feat: 添加更多重构模块 (第7批)

包含 IO 和 math 模块的实现：
- IO: initia, levcd, linset, ltegr, ltegrd, odfset, outpri, resolv, srtfrq, start, tabini, xenini
- Math: accel2, alisk1, alisk2, alist1, alist2, concor, conout, conref, contmd, contmp, coolrt, greyd, inilam, linsel, lucy, lymlin, matcon, matgen, moleq, newdm, newdmt, odf1, opacf0, opacf1, opacfa, opacfd, opacfl, opactr, opadd, opahst, pgset, princ, prnt, pzeval, quasim, radpre, radtot, rates1, ratsp1, rdata, rdatax, rechck, rhoeos, rhonen, rhsgen, rossop, rtecf1, rtecmc, rtecmu, rtecom, rtefr1, rteint, russel, rybchn, rybene, rybheq, rybsol, sgmer1, sigave, sigk, solve, solves, state, steqeq, temcor, temper, topbas, trmder, trmdrt

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

src/math/alisk1.rs

@@ -0,0 +1,899 @@
+//! ALI (加速 Lambda 迭代) Kantorovich 迭代简化版本。
+//!
+//! 重构自 TLUSTY `alisk1.f`
+//!
+//! # 功能
+//!
+//! 简化版 ALIST1，用于 Kantorovich 迭代。
+//! 计算所有必要的 ALI 参数和辐射跃迁率。
+//!
+//! # 算法
+//!
+//! 1. 初始化速率和其他量
+//! 2. 确定是否计算 Rosseland 平均不透明度
+//! 3. 遍历所有频率点：
+//!    - 计算不透明度 (OPACF1)
+//!    - 求解辐射转移方程 (RTEFR1)
+//!    - 计算 ALI 系数 (ALIFRK)
+//!    - 可选：计算 Rosseland 贡献 (ROSSTD)
+//!    - 处理连续谱跃迁
+//!    - 处理线跃迁
+//! 4. 后处理：乘以频率无关常数
+//! 5. 辐射压力计算
+//! 6. Rosseland 平均不透明度
+
+use crate::state::constants::{MDEPTH, MFREQ, MTRANS, UN, HK, PCK};
+
+// ============================================================================
+// 配置结构体
+// ============================================================================
+
+/// ALISK1 配置参数。
+#[derive(Debug, Clone)]
+pub struct Alisk1Config {
+    /// 深度修正数（负值表示不计算 Rosseland）
+    pub ndre: i32,
+    /// 当前迭代次数
+    pub iter: i32,
+    /// 最终迭代标志
+    pub lfin: bool,
+    /// 混合参数 (>0 强制计算 Rosseland)
+    pub hmix0: f64,
+    /// 不透明度表格标志 (<0 跳过跃迁处理)
+    pub ioptab: i32,
+    /// 盘模式标志
+    pub idisk: i32,
+}
+
+impl Default for Alisk1Config {
+    fn default() -> Self {
+        Self {
+            ndre: 0,
+            iter: 1,
+            lfin: false,
+            hmix0: 0.0,
+            ioptab: 0,
+            idisk: 0,
+        }
+    }
+}
+
+// ============================================================================
+// 输入/输出结构体
+// ============================================================================
+
+/// ALISK1 频率相关参数。
+pub struct Alisk1FreqParams<'a> {
+    /// 频率数
+    pub nfreq: usize,
+    /// 频率数组 [nfreq]
+    pub freq: &'a [f64],
+    /// 频率权重 [nfreq]
+    pub w0e: &'a [f64],
+    /// 频率索引标志 (-1 表示跳过) [nfreq]
+    pub ijx: &'a [i32],
+    /// 扩展频率索引 (>0 表示扩展) [nfreq]
+    pub ijex: &'a [i32],
+    /// 线频率索引 (>0 表示有线) [nfreq]
+    pub ijlin: &'a [i32],
+    /// 重叠线数 [nfreq]
+    pub nlines: &'a [i32],
+    /// 普朗克函数 [nfreq × nd] - BNUE
+    pub bnue: &'a [f64],
+}
+
+/// ALISK1 原子参数。
+pub struct Alisk1AtomicParams<'a> {
+    /// 连续谱跃迁数
+    pub ntranc: usize,
+    /// 总跃迁数
+    pub ntrans: usize,
+    /// 束缚-自由跃迁索引 [ntranc], 1-indexed
+    pub itrbf: &'a [i32],
+    /// 低能级索引 [ntrans], 1-indexed
+    pub ilow: &'a [i32],
+    /// 高能级索引 [ntrans], 1-indexed
+    pub iup: &'a [i32],
+    /// Macfarlane 下沉修正索引 [ntrans]
+    pub mcdw: &'a [i32],
+    /// 能级合并组索引 [mlevel]
+    pub imrg: &'a [i32],
+    /// 能级频率加权选项 [mlevel]
+    pub ifwop: &'a [i32],
+    /// 束缚-自由截面 [ntranc × nfreq]
+    pub cross: &'a [f64],
+    /// 线线型 [nfreq × nd] - PRFLIN
+    pub prflin: &'a [f64],
+    /// 重叠线跃迁索引 [maxlines × nfreq], 1-indexed
+    pub trlin: &'a [i32],
+    /// 跃迁起始频率索引 [ntrans]
+    pub ifr0: &'a [i32],
+    /// 跃迁结束频率索引 [ntrans]
+    pub ifr1: &'a [i32],
+    /// 线排除标志 [ntrans]
+    pub linexp: &'a [bool],
+    /// 合并 Gaunt 因子 [mmer × nd]
+    pub sgmg: &'a [f64],
+    /// 下沉因子 [maxcdw × nd]
+    pub dwf1: &'a [f64],
+    /// ITRA 索引矩阵 [mlevel × mlevel]
+    pub itra: &'a [i32],
+}
+
+/// ALISK1 模型状态参数。
+pub struct Alisk1ModelState<'a> {
+    /// 深度点数
+    pub nd: usize,
+    /// 温度 [nd]
+    pub temp: &'a [f64],
+    /// 电子密度 [nd]
+    pub elec: &'a [f64],
+    /// 总粒子密度 [nd]
+    pub dens: &'a [f64],
+    /// 密度倒数 [nd]
+    pub dens1: &'a [f64],
+    /// 柱质量密度 [nd]
+    pub dm: &'a [f64],
+    /// HK/T [nd]
+    pub hkt1: &'a [f64],
+    /// 辐射等效积分 [nd]
+    pub reint: &'a [f64],
+    /// 辐射等效扩散 [nd]
+    pub redif: &'a [f64],
+    /// CRSW 修正因子 [nd]
+    pub crsw: &'a [f64],
+    /// 零占据数标志 [mlevel × nd]
+    pub ipzero: &'a [i32],
+}
+
+/// ALISK1 输出状态。
+pub struct Alisk1OutputState<'a> {
+    // 累积量 [nd]
+    /// 冷却率积分
+    pub fcooli: &'a mut [f64],
+    /// 固定辐射通量
+    pub flfix: &'a mut [f64],
+    /// 辐射压力导数
+    pub fprd: &'a mut [f64],
+    /// 辐射通量红翼
+    pub flrd: &'a mut [f64],
+    /// 辐射压力总量
+    pub pradt: &'a mut [f64],
+    /// 辐射压力吸收
+    pub prada: &'a mut [f64],
+    /// 参考辐射压力 [输出]
+    pub prd0: &'a mut f64,
+
+    // 跃迁率 [ntrans × nd]
+    /// 向上跃迁率
+    pub rru: &'a mut [f64],
+    /// 向下跃迁率
+    pub rrd: &'a mut [f64],
+
+    // Rosseland 平均
+    /// Rosseland 平均不透明度 [nd]
+    pub abrosd: &'a mut [f64],
+    /// Rosseland 累加量 [nd]
+    pub sumdpl: &'a mut [f64],
+
+    // 扩展频率数据
+    /// 扩展吸收系数 [存储索引 × nd]
+    pub absoex: &'a mut [f64],
+    /// 扩展发射系数 [存储索引 × nd]
+    pub emisex: &'a mut [f64],
+    /// 扩展散射系数 [存储索引 × nd]
+    pub scatex: &'a mut [f64],
+
+    // 单频率工作数组（由 OPACF1/RTEFR1 填充）
+    /// 当前频率吸收系数 [nd]
+    pub abso1: &'a mut [f64],
+    /// 当前频率发射系数 [nd]
+    pub emis1: &'a mut [f64],
+    /// 当前频率散射系数 [nd]
+    pub scat1: &'a mut [f64],
+    /// 当前频率辐射强度 [nd]
+    pub rad1: &'a mut [f64],
+}
+
+/// ALISK1 输出结果。
+#[derive(Debug, Clone)]
+pub struct Alisk1Output {
+    /// 是否执行了计算
+    pub computed: bool,
+    /// Rosseland 标志
+    pub lross: bool,
+    /// 最小辐射压力比
+    pub prdx: f64,
+}
+
+// ============================================================================
+// 核心计算函数
+// ============================================================================
+
+/// ALI Kantorovich 迭代简化版本 (ALISK1)。
+///
+/// 计算所有必要的 ALI 参数和辐射跃迁率。
+///
+/// # 参数
+///
+/// * `config` - 配置参数
+/// * `freq_params` - 频率相关参数
+/// * `atomic_params` - 原子参数
+/// * `model_state` - 模型状态
+/// * `output_state` - 输出状态（可变）
+///
+/// # 返回值
+///
+/// 返回 `Alisk1Output`，包含计算结果信息。
+///
+/// # 注意
+///
+/// 此函数是一个框架实现，实际调用 OPACF1、RTEFR1、ALIFRK、ROSSTD
+/// 需要在完整系统中实现。当前版本主要用于结构验证。
+pub fn alisk1_pure(
+    config: &Alisk1Config,
+    freq_params: &Alisk1FreqParams,
+    atomic_params: &Alisk1AtomicParams,
+    model_state: &Alisk1ModelState,
+    output_state: &mut Alisk1OutputState,
+) -> Alisk1Output {
+    let nd = model_state.nd;
+    let nfreq = freq_params.nfreq;
+    let ntrans = atomic_params.ntrans;
+
+    // ========================================================================
+    // 1. 初始化速率和其他量
+    // ========================================================================
+    for id in 0..nd {
+        output_state.fcooli[id] = 0.0;
+        output_state.flfix[id] = 0.0;
+        output_state.fprd[id] = 0.0;
+        output_state.flrd[id] = 0.0;
+        output_state.pradt[id] = 0.0;
+        output_state.prada[id] = 0.0;
+
+        for itr in 0..ntrans {
+            output_state.rru[itr * nd + id] = 0.0;
+            output_state.rrd[itr * nd + id] = 0.0;
+        }
+    }
+    *output_state.prd0 = 0.0;
+
+    // ========================================================================
+    // 2. 确定 LROSS 标志
+    // ========================================================================
+    // LROSS = NDRE.LE.0.AND.ITER.EQ.1.OR.LFIN
+    // IF(HMIX0.GT.0.) LROSS=.TRUE.
+    let mut lross = (config.ndre <= 0 && config.iter == 1) || config.lfin;
+    if config.hmix0 > 0.0 {
+        lross = true;
+    }
+
+    if lross {
+        for id in 0..nd {
+            output_state.abrosd[id] = 0.0;
+            output_state.sumdpl[id] = 0.0;
+        }
+    }
+
+    // ========================================================================
+    // 3. 遍历频率点
+    // ========================================================================
+    for ij in 0..nfreq {
+        // 跳过标记为 -1 的频率
+        if freq_params.ijx[ij] == -1 {
+            continue;
+        }
+
+        let fr = freq_params.freq[ij];
+        let w0 = freq_params.w0e[ij];
+
+        // ----------------------------------------------------------------
+        // 3a. 调用 OPACF1(IJ) - 计算不透明度
+        // ----------------------------------------------------------------
+        // 注意：实际实现需要调用 opacf1 函数
+        // 这里只是框架，假设 abso1, emis1, scat1 已填充
+
+        // ----------------------------------------------------------------
+        // 3b. 存储扩展频率数据
+        // ----------------------------------------------------------------
+        let ije = freq_params.ijex[ij];
+        if ije > 0 {
+            let ije_idx = (ije - 1) as usize;
+            for id in 0..nd {
+                output_state.absoex[ije_idx * nd + id] = output_state.abso1[id];
+                output_state.emisex[ije_idx * nd + id] = output_state.emis1[id];
+                output_state.scatex[ije_idx * nd + id] = output_state.scat1[id];
+            }
+        }
+
+        // ----------------------------------------------------------------
+        // 3c. 调用 RTEFR1(IJ) - 辐射转移
+        // ----------------------------------------------------------------
+        // 注意：实际实现需要调用 rtefr1 函数
+
+        // ----------------------------------------------------------------
+        // 3d. 调用 ALIFRK(IJ) - ALI 系数
+        // ----------------------------------------------------------------
+        // 注意：实际实现需要调用 alifrk 函数
+
+        // ----------------------------------------------------------------
+        // 3e. 可选：调用 ROSSTD(IJ) - Rosseland 贡献
+        // ----------------------------------------------------------------
+        // if lross { rosstd_contribute(...); }
+
+        // 跳过跃迁处理（如果 ioptab < 0）
+        if config.ioptab < 0 {
+            continue;
+        }
+
+        // ----------------------------------------------------------------
+        // 3f. 处理连续谱跃迁
+        // ----------------------------------------------------------------
+        process_continuum_transitions(
+            ij,
+            fr,
+            w0,
+            nd,
+            freq_params,
+            atomic_params,
+            model_state,
+            output_state,
+        );
+
+        // ----------------------------------------------------------------
+        // 3g. 处理线跃迁
+        // ----------------------------------------------------------------
+        process_line_transitions(
+            ij,
+            fr,
+            w0,
+            nd,
+            freq_params,
+            atomic_params,
+            model_state,
+            output_state,
+        );
+    }
+
+    // ========================================================================
+    // 4. 后处理：乘以频率无关常数
+    // ========================================================================
+    for id in 0..nd {
+        // FCOOL(ID) = REINT(ID) * FCOOLI(ID) - REDIF(ID) * FLFIX(ID)
+        // 注意：这里更新的是 fcooli，完整的 fcool 计算在外部
+
+        // CRSW 修正
+        if (model_state.crsw[id] - UN).abs() > 1e-30 {
+            for itr in 0..ntrans {
+                output_state.rru[itr * nd + id] *= model_state.crsw[id];
+                output_state.rrd[itr * nd + id] *= model_state.crsw[id];
+            }
+        }
+    }
+
+    // ========================================================================
+    // 5. 辐射压力计算
+    // ========================================================================
+    let mut prdx = 1.0;
+    for id in 0..nd {
+        output_state.pradt[id] *= PCK;
+        output_state.prada[id] *= PCK;
+
+        if output_state.prada[id] > 0.0 {
+            let prdr = output_state.pradt[id] / output_state.prada[id];
+            if prdr < prdx {
+                prdx = prdr;
+            }
+        }
+    }
+
+    // PRD0 = PRD0 / DENS1(1) * DM(1) * PCK
+    *output_state.prd0 = *output_state.prd0 / model_state.dens1[0] * model_state.dm[0] * PCK;
+
+    // ========================================================================
+    // 6. Rosseland 平均不透明度
+    // ========================================================================
+    if lross {
+        for id in 0..nd {
+            if output_state.abrosd[id] > 0.0 {
+                output_state.abrosd[id] =
+                    output_state.sumdpl[id] / (output_state.abrosd[id] * model_state.dens[id]);
+            }
+        }
+    }
+
+    Alisk1Output {
+        computed: true,
+        lross,
+        prdx,
+    }
+}
+
+/// 处理连续谱跃迁。
+fn process_continuum_transitions(
+    ij: usize,
+    fr: f64,
+    w0: f64,
+    nd: usize,
+    freq_params: &Alisk1FreqParams,
+    atomic_params: &Alisk1AtomicParams,
+    model_state: &Alisk1ModelState,
+    output_state: &mut Alisk1OutputState,
+) {
+    let ntranc = atomic_params.ntranc;
+
+    // 工作数组 RBNU(MDEPTH)
+    let mut rbnu = vec![0.0; MDEPTH];
+
+    // 计算 RBNU = (RAD1 + BNUE) * EXP(-HKT1 * FR)
+    for id in 0..nd {
+        let bnue_ij = freq_params.bnue[ij * nd + id];
+        rbnu[id] = (output_state.rad1[id] + bnue_ij) * (-model_state.hkt1[id] * fr).exp();
+    }
+
+    // 遍历连续谱跃迁
+    for ibft in 0..ntranc {
+        let itr = (atomic_params.itrbf[ibft] - 1) as usize; // 1-indexed to 0-indexed
+        let sg = atomic_params.cross[ibft * freq_params.nfreq + ij];
+
+        if sg <= 0.0 {
+            continue;
+        }
+
+        let ii = (atomic_params.ilow[itr] - 1) as usize;
+        let jj = (atomic_params.iup[itr] - 1) as usize;
+
+        // 检查零占据数
+        for id in 0..nd {
+            if model_state.ipzero[ii * nd + id] != 0 || model_state.ipzero[jj * nd + id] != 0 {
+                continue;
+            }
+
+            let jc = (atomic_params.itra[jj * ii + jj] - 1) as usize; // ITRA(JJ, II)
+            let icdw = atomic_params.mcdw[itr];
+            let imer = atomic_params.imrg[ii] as usize;
+
+            let mut sg_local = sg;
+
+            // 频率加权修正
+            if atomic_params.ifwop[ii] >= 0 {
+                if icdw >= 1 {
+                    let icdw_idx = (icdw - 1) as usize;
+                    sg_local *= atomic_params.dwf1[icdw_idx * nd + id];
+                }
+            } else {
+                sg_local = atomic_params.sgmg[imer * nd + id];
+            }
+
+            let sgw0 = sg_local * w0;
+
+            // 累积跃迁率
+            output_state.rru[itr * nd + id] += sgw0 * output_state.rad1[id];
+            output_state.rrd[itr * nd + id] += sgw0 * rbnu[id];
+        }
+    }
+}
+
+/// 处理线跃迁。
+fn process_line_transitions(
+    ij: usize,
+    fr: f64,
+    w0: f64,
+    nd: usize,
+    freq_params: &Alisk1FreqParams,
+    atomic_params: &Alisk1AtomicParams,
+    model_state: &Alisk1ModelState,
+    output_state: &mut Alisk1OutputState,
+) {
+    // 主线跃迁
+    let ijlin_ij = freq_params.ijlin[ij];
+    if ijlin_ij > 0 {
+        let itr = (ijlin_ij - 1) as usize; // 1-indexed to 0-indexed
+
+        for id in 0..nd {
+            let sgw0 = atomic_params.prflin[ij * nd + id] * w0;
+            let rbnu = output_state.rad1[id] * (-fr * HK / model_state.temp[id]).exp();
+
+            output_state.rru[itr * nd + id] += sgw0 * output_state.rad1[id];
+            output_state.rrd[itr * nd + id] += sgw0 * rbnu;
+        }
+    }
+
+    // 重叠线
+    let nlines_ij = freq_params.nlines[ij];
+    if nlines_ij <= 0 {
+        return;
+    }
+
+    for ilint in 0..nlines_ij as usize {
+        let itr = (atomic_params.trlin[ilint * freq_params.nfreq + ij] - 1) as usize;
+
+        // 检查线排除
+        if atomic_params.linexp[itr] {
+            continue;
+        }
+
+        let ij0 = atomic_params.ifr0[itr] as usize;
+        let ij1 = atomic_params.ifr1[itr] as usize;
+
+        // 查找插值位置
+        let mut ij0_idx = ij0;
+        for ijt in ij0..=ij1 {
+            if freq_params.freq[ijt] <= fr {
+                ij0_idx = ijt;
+                break;
+            }
+        }
+
+        let ij1_idx = if ij0_idx > 0 { ij0_idx - 1 } else { 0 };
+
+        // 插值系数
+        let freq_ij0 = freq_params.freq[ij0_idx];
+        let freq_ij1 = freq_params.freq[ij1_idx];
+        let denom = freq_ij1 - freq_ij0;
+
+        let (a1, a2) = if denom.abs() > 1e-30 {
+            let a1 = (fr - freq_ij0) / denom * w0;
+            (a1, w0 - a1)
+        } else {
+            (w0, 0.0)
+        };
+
+        // 累积跃迁率
+        for id in 0..nd {
+            let sgw0 = a1 * atomic_params.prflin[ij1_idx * nd + id]
+                + a2 * atomic_params.prflin[ij0_idx * nd + id];
+            let rbnu = output_state.rad1[id] * (-fr * HK / model_state.temp[id]).exp();
+
+            output_state.rru[itr * nd + id] += sgw0 * output_state.rad1[id];
+            output_state.rrd[itr * nd + id] += sgw0 * rbnu;
+        }
+    }
+}
+
+// ============================================================================
+// 测试
+// ============================================================================
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn create_test_config() -> Alisk1Config {
+        Alisk1Config {
+            ndre: 0,
+            iter: 1,
+            lfin: false,
+            hmix0: 0.0,
+            ioptab: -1, // 跳过跃迁处理
+            idisk: 0,
+        }
+    }
+
+    #[test]
+    fn test_alisk1_initialization() {
+        let config = create_test_config();
+
+        // 创建最小测试数据
+        let nfreq = 10;
+        let nd = 5;
+        let ntrans = 3;
+
+        let freq = vec![1e14; nfreq];
+        let w0e = vec![1.0; nfreq];
+        let ijx = vec![0; nfreq];
+        let ijex = vec![0; nfreq];
+        let ijlin = vec![0; nfreq];
+        let nlines = vec![0; nfreq];
+        let bnue = vec![0.0; nfreq * nd];
+
+        let freq_params = Alisk1FreqParams {
+            nfreq,
+            freq: &freq,
+            w0e: &w0e,
+            ijx: &ijx,
+            ijex: &ijex,
+            ijlin: &ijlin,
+            nlines: &nlines,
+            bnue: &bnue,
+        };
+
+        let itrbf = vec![1, 2, 3];
+        let ilow = vec![1, 1, 2];
+        let iup = vec![2, 3, 3];
+        let mcdw = vec![0; ntrans];
+        let imrg = vec![0; 10];
+        let ifwop = vec![0; 10];
+        let cross = vec![0.0; 3 * nfreq];
+        let prflin = vec![0.0; nfreq * nd];
+        let trlin = vec![0; 10 * nfreq];
+        let ifr0 = vec![0; ntrans];
+        let ifr1 = vec![0; ntrans];
+        let linexp = vec![false; ntrans];
+        let sgmg = vec![1.0; 5 * nd];
+        let dwf1 = vec![1.0; 5 * nd];
+        let itra = vec![0; 100];
+
+        let atomic_params = Alisk1AtomicParams {
+            ntranc: 3,
+            ntrans,
+            itrbf: &itrbf,
+            ilow: &ilow,
+            iup: &iup,
+            mcdw: &mcdw,
+            imrg: &imrg,
+            ifwop: &ifwop,
+            cross: &cross,
+            prflin: &prflin,
+            trlin: &trlin,
+            ifr0: &ifr0,
+            ifr1: &ifr1,
+            linexp: &linexp,
+            sgmg: &sgmg,
+            dwf1: &dwf1,
+            itra: &itra,
+        };
+
+        let temp = vec![10000.0; nd];
+        let elec = vec![1e12; nd];
+        let dens = vec![1e14; nd];
+        let dens1 = vec![1e-14; nd];
+        let dm = vec![1e-3; nd];
+        let hkt1 = vec![4.8e-12; nd];
+        let reint = vec![1.0; nd];
+        let redif = vec![0.0; nd];
+        let crsw = vec![1.0; nd];
+        let ipzero = vec![0; 100 * nd];
+
+        let model_state = Alisk1ModelState {
+            nd,
+            temp: &temp,
+            elec: &elec,
+            dens: &dens,
+            dens1: &dens1,
+            dm: &dm,
+            hkt1: &hkt1,
+            reint: &reint,
+            redif: &redif,
+            crsw: &crsw,
+            ipzero: &ipzero,
+        };
+
+        let mut fcooli = vec![0.0; nd];
+        let mut flfix = vec![0.0; nd];
+        let mut fprd = vec![0.0; nd];
+        let mut flrd = vec![0.0; nd];
+        let mut pradt = vec![0.0; nd];
+        let mut prada = vec![0.0; nd];
+        let mut prd0 = 0.0;
+        let mut rru = vec![0.0; ntrans * nd];
+        let mut rrd = vec![0.0; ntrans * nd];
+        let mut abrosd = vec![0.0; nd];
+        let mut sumdpl = vec![0.0; nd];
+        let mut absoex = vec![0.0; 10 * nd];
+        let mut emisex = vec![0.0; 10 * nd];
+        let mut scatex = vec![0.0; 10 * nd];
+        let mut abso1 = vec![1.0; nd];
+        let mut emis1 = vec![0.5; nd];
+        let mut scat1 = vec![0.1; nd];
+        let mut rad1 = vec![0.8; nd];
+
+        let mut output_state = Alisk1OutputState {
+            fcooli: &mut fcooli,
+            flfix: &mut flfix,
+            fprd: &mut fprd,
+            flrd: &mut flrd,
+            pradt: &mut pradt,
+            prada: &mut prada,
+            prd0: &mut prd0,
+            rru: &mut rru,
+            rrd: &mut rrd,
+            abrosd: &mut abrosd,
+            sumdpl: &mut sumdpl,
+            absoex: &mut absoex,
+            emisex: &mut emisex,
+            scatex: &mut scatex,
+            abso1: &mut abso1,
+            emis1: &mut emis1,
+            scat1: &mut scat1,
+            rad1: &mut rad1,
+        };
+
+        let output = alisk1_pure(&config, &freq_params, &atomic_params, &model_state, &mut output_state);
+
+        assert!(output.computed);
+        assert!(output.lross); // 因为 iter=1 且 ndre=0
+    }
+
+    #[test]
+    fn test_alisk1_skip_frequency() {
+        let mut config = create_test_config();
+
+        let nfreq = 5;
+        let nd = 3;
+        let ntrans = 2;
+
+        // 设置 IJX[0] = -1，应该跳过第一个频率
+        let freq = vec![1e14; nfreq];
+        let w0e = vec![1.0; nfreq];
+        let ijx = vec![-1, 0, 0, 0, 0];
+        let ijex = vec![0; nfreq];
+        let ijlin = vec![0; nfreq];
+        let nlines = vec![0; nfreq];
+        let bnue = vec![0.0; nfreq * nd];
+
+        let freq_params = Alisk1FreqParams {
+            nfreq,
+            freq: &freq,
+            w0e: &w0e,
+            ijx: &ijx,
+            ijex: &ijex,
+            ijlin: &ijlin,
+            nlines: &nlines,
+            bnue: &bnue,
+        };
+
+        let itrbf = vec![1, 2];
+        let ilow = vec![1, 2];
+        let iup = vec![2, 3];
+        let mcdw = vec![0; ntrans];
+        let imrg = vec![0; 10];
+        let ifwop = vec![0; 10];
+        let cross = vec![0.0; 2 * nfreq];
+        let prflin = vec![0.0; nfreq * nd];
+        let trlin = vec![0; 10 * nfreq];
+        let ifr0 = vec![0; ntrans];
+        let ifr1 = vec![0; ntrans];
+        let linexp = vec![false; ntrans];
+        let sgmg = vec![1.0; 5 * nd];
+        let dwf1 = vec![1.0; 5 * nd];
+        let itra = vec![0; 100];
+
+        let atomic_params = Alisk1AtomicParams {
+            ntranc: 2,
+            ntrans,
+            itrbf: &itrbf,
+            ilow: &ilow,
+            iup: &iup,
+            mcdw: &mcdw,
+            imrg: &imrg,
+            ifwop: &ifwop,
+            cross: &cross,
+            prflin: &prflin,
+            trlin: &trlin,
+            ifr0: &ifr0,
+            ifr1: &ifr1,
+            linexp: &linexp,
+            sgmg: &sgmg,
+            dwf1: &dwf1,
+            itra: &itra,
+        };
+
+        let temp = vec![10000.0; nd];
+        let elec = vec![1e12; nd];
+        let dens = vec![1e14; nd];
+        let dens1 = vec![1e-14; nd];
+        let dm = vec![1e-3; nd];
+        let hkt1 = vec![4.8e-12; nd];
+        let reint = vec![1.0; nd];
+        let redif = vec![0.0; nd];
+        let crsw = vec![1.0; nd];
+        let ipzero = vec![0; 100 * nd];
+
+        let model_state = Alisk1ModelState {
+            nd,
+            temp: &temp,
+            elec: &elec,
+            dens: &dens,
+            dens1: &dens1,
+            dm: &dm,
+            hkt1: &hkt1,
+            reint: &reint,
+            redif: &redif,
+            crsw: &crsw,
+            ipzero: &ipzero,
+        };
+
+        let mut fcooli = vec![0.0; nd];
+        let mut flfix = vec![0.0; nd];
+        let mut fprd = vec![0.0; nd];
+        let mut flrd = vec![0.0; nd];
+        let mut pradt = vec![0.0; nd];
+        let mut prada = vec![0.0; nd];
+        let mut prd0 = 0.0;
+        let mut rru = vec![0.0; ntrans * nd];
+        let mut rrd = vec![0.0; ntrans * nd];
+        let mut abrosd = vec![0.0; nd];
+        let mut sumdpl = vec![0.0; nd];
+        let mut absoex = vec![0.0; 10 * nd];
+        let mut emisex = vec![0.0; 10 * nd];
+        let mut scatex = vec![0.0; 10 * nd];
+        let mut abso1 = vec![1.0; nd];
+        let mut emis1 = vec![0.5; nd];
+        let mut scat1 = vec![0.1; nd];
+        let mut rad1 = vec![0.8; nd];
+
+        let mut output_state = Alisk1OutputState {
+            fcooli: &mut fcooli,
+            flfix: &mut flfix,
+            fprd: &mut fprd,
+            flrd: &mut flrd,
+            pradt: &mut pradt,
+            prada: &mut prada,
+            prd0: &mut prd0,
+            rru: &mut rru,
+            rrd: &mut rrd,
+            abrosd: &mut abrosd,
+            sumdpl: &mut sumdpl,
+            absoex: &mut absoex,
+            emisex: &mut emisex,
+            scatex: &mut scatex,
+            abso1: &mut abso1,
+            emis1: &mut emis1,
+            scat1: &mut scat1,
+            rad1: &mut rad1,
+        };
+
+        let output = alisk1_pure(&config, &freq_params, &atomic_params, &model_state, &mut output_state);
+
+        assert!(output.computed);
+    }
+
+    #[test]
+    fn test_lross_determination() {
+        // 测试 LROSS 标志的各种条件
+
+        // 条件 1: ndre <= 0 AND iter == 1
+        let config1 = Alisk1Config {
+            ndre: 0,
+            iter: 1,
+            lfin: false,
+            hmix0: 0.0,
+            ioptab: -1,
+            idisk: 0,
+        };
+        // LROSS 应该为 true
+
+        // 条件 2: lfin = true
+        let config2 = Alisk1Config {
+            ndre: 1,
+            iter: 2,
+            lfin: true,
+            hmix0: 0.0,
+            ioptab: -1,
+            idisk: 0,
+        };
+        // LROSS 应该为 true
+
+        // 条件 3: hmix0 > 0
+        let config3 = Alisk1Config {
+            ndre: 1,
+            iter: 2,
+            lfin: false,
+            hmix0: 1.0,
+            ioptab: -1,
+            idisk: 0,
+        };
+        // LROSS 应该为 true
+
+        // 条件 4: 所有条件都不满足
+        let config4 = Alisk1Config {
+            ndre: 1,
+            iter: 2,
+            lfin: false,
+            hmix0: 0.0,
+            ioptab: -1,
+            idisk: 0,
+        };
+        // LROSS 应该为 false
+
+        // 简单验证配置创建
+        assert!(config1.ndre <= 0 && config1.iter == 1);
+        assert!(config2.lfin);
+        assert!(config3.hmix0 > 0.0);
+        assert!(!(config4.ndre <= 0 && config4.iter == 1)
+            && !config4.lfin
+            && !(config4.hmix0 > 0.0));
+    }
+}