更新未实现的测试代码

src/tlusty/math/alifr1.rs

@@ -1458,26 +1458,113 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_alifr1_ifali_le_1() {
+    fn test_alifr1_basic() {
-        // 测试 IFALI <= 1 时直接返回
+        // Setup minimal dimensions
-        let params = Alifr1Params {
+        const ND: usize = 3;
-            ij: 1,
+        const NFREQ: usize = 2;
-            nd: 10,
+        const NLVEXP: usize = 2;
-            nlvexp: 5,
-            ifali: 1,
-            irder: 1,
-            ilmcor: 3,
-            ilasct: 0,
-            ibc: 0,
-            idisk: 0,
-            ifalih: 0,
-        };
 
-        // 创建空的 FixAlp（实际使用需要完整初始化）
+        let params = Alifr1Params {
+            ij: 1, nd: ND, nlvexp: NLVEXP, ifali: 3, irder: 3,
+            ilmcor: 3, ilasct: 0, ibc: 0, idisk: 0, ifalih: 0,
+        };
         let mut fixalp = FixAlp::default();
 
-        // 简单测试：确保函数不会 panic
+        let elec = vec![1.0; ND];
-        // 实际测试需要完整的模型状态
+        let dens = vec![1.0; ND];
-        let _ = (&params, &mut fixalp);
+        let densi = vec![1.0; ND];
+        let densim = vec![1.0; ND];
+        let dens1 = vec![1.0; ND];
+        let dm = vec![1.0; ND];
+        let deldmz = vec![1.0; ND];
+        let elscat = vec![0.1; ND];
+        let absot = vec![1.0; ND];
+        let hkt21 = vec![1.0; ND];
+        let xkfb = vec![1.0; ND];
+        let xkf1 = vec![1.0; ND];
+
+        let rad1 = vec![1.0; ND];
+        let fak1 = vec![1.0; ND];
+
+        let freq = vec![1e15; NFREQ];
+        let hextrd = vec![0.0; NFREQ];
+        let sigec = vec![0.0; NFREQ];
+        let sige = 0.0;
+        let extrad = vec![0.0; NFREQ];
+        let fh = vec![1.0; NFREQ];
+        let w = vec![1.0; NFREQ];
+        let q0 = vec![0.0; NFREQ];
+
+        let lskip = vec![vec![0; NFREQ]; ND]; // 0 means false (don't skip)
+
+        let reint = vec![1.0; ND];
+        let redif = vec![1.0; ND];
+
+        let mut fprd = vec![0.0; ND];
+        let mut flfix = vec![0.0; ND];
+        let mut flrd = vec![0.0; ND];
+        let mut fcooli = vec![0.0; ND];
+        let mut heit = vec![0.0; ND];
+        let mut hein = vec![0.0; ND];
+        let mut heim = vec![0.0; ND];
+        let mut heitm = vec![0.0; ND];
+        let mut heinm = vec![0.0; ND];
+        let mut heimm = vec![0.0; ND];
+        let mut heip = vec![vec![0.0; ND]; NLVEXP];
+        let mut heipm = vec![vec![0.0; ND]; NLVEXP];
+        let mut redt = vec![0.0; ND];
+        let mut redn = vec![0.0; ND];
+        let mut redm = vec![0.0; ND];
+        let mut redx = vec![0.0; ND];
+        let mut redtm = vec![0.0; ND];
+        let mut rednm = vec![0.0; ND];
+        let mut redmm = vec![0.0; ND];
+        let mut redxm = vec![0.0; ND];
+        let mut redp = vec![vec![0.0; ND]; NLVEXP];
+        let mut redpm = vec![vec![0.0; ND]; NLVEXP];
+        let mut rein = vec![0.0; ND];
+        let mut reit = vec![0.0; ND];
+        let mut reim = vec![0.0; ND];
+        let mut reip = vec![vec![0.0; ND]; NLVEXP];
+
+        let mut model = Alifr1ModelState {
+            elec: &elec, dens: &dens, densi: &densi, densim: &densim, dens1: &dens1,
+            dm: &dm, deldmz: &deldmz, elscat: &elscat, absot: &absot, hkt21: &hkt21,
+            xkfb: &xkfb, xkf1: &xkf1, rad1: &rad1, fak1: &fak1,
+            freq: &freq, hextrd: &hextrd, sigec: &sigec, sige, extrad: &extrad, fh: &fh, w: &w, q0: &q0,
+            lskip: &lskip, reint: &reint, redif: &redif,
+            fprd: &mut fprd, flfix: &mut flfix, flrd: &mut flrd, fcooli: &mut fcooli,
+            heit: &mut heit, hein: &mut hein, heim: &mut heim,
+            heitm: &mut heitm, heinm: &mut heinm, heimm: &mut heimm,
+            heip: &mut heip, heipm: &mut heipm,
+            redt: &mut redt, redn: &mut redn, redm: &mut redm, redx: &mut redx,
+            redtm: &mut redtm, rednm: &mut rednm, redmm: &mut redmm, redxm: &mut redxm,
+            redp: &mut redp, redpm: &mut redpm,
+            rein: &mut rein, reit: &mut reit, reim: &mut reim, reip: &mut reip,
+        };
+
+        let wc = vec![1.0; NFREQ];
+        let emis1 = vec![1.0; ND];
+        let abso1 = vec![1.0; ND];
+        let scat1 = vec![0.1; ND];
+        let demt1 = vec![0.1; ND];
+        let demn1 = vec![0.1; ND];
+        let demm1 = vec![0.1; ND];
+        let dabt1 = vec![0.1; ND];
+        let dabn1 = vec![0.1; ND];
+        let dabm1 = vec![0.1; ND];
+        let demp1 = vec![vec![0.1; ND]; NLVEXP];
+        let dabp1 = vec![vec![0.1; ND]; NLVEXP];
+
+        let rad = Alifr1RadState {
+            wc: &wc, emis1: &emis1, abso1: &abso1, scat1: &scat1,
+            demt1: &demt1, demn1: &demn1, demm1: &demm1,
+            dabt1: &dabt1, dabn1: &dabn1, dabm1: &dabm1,
+            demp1: &demp1, dabp1: &dabp1,
+        };
+
+        let res = alifr1(&params, &mut fixalp, &mut model, &rad);
+        assert!(!res);
+        assert!(model.heit[0] != 0.0 || model.hein[0] != 0.0, "Heating rates should be updated");
     }
 }

src/tlusty/math/alifr6.rs

@@ -1000,19 +1000,130 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_alifr6_params_creation() {
+    fn test_alifr6_basic() {
+        // Setup minimal dimensions
+        const ND: usize = 3;
+        const NFREQ: usize = 2;
+        const NLVEXP: usize = 2;
+
         let params = Alifr6Params {
-            ij: 1,
+            ij: 1, nd: ND, nlvexp: NLVEXP, ifali: 7, irder: 3,
-            nd: 50,
+            ilmcor: 3, ilasct: 0, ibc: 0, idisk: 0,
-            nlvexp: 10,
-            ifali: 7,
-            irder: 3,
-            ilmcor: 0,
-            ilasct: 1,
-            ibc: 2,
-            idisk: 0,
         };
-        assert_eq!(params.ij, 1);
+
-        assert_eq!(params.nd, 50);
+        // Input arrays
+        let elec = vec![1.0; ND];
+        let densi = vec![1.0; ND];
+        let densim = vec![1.0; ND];
+        let dens1 = vec![1.0; ND];
+        let fak1 = vec![1.0; ND];
+        let deldmz = vec![1.0; ND];
+        let absot = vec![1.0; ND];
+        let hkt21 = vec![1.0; ND];
+        let rad1 = vec![1.0; ND];
+        let emis1 = vec![1.0; ND];
+        let abso1 = vec![1.0; ND];
+        let elscat = vec![0.1; ND];
+        let wc = vec![1.0; NFREQ];
+        let fh = vec![1.0; NFREQ];
+        let freq = vec![1e15; NFREQ];
+        let hextrd = vec![0.0; NFREQ];
+        let sigec = vec![0.0; NFREQ];
+        let lskip = vec![vec![0; NFREQ]; ND]; // 0 means false (don't skip)
+        let redif = vec![1.0; ND];
+        let reint = vec![1.0; ND];
+        let xkf1 = vec![1.0; ND];
+        let xkfb = vec![1.0; ND];
+        let ali1 = vec![1.0; ND];
+        let alim1 = vec![1.0; ND];
+        let alip1 = vec![1.0; ND];
+        let demt1 = vec![0.1; ND];
+        let demn1 = vec![0.1; ND];
+        let dabt1 = vec![0.1; ND];
+        let dabn1 = vec![0.1; ND];
+        let demp1 = vec![vec![0.1; ND]; NLVEXP];
+        let dabp1 = vec![vec![0.1; ND]; NLVEXP];
+
+        // Output arrays (mutable)
+        let mut heit = vec![0.0; ND];
+        let mut hein = vec![0.0; ND];
+        let mut heip = vec![vec![0.0; ND]; NLVEXP];
+        let mut heitm = vec![0.0; ND];
+        let mut heinm = vec![0.0; ND];
+        let mut heipm = vec![vec![0.0; ND]; NLVEXP];
+        let mut heitp = vec![0.0; ND];
+        let mut heinp = vec![0.0; ND];
+        let mut heipp = vec![vec![0.0; ND]; NLVEXP];
+        let mut redt = vec![0.0; ND];
+        let mut redn = vec![0.0; ND];
+        let mut redp = vec![vec![0.0; ND]; NLVEXP];
+        let mut redtm = vec![0.0; ND];
+        let mut rednm = vec![0.0; ND];
+        let mut redpm = vec![vec![0.0; ND]; NLVEXP];
+        let mut redtp = vec![0.0; ND];
+        let mut rednp = vec![0.0; ND];
+        let mut redpp = vec![vec![0.0; ND]; NLVEXP];
+        let mut redx = vec![0.0; ND];
+        let mut redxm = vec![0.0; ND];
+        let mut reit = vec![0.0; ND];
+        let mut rein = vec![0.0; ND];
+        let mut reip = vec![vec![0.0; ND]; NLVEXP];
+        let mut areit = vec![0.0; ND];
+        let mut arein = vec![0.0; ND];
+        let mut areip = vec![vec![0.0; ND]; NLVEXP];
+        let mut creit = vec![0.0; ND];
+        let mut crein = vec![0.0; ND];
+        let mut creip = vec![vec![0.0; ND]; NLVEXP];
+        let mut ehet = vec![0.0; ND];
+        let mut ehen = vec![0.0; ND];
+        let mut ehep = vec![vec![0.0; ND]; NLVEXP];
+        let mut eret = vec![0.0; ND];
+        let mut eren = vec![0.0; ND];
+        let mut erep = vec![vec![0.0; ND]; NLVEXP];
+        let mut dsfdt = vec![0.0; ND];
+        let mut dsfdn = vec![0.0; ND];
+        let mut dsfdp = vec![vec![0.0; ND]; NLVEXP];
+        let mut dsfdtm = vec![0.0; ND];
+        let mut dsfdnm = vec![0.0; ND];
+        let mut dsfdpm = vec![vec![0.0; ND]; NLVEXP];
+        let mut dsfdtp = vec![0.0; ND];
+        let mut dsfdnp = vec![0.0; ND];
+        let mut dsfdpp = vec![vec![0.0; ND]; NLVEXP];
+        let mut fprd = vec![0.0; ND];
+        let mut flfix = vec![0.0; ND];
+        let mut fcooli = vec![0.0; ND];
+
+        let mut state = Alifr6State {
+            elec: &elec, densi: &densi, densim: &densim, dens1: &dens1,
+            fak1: &fak1, deldmz: &deldmz, absot: &absot, hkt21: &hkt21,
+            rad1: &rad1, emis1: &emis1, abso1: &abso1, elscat: &elscat,
+            wc: &wc, fh: &fh, freq: &freq, hextrd: &hextrd, sigec: &sigec,
+            lskip: &lskip, redif: &redif, reint: &reint, xkf1: &xkf1, xkfb: &xkfb,
+            heit: &mut heit, hein: &mut hein, heip: &mut heip,
+            heitm: &mut heitm, heinm: &mut heinm, heipm: &mut heipm,
+            heitp: &mut heitp, heinp: &mut heinp, heipp: &mut heipp,
+            redt: &mut redt, redn: &mut redn, redp: &mut redp,
+            redtm: &mut redtm, rednm: &mut rednm, redpm: &mut redpm,
+            redtp: &mut redtp, rednp: &mut rednp, redpp: &mut redpp,
+            redx: &mut redx, redxm: &mut redxm,
+            reit: &mut reit, rein: &mut rein, reip: &mut reip,
+            areit: &mut areit, arein: &mut arein, areip: &mut areip,
+            creit: &mut creit, crein: &mut crein, creip: &mut creip,
+            ehet: &mut ehet, ehen: &mut ehen, ehep: &mut ehep,
+            eret: &mut eret, eren: &mut eren, erep: &mut erep,
+            dsfdt: &mut dsfdt, dsfdn: &mut dsfdn, dsfdp: &mut dsfdp,
+            dsfdtm: &mut dsfdtm, dsfdnm: &mut dsfdnm, dsfdpm: &mut dsfdpm,
+            dsfdtp: &mut dsfdtp, dsfdnp: &mut dsfdnp, dsfdpp: &mut dsfdpp,
+            fprd: &mut fprd, flfix: &mut flfix, fcooli: &mut fcooli,
+            ali1: &ali1, alim1: &alim1, alip1: &alip1,
+            demt1: &demt1, demn1: &demn1, dabt1: &dabt1, dabn1: &dabn1,
+            demp1: &demp1, dabp1: &dabp1,
+        };
+
+        // Call proper function
+        alifr6(&params, &mut state);
+
+        // Verification that some arrays got mutated instead of just checking parameters
+        assert!(state.heit[0] != 0.0 || state.dsfdt[0] != 0.0, "State should be mutated by alifr6");
     }
 }

src/tlusty/math/alist1.rs

@@ -730,73 +730,165 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_zero_rates_simple() {
+    fn test_alist1_pure_basic() {
-        let nd = 5;
+        const ND: usize = 2;
-        let nlvexp = 3;
+        const NFREQ: usize = 2;
-        let ntrans = 10;
+        const NLVEXP: usize = 2;
+        const NTRANS: usize = 2;
+        const NTRANC: usize = 1;
 
-        // 创建简单的速率数组并验证清零
+        let config = Alist1Config {
-        let mut reit = vec![1.0; nd];
+            nd: ND, nfreq: NFREQ, nlvexp: NLVEXP, ntrans: NTRANS, ntranc: NTRANC,
-        let mut rein = vec![2.0; nd];
+            ispodf: 0, ioptab: 1, iter: 1, ndre: 0, hmix0: 0.0, lfin: false,
-        let mut heip = vec![vec![3.0; nd]; nlvexp];
+        };
-        let mut rru = vec![vec![4.0; nd]; ntrans];
 
-        // 直接测试清零逻辑（不使用完整结构体）
+        // Freq params
-        for id in 0..nd {
+        let freq = vec![1e15; NFREQ];
-            reit[id] = 0.0;
+        let w0e = vec![1.0; NFREQ];
-            rein[id] = 0.0;
+        let ijx = vec![0; NFREQ]; // 0 means do not skip
-            for ii in 0..nlvexp {
+        let ijlin = vec![1, 0];
-                heip[ii][id] = 0.0;
+        let nlines = vec![0; NFREQ];
-            }
+        let itrlin = vec![vec![0; 5]; NFREQ];
-            for itr in 0..ntrans {
+        let ifr0 = vec![1; NTRANS];
-                rru[itr][id] = 0.0;
+        let ifr1 = vec![NFREQ as i32; NTRANS];
-            }
+        let kfr0 = vec![1; NTRANS];
-        }
+        let linexp = vec![false; NTRANS];
+        let prflin = vec![vec![1.0; NFREQ]; ND];
 
-        // 验证
+        let freq_params = Alist1FreqParams {
-        for id in 0..nd {
+            freq: &freq, w0e: &w0e, ijx: &ijx, ijlin: &ijlin, nlines: &nlines,
-            assert_eq!(reit[id], 0.0);
+            itrlin: &itrlin, ifr0: &ifr0, ifr1: &ifr1, kfr0: &kfr0, linexp: &linexp,
-            assert_eq!(rein[id], 0.0);
+            prflin: &prflin,
-        }
+        };
-        for ii in 0..nlvexp {
-            for id in 0..nd {
-                assert_eq!(heip[ii][id], 0.0);
-            }
-        }
-        for itr in 0..ntrans {
-            for id in 0..nd {
-                assert_eq!(rru[itr][id], 0.0);
-            }
-        }
-    }
 
-    #[test]
+        // Atomic params
-    fn test_rbnu_calculation() {
+        let ilow = vec![1; NTRANS];
-        let hkt1: Vec<f64> = vec![4.8e-12, 6.0e-12, 8.0e-12];
+        let iup = vec![2; NTRANS];
-        let rad1: Vec<f64> = vec![1.0, 0.5, 0.2];
+        let itrbf = vec![1; NTRANC];
-        let bnue: Vec<f64> = vec![1.0e-10, 2.0e-10];
+        let cross = vec![vec![1e-18; NFREQ]; NTRANC];
-        let hkt21: Vec<f64> = vec![1.0e-12, 1.2e-12, 1.6e-12];
+        let ifwop = vec![1; NLVEXP];
+        let mcdw = vec![0; NTRANS];
+        let dwf1 = vec![vec![1.0; ND]; 10];
+        let imrg = vec![0; NLVEXP];
+        let sgmg = vec![vec![1.0; ND]; 10];
+        let ipzero = vec![vec![0; ND]; NLVEXP];
+        let itra = vec![vec![1; NLVEXP]; NLVEXP];
+        let jidi = vec![0; ND];
+        let xjid = vec![1.0; ND];
+        let sigfe = vec![vec![1.0; NFREQ]; 5];
+        let indexp = vec![1; NTRANS];
+        let iiexp = vec![1; NLVEXP];
 
-        let fr: f64 = 1.0e15;
+        let atomic = Alist1AtomicParams {
-        let ij = 0;
+            ilow: &ilow, iup: &iup, itrbf: &itrbf, cross: &cross, ifwop: &ifwop,
-        let id = 0;
+            mcdw: &mcdw, dwf1: &dwf1, imrg: &imrg, sgmg: &sgmg, ipzero: &ipzero,
+            itra: &itra, jidi: &jidi, xjid: &xjid, sigfe: &sigfe, indexp: &indexp,
+            iiexp: &iiexp,
+        };
 
-        let exx: f64 = (-hkt1[id] * fr).exp();
+        // Model state
-        let rbnu: f64 = (rad1[id] + bnue[ij]) * exx;
+        let temp = vec![10000.0; ND];
-        let expected: f64 = (rad1[id] + bnue[ij]) * exx;
+        let elec = vec![1e12; ND];
+        let dens = vec![1e14; ND];
+        let dens1 = vec![1e-14; ND];
+        let dm = vec![1.0; ND];
+        let wmm = vec![1.0; ND];
+        let hkt1 = vec![4.8e-15; ND];
+        let hkt21 = vec![1.2e-15; ND];
+        let rad1 = vec![1.0; ND];
+        let bnue = vec![1.0; NFREQ];
+        let crsw = vec![1.0; ND];
+        let xkfb = vec![1.0; ND];
+        let xkf1 = vec![1.0; ND];
+        let abso1 = vec![1.0; ND];
+        let scat1 = vec![0.1; ND];
 
-        assert!((rbnu - expected).abs() < 1e-10_f64);
+        let model = Alist1ModelState {
+            temp: &temp, elec: &elec, dens: &dens, dens1: &dens1, dm: &dm,
+            wmm: &wmm, hkt1: &hkt1, hkt21: &hkt21, rad1: &rad1, bnue: &bnue,
+            crsw: &crsw, xkfb: &xkfb, xkf1: &xkf1, abso1: &abso1, scat1: &scat1,
+        };
 
-        let rbnuf: f64 = rbnu * fr * hkt21[id];
+        // Output state
-        let expected_rbnuf: f64 = rbnu * fr * hkt21[id];
+        let mut reit = vec![0.0; ND];
-        assert!((rbnuf - expected_rbnuf).abs() < 1e-15_f64);
+        let mut rein = vec![0.0; ND];
-    }
+        let mut reix = vec![0.0; ND];
+        let mut areit = vec![0.0; ND];
+        let mut arein = vec![0.0; ND];
+        let mut creit = vec![0.0; ND];
+        let mut crein = vec![0.0; ND];
+        let mut creix = vec![0.0; ND];
+        let mut redt = vec![0.0; ND];
+        let mut redtm = vec![0.0; ND];
+        let mut redtp = vec![0.0; ND];
+        let mut redn = vec![0.0; ND];
+        let mut rednm = vec![0.0; ND];
+        let mut rednp = vec![0.0; ND];
+        let mut redx = vec![0.0; ND];
+        let mut redxm = vec![0.0; ND];
+        let mut redxp = vec![0.0; ND];
+        let mut heit = vec![0.0; ND];
+        let mut heitm = vec![0.0; ND];
+        let mut heitp = vec![0.0; ND];
+        let mut hein = vec![0.0; ND];
+        let mut heinm = vec![0.0; ND];
+        let mut heinp = vec![0.0; ND];
+        let mut ehet = vec![0.0; ND];
+        let mut ehen = vec![0.0; ND];
+        let mut eret = vec![0.0; ND];
+        let mut eren = vec![0.0; ND];
 
-    #[test]
+        let mut heip = vec![vec![0.0; ND]; NLVEXP];
-    fn test_constants() {
+        let mut reip = vec![vec![0.0; ND]; NLVEXP];
-        // 验证使用的常量
+        let mut areip = vec![vec![0.0; ND]; NLVEXP];
-        assert!(PCK > 0.0);
+        let mut creip = vec![vec![0.0; ND]; NLVEXP];
-        assert!((UN - 1.0_f64).abs() < 1e-15_f64);
+        let mut redp = vec![vec![0.0; ND]; NLVEXP];
-        assert!((HALF - 0.5_f64).abs() < 1e-15_f64);
+        let mut redpm = vec![vec![0.0; ND]; NLVEXP];
+        let mut heipm = vec![vec![0.0; ND]; NLVEXP];
+        let mut redpp = vec![vec![0.0; ND]; NLVEXP];
+        let mut heipp = vec![vec![0.0; ND]; NLVEXP];
+        let mut ehep = vec![vec![0.0; ND]; NLVEXP];
+        let mut erep = vec![vec![0.0; ND]; NLVEXP];
+
+        let mut fcooli = vec![0.0; ND];
+        let mut flfix = vec![0.0; ND];
+        let mut flexp = vec![0.0; ND];
+        let mut flrd = vec![0.0; ND];
+        let mut fprd = vec![0.0; ND];
+
+        let mut pradt = vec![0.0; ND];
+        let mut prada = vec![0.0; ND];
+
+        let mut rru = vec![vec![0.0; ND]; NTRANS];
+        let mut rrd = vec![vec![0.0; ND]; NTRANS];
+        let mut drdt = vec![vec![0.0; ND]; NTRANS];
+
+        let mut abrosd = vec![0.0; ND];
+        let mut sumdpl = vec![0.0; ND];
+
+        let reint = vec![1.0; ND];
+        let redif = vec![1.0; ND];
+        let mut fcool = vec![0.0; ND];
+
+        let mut output = Alist1OutputState {
+            reit: &mut reit, rein: &mut rein, reix: &mut reix, areit: &mut areit, arein: &mut arein,
+            creit: &mut creit, crein: &mut crein, creix: &mut creix, redt: &mut redt, redtm: &mut redtm,
+            redtp: &mut redtp, redn: &mut redn, rednm: &mut rednm, rednp: &mut rednp, redx: &mut redx,
+            redxm: &mut redxm, redxp: &mut redxp, heit: &mut heit, heitm: &mut heitm, heitp: &mut heitp,
+            hein: &mut hein, heinm: &mut heinm, heinp: &mut heinp, ehet: &mut ehet, ehen: &mut ehen,
+            eret: &mut eret, eren: &mut eren, heip: &mut heip, reip: &mut reip, areip: &mut areip,
+            creip: &mut creip, redp: &mut redp, redpm: &mut redpm, heipm: &mut heipm, redpp: &mut redpp,
+            heipp: &mut heipp, ehep: &mut ehep, erep: &mut erep, fcooli: &mut fcooli, flfix: &mut flfix,
+            flexp: &mut flexp, flrd: &mut flrd, fprd: &mut fprd, pradt: &mut pradt, prada: &mut prada,
+            rru: &mut rru, rrd: &mut rrd, drdt: &mut drdt, abrosd: &mut abrosd, sumdpl: &mut sumdpl,
+            reint: &reint, redif: &redif, fcool: &mut fcool,
+        };
+
+        // Call the functional test
+        let out = alist1_pure(&config, &freq_params, &atomic, &model, &mut output);
+
+        // Verify mutations 
+        assert!(output.rru[0][0] > 0.0 || output.redx[0] == 0.0);
+        assert_eq!(out.prdx, 1.0); // prada is initialized to 0, prdx remains 1.0
     }
 }

src/tlusty/math/chctab.rs

@@ -350,16 +350,53 @@ fn check_opacity_simple<W: std::io::Write>(
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::io::Cursor;
 
     #[test]
-    fn test_element_symbols_count() {
+    fn test_chctab_basic() {
-        assert_eq!(ELEMENT_SYMBOLS.len(), 99);
+        let mut abndd = vec![vec![1.0; 1]; MATOM];
-    }
+        let abunt = vec![1.0; MATOM];
+        let abuno = vec![1.0; MATOM];
 
-    #[test]
+        let mut params = ChctabParams {
-    fn test_element_symbols_format() {
+            abndd: &abndd,
-        assert_eq!(ELEMENT_SYMBOLS[0], " H  ");
+            abunt: &abunt,
-        assert_eq!(ELEMENT_SYMBOLS[1], " He ");
+            abuno: &abuno,
-        assert_eq!(ELEMENT_SYMBOLS[25], " Fe ");  // Fe 是第 26 个元素，索引 25
+            ifmol: 1,
+            ifmolt: 2, // Different, should cause change if keepop == 0
+            tmolim: 1000.0,
+            tmolit: 2000.0,
+            keepop: 0, // Will adopt op.table values
+            opacity_flags: OpacityFlags {
+                iophmi: 1, ielhm: 0, iophmt: 1,
+                ioph2p: 1, ioph2t: 1,
+                iophem: 0, iophet: 0,
+                iopch: 0, iopcht: 0,
+                iopoh: 0, iopoht: 0,
+                ioph2m: 0, ioh2mt: 0,
+                ioh2h2: 0, ih2h2t: 0,
+                ioh2he: 0, ih2het: 0,
+                ioh2h: 0, ioh2ht: 0,
+                iohhe: 0, iohhet: 0,
+            },
+        };
+
+        let mut buf = Cursor::new(Vec::new());
+        {
+            let mut writer = FortranWriter::new(&mut buf);
+            let result = chctab(&mut params, &mut writer).expect("chctab should succeed");
+
+            // Verify that ifmol was changed to ifmolt because keepop == 0
+            assert_eq!(result.ifmol, 2);
+            assert_eq!(result.tmolim, 2000.0);
+            
+            // Verify opacity flags changes (iophmi and ioph2p should be set to 0 because keepop == 0 and both are > 0)
+            assert_eq!(result.iophmi, 0);
+            assert_eq!(result.ioph2p, 0);
+        }
+
+        let output_str = String::from_utf8(buf.into_inner()).unwrap();
+        assert!(output_str.contains("IFMOL and TMILIM changed"));
+        assert!(output_str.contains("so removed here"));
     }
 }

src/tlusty/math/odfmer.rs

@@ -188,32 +188,70 @@ mod tests {
     }
 
     #[test]
-    fn test_odfmer_combined_logic() {
+    fn test_odfmer_basic() {
-        // 综合测试：验证跃迁和深度的组合筛选
+        use crate::tlusty::state::model::StrAux;
-        let ntrans = 4;
+        
-        let nd = 3;
+        let params = OdfmerParams { init: 1 };
-
+        
-        let line = vec![true, true, false, true];
+        let ntrans = 1;
-        let indexp: Vec<i32> = vec![2, 1, 2, -2];
+        let nd = 1;
-        let chant: Vec<f64> = vec![0.0, 0.002, 0.001]; // 深度 1, 2 有变化
+        
-        let init: i32 = 0;
+        let line = vec![true];
-
+        let indexp = vec![2];
-        // 计算应该被处理的 (跃迁, 深度) 对
+        let atomic = OdfmerAtomicData {
-        let mut expected_updates = 0;
+            line: &line,
-        for itr in 0..ntrans {
+            indexp: &indexp,
-            if line[itr] && indexp[itr].abs() == 2 {
+        };
-                for id in 0..nd {
+        
-                    if init == 1 || chant[id].abs() >= CHTL {
+        let chant = vec![1.0];
-                        expected_updates += 1;
+        let model = OdfmerModelState {
-                    }
+            chant: &chant,
-                }
+        };
-            }
+        
-        }
+        let config = OdfhydConfig {
-
+            ispodf: 1, nlmx: 1, cas: 3e10, vtb: 2e5,
-        // 跃迁 0, 3 应该被处理（满足 line=true 且 indexp=±2）
+        };
-        // 深度 1, 2 应该被处理（温度变化 >= CHTL）
+        
-        // 所以预期更新次数 = 2 跃迁 × 2 深度 = 4
+        let ilow = vec![1];
-        assert_eq!(expected_updates, 4,
+        let iup = vec![2];
-            "Expected 4 ODF updates for the given configuration");
+        let nquant = vec![1, 2];
+        let nqlodf = vec![1, 2];
+        let ifr0 = vec![1];
+        let ifr1 = vec![1];
+        let xkij = vec![1.0, 1.0];
+        let fij = vec![1.0, 1.0];
+        let jndodf = vec![1];
+        
+        let odfhyd_atomic = OdfhydAtomicData {
+            ilow: &ilow, iup: &iup, nquant: &nquant, nqlodf: &nqlodf,
+            ifr0: &ifr0, ifr1: &ifr1, xkij: &xkij, fij: &fij, jndodf: &jndodf,
+        };
+        
+        let temp = vec![5000.0];
+        let elec = vec![1e12];
+        let wnhint = vec![1e-4; 10];
+        
+        let straux = StrAux::default();
+        let mut odfhyd_model = OdfhydModelState {
+            temp: &temp, elec: &elec, wnhint: &wnhint, straux,
+        };
+        
+        let nfrodf = vec![1];
+        let fros = vec![1e15; 2000];
+        let wnus = vec![1e13; 2000];
+        let mut prflin = vec![0.0; 200000];
+        let freq = vec![1e15];
+        let kfr0 = vec![1];
+        
+        let mut odfhyd_odf = OdfhydOdfData {
+            nfrodf: &nfrodf, fros: &fros, wnus: &wnus, prflin: &mut prflin,
+            freq: &freq, kfr0: &kfr0, indexp: &indexp,
+        };
+        
+        // Should execute odfhyd and modify prflin or return without panic
+        odfmer(&params, &atomic, &model, &config, &odfhyd_atomic, &mut odfhyd_model, &mut odfhyd_odf);
+        
+        // Assert that we successfully called the function without panic
+        assert_eq!(odfhyd_odf.prflin.len(), 200000);
     }
 }

src/tlusty/math/opacfd.rs

@@ -959,20 +959,176 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_opacfd_initialization() {
+    fn test_opacfd_basic() {
-        // 基本初始化测试
+        // Minimal configuration to avoid out-of-bounds but still run some logic
-        let output = OpacfdOutput::default();
+        let ij = 1;
-        assert_eq!(output.abso1.len(), MDEPTH);
+        let nd = 2;
-        assert_eq!(output.emis1.len(), MDEPTH);
+        let nlevel = 2;
-        assert_eq!(output.scat1.len(), MDEPTH);
+        let nion = 1;
-    }
+        let ntranc = 1;
 
-    #[test]
+        // Ensure we allocate enough space to satisfy MDEPTH / MFREQ indexing
-    fn test_constants() {
+        // We'll use safe small numbers, assuming MDEPTH > 2, MFREQ > 2, MLEVEL > 2
-        // 验证常量
+        let mdepth_size = MDEPTH.max(nd);
-        assert!((C14 - 2.99793e14).abs() < 1e8);
+        let mfreq_size = MFREQ.max(ij);
-        assert!((CFF1 - 1.3727e-25).abs() < 1e-30);
+
-        assert!((DELT - 1e-3).abs() < 1e-10);
+        let freq = vec![1e15; mfreq_size];
-        assert!((DELR - 1e-3).abs() < 1e-10);
+        let bnue = vec![1e-15; mfreq_size];
+        
+        let temp = vec![5000.0; mdepth_size];
+        let elec = vec![1e12; mdepth_size];
+        let elec1 = vec![1e-12; mdepth_size];
+        let dens = vec![1e14; mdepth_size];
+        let hkt1 = vec![4.8e-15; mdepth_size];
+        let hkt21 = vec![1.2e-15; mdepth_size];
+        let temp1 = vec![2e-4; mdepth_size];
+        
+        let sigec = vec![6.65e-25; mfreq_size];
+        
+        let iel = vec![1; MLEVEL];
+        let iz = vec![1; MLEVEL];
+        let charg2 = vec![1.0; 10];
+        let nnext = vec![1; 10];
+        let itra = vec![1; MLEVEL * MLEVEL];
+        
+        let itrbf = vec![1; 10];
+        let ilow = vec![1; 10];
+        let iup = vec![2; 10];
+        let fr0 = vec![1e14; 10];
+        let cross = vec![1e-18; 10 * mfreq_size];
+        let crossd = vec![1e-18; 10 * mfreq_size * mdepth_size];
+        
+        let abtra = vec![1.0; 10 * mdepth_size];
+        let emtra = vec![1.0; 10 * mdepth_size];
+        let demlt = vec![0.1; 10 * mdepth_size];
+        
+        let popul = vec![1e10; MLEVEL * mdepth_size];
+        let popinv = vec![1e-10; MLEVEL * mdepth_size];
+        
+        let iatm = vec![1; MLEVEL];
+        let iifix = vec![0; MLEVEL];
+        let ipzero = vec![0; MLEVEL * mdepth_size];
+        
+        let sff3 = vec![1.0; 10 * mdepth_size];
+        let sff2 = vec![1.0; 10 * mdepth_size];
+        let dsff = vec![0.1; 10 * mdepth_size];
+        let ff = vec![1e10; 10];
+        
+        let nfirst = vec![1; 10];
+        let ielh = 1;
+        
+        let ijlin = vec![0; mfreq_size];
+        let nlines = vec![0; mfreq_size];
+        let itrlin = vec![0; 10 * mfreq_size];
+        let prflin = vec![1.0; mdepth_size * mfreq_size];
+        let ifr0 = vec![1; 10];
+        let ifr1 = vec![2; 10];
+        let kfr0 = vec![1; 10];
+        let linexp = vec![false; 10];
+        let indexp = vec![2; 10];
+        
+        let imrg = vec![0; MLEVEL];
+        let ifwop = vec![0; MLEVEL];
+        let mcdw = vec![0; 10];
+        
+        let iiexp = vec![1; MLEVEL];
+        let iltref = vec![1; MLEVEL * mdepth_size];
+        let imodl = vec![1; MLEVEL];
+        let pt = vec![0.1; MLEVEL * mdepth_size];
+        let pn = vec![0.1; MLEVEL * mdepth_size];
+        let pp = vec![0.1; MLEVEL * mdepth_size];
+        
+        let drhodt = vec![0.0; mdepth_size];
+        let mut ijex = vec![1; mfreq_size];
+        let mut iadop = vec![0; MLEVEL];
+        
+        let mut jidi = vec![0; mdepth_size];
+        let mut xjid = vec![1.0; mdepth_size];
+        
+        // Fix 145GB allocation size to a more reasonable size based on usage
+        let mut sigfe = vec![0.0; 10 * mfreq_size];
+
+        
+        let params = OpacfdParams {
+            ij, nd, nlevel, nion, ntranc,
+            freq: &freq, bnue: &bnue, temp: &temp, elec: &elec, elec1: &elec1,
+            dens: &dens, hkt1: &hkt1, hkt21: &hkt21, temp1: &temp1,
+            sigec: &sigec, iel: &iel, iz: &iz, charg2: &charg2, nnext: &nnext, itra: &itra,
+            itrbf: &itrbf, ilow: &ilow, iup: &iup, fr0: &fr0, cross: &cross, crossd: &crossd,
+            abtra: &abtra, emtra: &emtra, demlt: &demlt, popul: &popul, popinv: &popinv,
+            ifdiel: 0, iopadd: 0, ioplym: 0, ifprd: 0, iter: 1, itlas: 1,
+            ispodf: 0, ioptab: 0, frtabm: 1e16, iatm: &iatm, iifix: &iifix, ipzero: &ipzero,
+            sff3: &sff3, sff2: &sff2, dsff: &dsff, ff: &ff, nfirst: &nfirst, ielh,
+            ijlin: &ijlin, nlines: &nlines, itrlin: &itrlin, prflin: &prflin,
+            ifr0: &ifr0, ifr1: &ifr1, kfr0: &kfr0, linexp: &linexp, indexp: &indexp,
+            imrg: &imrg, ifwop: &ifwop, mcdw: &mcdw,
+            nlvexp: 2, iiexp: &iiexp, iltref: &iltref, imodl: &imodl, pt: &pt, pn: &pn, pp: &pp,
+            inhe: 0, drhodt: &drhodt, izscal: 0, ifryb: 0, ijex: &mut ijex, iadop: &iadop,
+            jidi: &mut jidi, xjid: &mut xjid, sigfe: &mut sigfe,
+        };
+
+        // Mutable state arrays
+        let mut abso1 = vec![0.0; mdepth_size];
+        let mut emis1 = vec![0.0; mdepth_size];
+        let mut scat1 = vec![0.0; mdepth_size];
+        let mut dabt1 = vec![0.0; mdepth_size];
+        let mut demt1 = vec![0.0; mdepth_size];
+        let mut dabn1 = vec![0.0; mdepth_size];
+        let mut demn1 = vec![0.0; mdepth_size];
+        let mut dabm1 = vec![0.0; mdepth_size];
+        let mut demm1 = vec![0.0; mdepth_size];
+        
+        let mut absff = vec![0.0; mdepth_size];
+        let mut dabft = vec![0.0; mdepth_size];
+        let mut dabfn = vec![0.0; mdepth_size];
+        
+        let mut dabp1 = vec![0.0; MLEVEL * mdepth_size];
+        let mut demp1 = vec![0.0; MLEVEL * mdepth_size];
+        let mut elscat = vec![0.0; mdepth_size];
+        
+        let mut xkf = vec![0.0; mdepth_size];
+        let mut xkf1 = vec![0.0; mdepth_size];
+        let mut xkfb = vec![0.0; mdepth_size];
+        let mut dwf1 = vec![0.0; 10 * mdepth_size];
+        let mut sgmg = vec![0.0; MLEVEL * mdepth_size];
+        let mut absot = vec![0.0; mdepth_size];
+        
+        let mut absoex = vec![0.0; 10 * mdepth_size];
+        let mut emisex = vec![0.0; 10 * mdepth_size];
+        let mut scatex = vec![0.0; 10 * mdepth_size];
+        let mut dabtex = vec![0.0; 10 * mdepth_size];
+        let mut demtex = vec![0.0; 10 * mdepth_size];
+        let mut dabnex = vec![0.0; 10 * mdepth_size];
+        let mut demnex = vec![0.0; 10 * mdepth_size];
+        let mut dabmex = vec![0.0; 10 * mdepth_size];
+        let mut demmex = vec![0.0; 10 * mdepth_size];
+        let mut drchex = vec![0.0; 3 * MFREQ * MDEPTH];
+        let mut dretex = vec![0.0; 3 * MFREQ * MDEPTH];
+        
+        let mut dsct1 = vec![0.0; mdepth_size];
+        let mut dscn1 = vec![0.0; mdepth_size];
+        
+        let mut anh2 = vec![0.0; mdepth_size];
+        let mut anhm = vec![0.0; mdepth_size];
+
+        let mut state = OpacfdState {
+            abso1: &mut abso1, emis1: &mut emis1, scat1: &mut scat1, 
+            dabt1: &mut dabt1, demt1: &mut demt1, dabn1: &mut dabn1, 
+            demn1: &mut demn1, dabm1: &mut dabm1, demm1: &mut demm1,
+            absff: &mut absff, dabft: &mut dabft, dabfn: &mut dabfn,
+            dabp1: &mut dabp1, demp1: &mut demp1, elscat: &mut elscat,
+            xkf: &mut xkf, xkf1: &mut xkf1, xkfb: &mut xkfb,
+            dwf1: &mut dwf1, sgmg: &mut sgmg, absot: &mut absot,
+            absoex: &mut absoex, emisex: &mut emisex, scatex: &mut scatex,
+            dabtex: &mut dabtex, demtex: &mut demtex, dabnex: &mut dabnex,
+            demnex: &mut demnex, dabmex: &mut dabmex, demmex: &mut demmex,
+            drchex: &mut drchex, dretex: &mut dretex,
+            dsct1: &mut dsct1, dscn1: &mut dscn1, anh2: &mut anh2, anhm: &mut anhm,
+        };
+
+        opacfd(&params, &mut state);
+
+        // Core validation, verify the state was mutated meaningfully
+        assert!(state.abso1[0] > 0.0 || state.emis1[0] > 0.0 || state.scat1[0] > 0.0);
     }
 }

src/tlusty/math/opdata.rs

@@ -135,9 +135,51 @@ pub fn opdata_check(file_path: &str) -> Result<bool> {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::io::Write;
+    use std::fs;
 
     #[test]
-    fn test_opdata_params_default() {
+    fn test_opdata_functional() {
+        // Create a temporary mock file for RBF.DAT
+        let file_path = std::env::temp_dir().join("mock_rbf.dat");
+        let mut file = File::create(&file_path).unwrap();
+
+        // FortranReader `read_line()` buffers the read line in `remaining`
+        // Then `read_value()` tokenizes `remaining`.
+        // opdata_check reads 21 lines, then calls `read_value()` for `neop`.
+        // This means `neop` comes from the 21st line!
+
+        // Lines 1-20 (Indices 0..20)
+        for _ in 0..20 {
+            writeln!(file, "0").unwrap();
+        }
+        
+        // Line 21: read by 21st `read_line`, parsed by `read_value` for `neop`
+        // We set it to "1"
+        writeln!(file, "1").unwrap();
+        
+        // `opdata` skips 3 element lines, then calls `read_value` for `niop`.
+        // So the 3rd element line must be the value for `niop`.
+        writeln!(file, "0").unwrap(); // Line 22
+        writeln!(file, "0").unwrap(); // Line 23
+        writeln!(file, "1").unwrap(); // Line 24: parsed as niop = 1
+        
+        // The following lines are parsed directly via read_line + split
+        // ionid, iatom, ielec, nlevel_op=1 (Line 25)
+        writeln!(file, "ION1 1 1 1").unwrap();
+        
+        // idlvop, nop=2 (Line 26)
+        writeln!(file, "LEVEL1 2").unwrap();
+        
+        // index, xop, sop (Lines 27-28)
+        writeln!(file, "1 0.1 1.0").unwrap();
+        writeln!(file, "2 0.2 2.0").unwrap();
+
+        // Ensure buffers are flushed
+        file.sync_all().unwrap();
+
+
+        // Structure init
         let mut sop = vec![vec![0.0; MMAXOP]; MOP];
         let mut xop = vec![vec![0.0; MMAXOP]; MOP];
         let mut nop = vec![0; MMAXOP];
@@ -145,7 +187,7 @@ mod tests {
         let mut ntotop = 0;
         let mut loprea = false;
 
-        let params = OpdataParams {
+        let mut params = OpdataParams {
             sop: &mut sop,
             xop: &mut xop,
             nop: &mut nop,
@@ -154,9 +196,26 @@ mod tests {
             loprea: &mut loprea,
         };
 
-        // 验证参数结构正确
+        // Test opdata_check
-        assert_eq!(params.sop.len(), MOP);
+        let check_res = opdata_check(file_path.to_str().unwrap()).unwrap();
-        assert_eq!(params.xop.len(), MOP);
+        assert!(check_res);
-        assert_eq!(params.nop.len(), MMAXOP);
+
+        // Test opdata
+        let res = opdata(file_path.to_str().unwrap(), &mut params).unwrap();
+        
+        // Verify changes
+        assert_eq!(res.ntotop, 1);
+        assert_eq!(*params.ntotop, 1);
+        assert!(*params.loprea);
+        
+        assert_eq!(params.idlvop[0], "LEVEL1");
+        assert_eq!(params.nop[0], 2);
+        assert_eq!(params.xop[0][0], 0.1);
+        assert_eq!(params.sop[0][0], 1.0);
+        assert_eq!(params.xop[1][0], 0.2);
+        assert_eq!(params.sop[1][0], 2.0);
+
+        // Cleanup
+        let _ = fs::remove_file(file_path);
     }
 }