694 lines
21 KiB
Rust
694 lines
21 KiB
Rust
//! 超级能级能量和统计权重计算。
|
|
//!
|
|
//! 重构自 TLUSTY `levcd.f`。
|
|
//!
|
|
//! 从 Kurucz CD-ROM 文件 (gf*.gam) 读取原子数据，
|
|
//! 计算超级能级的平均能量和统计权重。
|
|
//!
|
|
//! 使用 Eissner-Seaton 公式设置超级能级之间的碰撞强度，
|
|
//! 假设 Gamma(T)=0.05, T=Teff。
|
|
|
|
use super::{FortranReader, IoError, Result};
|
|
use crate::tlusty::math::indexx as indexx_func;
|
|
use crate::tlusty::math::quit as quit_func;
|
|
use crate::tlusty::math::wn as wn_func;
|
|
use crate::tlusty::state::atomic::{AtomicData, IonPar, LevPar};
|
|
use crate::tlusty::state::constants::*;
|
|
use crate::tlusty::state::model::ModPar;
|
|
use crate::tlusty::state::odfpar::LevCom;
|
|
use std::fs::File;
|
|
use std::io::{BufRead, BufReader, BufWriter, Write};
|
|
|
|
// ============================================================================
|
|
// 常量参数
|
|
// ============================================================================
|
|
|
|
/// 玻尔兹曼常数转换因子 (用于能量单位转换)
|
|
const BOLCM: f64 = 1.0e8 / HK / CAS;
|
|
/// 相关参数
|
|
const CCOR: f64 = 0.09;
|
|
/// 1/6
|
|
const SIXTH: f64 = UN / 6.0;
|
|
/// Gamma(T) 值
|
|
const GES: f64 = 0.05;
|
|
|
|
/// Fe 离子的基准能量 (cm⁻¹)
|
|
const E0FE: [f64; 10] = [
|
|
63480.0, 130563.0, 247220.0, 442000.0, 605000.0, 799000.0, 1008000.0, 1218380.0, 1884000.0,
|
|
2114000.0,
|
|
];
|
|
|
|
/// Ni 离子的基准能量 (cm⁻¹)
|
|
const E0NI: [f64; 10] = [
|
|
61590.0, 146560.0, 283700.0, 443000.0, 613500.0, 871000.0, 1070000.0, 1310000.0, 1560000.0,
|
|
1812000.0,
|
|
];
|
|
|
|
/// Cr 离子的基准能量 (cm⁻¹)
|
|
const E0CR: [f64; 10] = [
|
|
54576.0, 132966.0, 249700.0, 396500.0, 560200.0, 731020.0, 1291900.0, 1490000.0, 1688000.0,
|
|
1971000.0,
|
|
];
|
|
|
|
// ============================================================================
|
|
// 碰撞强度 COMMON /COLKUR/
|
|
// ============================================================================
|
|
|
|
/// 碰撞强度和 Kurucz 数据。
|
|
/// 对应 COMMON /COLKUR/
|
|
#[derive(Debug, Clone)]
|
|
pub struct ColKur {
|
|
/// 碰撞强度矩阵 (100 x 100)
|
|
pub omes: Vec<Vec<f64>>,
|
|
/// Kurucz 能级能量
|
|
pub eku: Vec<f64>,
|
|
/// Kurucz 能级统计权重
|
|
pub gku: Vec<f64>,
|
|
/// GST 常数
|
|
pub gst: f64,
|
|
/// Kurucz 能级到超级能级的映射
|
|
pub kku: Vec<i32>,
|
|
}
|
|
|
|
impl Default for ColKur {
|
|
fn default() -> Self {
|
|
Self {
|
|
omes: vec![vec![0.0; 100]; 100],
|
|
eku: vec![0.0; 15000],
|
|
gku: vec![0.0; 15000],
|
|
gst: 0.0,
|
|
kku: vec![0; 15000],
|
|
}
|
|
}
|
|
}
|
|
|
|
// ============================================================================
|
|
// 输入参数
|
|
// ============================================================================
|
|
|
|
/// LEVCD 输入参数。
|
|
pub struct LevcdParams<'a> {
|
|
/// 离子索引 (1-based)
|
|
pub ion: usize,
|
|
/// 观测标志 (0=标准, 1=使用观测能级, 2=使用所有能级)
|
|
pub iobs: i32,
|
|
/// 有效温度 (K)
|
|
pub teff: f64,
|
|
/// β 引力因子
|
|
pub bergfc: f64,
|
|
/// 模型参数
|
|
pub modpar: &'a mut ModPar,
|
|
/// 离子参数
|
|
pub ionpar: &'a IonPar,
|
|
/// 能级参数
|
|
pub levpar: &'a LevPar,
|
|
/// 深度点数
|
|
pub nd: usize,
|
|
/// 占据概率写入选项 (IFWOP)
|
|
pub ifwop: &'a [i32],
|
|
/// Kurucz 文件路径
|
|
pub fiodf1: &'a str,
|
|
}
|
|
|
|
// ============================================================================
|
|
// Kurucz 文件格式读取
|
|
// ============================================================================
|
|
|
|
/// Kurucz 文件头部信息
|
|
struct KuruczHeader {
|
|
/// 链接数
|
|
nlinku: i32,
|
|
/// 偶宇称能级数
|
|
keve: i32,
|
|
/// 奇宇称能级数
|
|
kodd: i32,
|
|
}
|
|
|
|
/// Kurucz 能级数据
|
|
struct KuruczLevel {
|
|
/// 角动量量子数 J
|
|
yj: f64,
|
|
/// 能量 (cm⁻¹)
|
|
e: f64,
|
|
/// 自动电离宽度
|
|
ar: f64,
|
|
/// Stark 宽度参数
|
|
sr: f64,
|
|
/// 辐射宽度
|
|
wr: f64,
|
|
}
|
|
|
|
/// 读取 Kurucz 文件头部
|
|
///
|
|
/// FORMAT 170: I7, 13X, I6, 12X, I6
|
|
fn read_kurucz_header<R: BufRead>(reader: &mut R) -> Result<KuruczHeader> {
|
|
let mut line = String::new();
|
|
reader.read_line(&mut line)?;
|
|
|
|
if line.len() < 44 {
|
|
return Err(IoError::ParseError(format!(
|
|
"Kurucz header line too short: {}",
|
|
line.len()
|
|
)));
|
|
}
|
|
|
|
// I7: 列 1-7
|
|
let nlinku: i32 = line[0..7].trim().parse().map_err(|e| {
|
|
IoError::ParseError(format!("Failed to parse NLINKU: {} in '{}'", e, line))
|
|
})?;
|
|
|
|
// I6: 列 21-26 (跳过 13 个字符)
|
|
let keve: i32 = line[20..26].trim().parse().map_err(|e| {
|
|
IoError::ParseError(format!("Failed to parse KEVE: {} in '{}'", e, line))
|
|
})?;
|
|
|
|
// I6: 列 39-44 (跳过 12 个字符)
|
|
let kodd: i32 = line[38..44].trim().parse().map_err(|e| {
|
|
IoError::ParseError(format!("Failed to parse KODD: {} in '{}'", e, line))
|
|
})?;
|
|
|
|
Ok(KuruczHeader {
|
|
nlinku,
|
|
keve,
|
|
kodd,
|
|
})
|
|
}
|
|
|
|
/// 读取 Kurucz 能级数据
|
|
///
|
|
/// FORMAT 171: 8X, F4.1, 4X, F13.3, 18X, 3E9.2
|
|
fn read_kurucz_level<R: BufRead>(reader: &mut R) -> Result<KuruczLevel> {
|
|
let mut line = String::new();
|
|
reader.read_line(&mut line)?;
|
|
|
|
if line.len() < 70 {
|
|
// 最小长度检查
|
|
// 如果行较短但包含有效数据，尝试解析
|
|
if line.trim().is_empty() {
|
|
return Err(IoError::UnexpectedEof);
|
|
}
|
|
}
|
|
|
|
// F4.1: 列 9-12 (跳过 8 个字符) - YJ
|
|
let yj: f64 = if line.len() >= 12 {
|
|
line[8..12].trim().parse().unwrap_or(0.0)
|
|
} else {
|
|
0.0
|
|
};
|
|
|
|
// F13.3: 列 17-29 (跳过 4 个字符) - E
|
|
let e: f64 = if line.len() >= 29 {
|
|
line[16..29].trim().parse().unwrap_or(0.0)
|
|
} else {
|
|
0.0
|
|
};
|
|
|
|
// 3E9.2: 列 48-74 (跳过 18 个字符) - AR, SR, WR
|
|
let ar: f64 = if line.len() >= 56 {
|
|
line[47..56].trim().parse().unwrap_or(0.0)
|
|
} else {
|
|
0.0
|
|
};
|
|
|
|
let sr: f64 = if line.len() >= 65 {
|
|
line[56..65].trim().parse().unwrap_or(0.0)
|
|
} else {
|
|
0.0
|
|
};
|
|
|
|
let wr: f64 = if line.len() >= 74 {
|
|
line[65..74].trim().parse().unwrap_or(0.0)
|
|
} else {
|
|
0.0
|
|
};
|
|
|
|
Ok(KuruczLevel { yj, e, ar, sr, wr })
|
|
}
|
|
|
|
// ============================================================================
|
|
// 主函数
|
|
// ============================================================================
|
|
|
|
/// 执行 LEVCD 计算。
|
|
///
|
|
/// # 参数
|
|
/// - `params` - 输入参数
|
|
/// - `levcom` - 能级 ODF 数据 (可变)
|
|
/// - `colkur` - 碰撞强度数据 (可变)
|
|
/// - `wop` - 占据概率数组 (可变)
|
|
///
|
|
/// # Fortran 原始代码
|
|
/// ```fortran
|
|
/// SUBROUTINE LEVCD(ION,IOBS)
|
|
/// ```
|
|
pub fn levcd(
|
|
params: &mut LevcdParams,
|
|
levcom: &mut LevCom,
|
|
colkur: &mut ColKur,
|
|
wop: &mut [Vec<f64>],
|
|
) -> Result<()> {
|
|
let ion = params.ion;
|
|
let iobs = if params.iobs != 1 && params.iobs != 2 {
|
|
0
|
|
} else {
|
|
params.iobs
|
|
};
|
|
|
|
let nd = params.nd;
|
|
let nevku = levcom.nevku[ion] as usize;
|
|
let nodku = levcom.nodku[ion] as usize;
|
|
|
|
// 临时数组
|
|
let mut gwe = vec![vec![vec![0.0f64; 2]; MLEVEL]; MDEPTH];
|
|
let mut gwb = vec![vec![vec![0.0f64; 2]; MLEVEL]; MDEPTH];
|
|
let mut aa = vec![0.0f64; MDEPTH];
|
|
|
|
// 初始化
|
|
for i in 0..nevku {
|
|
levcom.ymku[i][0] = 0.0;
|
|
levcom.emku[i][0] = 0.0;
|
|
for id in 0..nd {
|
|
gwe[id][i][0] = 0.0;
|
|
gwb[id][i][0] = 0.0;
|
|
}
|
|
}
|
|
|
|
for i in 0..nodku {
|
|
levcom.ymku[i][1] = 0.0;
|
|
levcom.emku[i][1] = 0.0;
|
|
for id in 0..nd {
|
|
gwe[id][i][1] = 0.0;
|
|
gwb[id][i][1] = 0.0;
|
|
}
|
|
}
|
|
|
|
let nevod = nevku + nodku;
|
|
if nevod > 100 {
|
|
quit_func(
|
|
"Too many superlevels in a single Fe ion",
|
|
nevku as i32,
|
|
nodku as i32,
|
|
);
|
|
}
|
|
|
|
// 初始化碰撞矩阵
|
|
for i in 0..nevod {
|
|
for j in 0..nevod {
|
|
colkur.omes[i][j] = 0.0;
|
|
}
|
|
}
|
|
|
|
// 检查占据概率计算选项
|
|
let iw_sup = params.ifwop[params.ionpar.nfirst[ion] as usize];
|
|
if iw_sup >= 2 {
|
|
// 预计算温度相关量
|
|
for id in 0..nd {
|
|
params.modpar.temp1[id] = UN / params.modpar.temp[id];
|
|
aa[id] = CCOR * (params.modpar.elec[id].ln() * SIXTH).exp() / params.modpar.temp[id].sqrt();
|
|
}
|
|
|
|
let zz = params.ionpar.iz[ion] as f64;
|
|
if params.ionpar.iz[ion] > 10 {
|
|
quit_func(
|
|
"Too high Fe, Ni or Cr ion: ion,iz",
|
|
ion as i32,
|
|
params.ionpar.iz[ion],
|
|
);
|
|
}
|
|
|
|
let iat = params.levpar.iatm[params.ionpar.nfirst[ion] as usize] as usize;
|
|
let mut e0 = E0FE[params.ionpar.iz[ion] as usize - 1];
|
|
if params.levpar.iel[params.ionpar.nfirst[ion] as usize] >= 0 {
|
|
// 检查原子类型
|
|
let numat = params.levpar.iel[params.ionpar.nfirst[ion] as usize]; // 简化处理
|
|
if numat == 28 {
|
|
e0 = E0NI[params.ionpar.iz[ion] as usize - 1];
|
|
} else if numat == 24 {
|
|
e0 = E0CR[params.ionpar.iz[ion] as usize - 1];
|
|
}
|
|
}
|
|
|
|
// 打开 Kurucz 文件
|
|
let file = File::open(params.fiodf1)?;
|
|
let mut reader = BufReader::new(file);
|
|
|
|
// 读取头部
|
|
let header = read_kurucz_header(&mut reader)?;
|
|
let nlinku = header.nlinku;
|
|
let keve = header.keve as usize;
|
|
let kodd = header.kodd as usize;
|
|
|
|
levcom.nlinku = nlinku;
|
|
levcom.keve = keve as i32;
|
|
levcom.kodd = kodd as i32;
|
|
|
|
if keve + kodd > 15000 {
|
|
quit_func(
|
|
"Too many levels in Kurucz file",
|
|
keve as i32,
|
|
kodd as i32,
|
|
);
|
|
}
|
|
|
|
// 读取偶宇称能级
|
|
for k in 0..keve {
|
|
let level = read_kurucz_level(&mut reader)?;
|
|
let yj = level.yj;
|
|
let mut e = level.e;
|
|
let ar = level.ar;
|
|
let sr = level.sr;
|
|
let wr = level.wr;
|
|
|
|
let gev = TWO * yj + UN;
|
|
|
|
if e < 0.0 {
|
|
e = -e;
|
|
if iobs == 0 {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// 确定超级能级索引
|
|
let mut ksl = 0;
|
|
if e <= levcom.xev[0][ion] {
|
|
ksl = 1;
|
|
}
|
|
for i in 1..nevku {
|
|
if e <= levcom.xev[i][ion] && e > levcom.xev[i - 1][ion] {
|
|
ksl = (i + 1) as i32;
|
|
}
|
|
}
|
|
|
|
if ksl == 0 {
|
|
// WRITE(10,*) 'Error with even levels', E, YJ
|
|
eprintln!("Error with even levels: E={}, YJ={}", e, yj);
|
|
}
|
|
|
|
colkur.kku[k] = ksl;
|
|
colkur.gku[k] = gev;
|
|
colkur.eku[k] = e;
|
|
|
|
levcom.ymku[(ksl - 1) as usize][0] += gev;
|
|
levcom.emku[(ksl - 1) as usize][0] += gev * e;
|
|
|
|
if iw_sup == 2 {
|
|
let ebcm = e / BOLCM;
|
|
for id in 0..nd {
|
|
let gwx = gev * (-ebcm * params.modpar.temp1[id]).exp();
|
|
gwb[id][(ksl - 1) as usize][0] += gwx;
|
|
gwe[id][(ksl - 1) as usize][0] += gwx * e;
|
|
}
|
|
} else if iw_sup == 3 {
|
|
let ebcm = e / BOLCM;
|
|
if e < e0 {
|
|
let xn = (e0 / (e0 - e)).sqrt();
|
|
for id in 0..nd {
|
|
let wid = wn_func(xn, aa[id], params.modpar.elec[id], zz, params.bergfc);
|
|
let gwx = gev * wid * (-ebcm * params.modpar.temp1[id]).exp();
|
|
gwb[id][(ksl - 1) as usize][0] += gwx;
|
|
gwe[id][(ksl - 1) as usize][0] += gwx * e;
|
|
}
|
|
} else {
|
|
for id in 0..nd {
|
|
let wid = UN;
|
|
let gwx = gev * wid * (-ebcm * params.modpar.temp1[id]).exp();
|
|
gwb[id][(ksl - 1) as usize][0] += gwx;
|
|
gwe[id][(ksl - 1) as usize][0] += gwx * e;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 存储能级数据
|
|
if k < levcom.eev.len() {
|
|
levcom.eev[k] = e;
|
|
levcom.aev[k] = ar;
|
|
levcom.sev[k] = sr;
|
|
levcom.wev[k] = wr;
|
|
levcom.ksev[k] = ksl;
|
|
}
|
|
}
|
|
|
|
// 检查偶宇称超级能级
|
|
for i in 0..nevku {
|
|
if levcom.ymku[i][0] == 0.0 {
|
|
quit_func("No levels in even superlevel", (i + 1) as i32, (i + 1) as i32);
|
|
}
|
|
levcom.emku[i][0] /= levcom.ymku[i][0];
|
|
}
|
|
|
|
// 读取奇宇称能级
|
|
for k in 0..kodd {
|
|
let level = read_kurucz_level(&mut reader)?;
|
|
let yj = level.yj;
|
|
let mut e = level.e;
|
|
let ar = level.ar;
|
|
let sr = level.sr;
|
|
let wr = level.wr;
|
|
|
|
let god = TWO * yj + UN;
|
|
|
|
if e < 0.0 {
|
|
e = -e;
|
|
if iobs == 0 {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// 确定超级能级索引
|
|
let mut ksl = 0;
|
|
if e <= levcom.xod[0][ion] {
|
|
ksl = 1;
|
|
}
|
|
for i in 1..nodku {
|
|
if e <= levcom.xod[i][ion] && e > levcom.xod[i - 1][ion] {
|
|
ksl = (i + 1) as i32;
|
|
}
|
|
}
|
|
|
|
if ksl == 0 {
|
|
eprintln!("Error with odd levels: E={}, YJ={}", e, yj);
|
|
}
|
|
|
|
let kku_idx = k + keve;
|
|
colkur.kku[kku_idx] = ksl + nevku as i32;
|
|
colkur.gku[kku_idx] = god;
|
|
colkur.eku[kku_idx] = e;
|
|
|
|
levcom.ymku[(ksl - 1) as usize][1] += god;
|
|
levcom.emku[(ksl - 1) as usize][1] += god * e;
|
|
|
|
if iw_sup == 2 {
|
|
let ebcm = e / BOLCM;
|
|
for id in 0..nd {
|
|
let gwx = god * (-ebcm * params.modpar.temp1[id]).exp();
|
|
gwb[id][(ksl - 1) as usize][1] += gwx;
|
|
gwe[id][(ksl - 1) as usize][1] += gwx * e;
|
|
}
|
|
} else if iw_sup == 3 {
|
|
let ebcm = e / BOLCM;
|
|
if e < e0 {
|
|
let xn = (e0 / (e0 - e)).sqrt();
|
|
for id in 0..nd {
|
|
let wid = wn_func(xn, aa[id], params.modpar.elec[id], zz, params.bergfc);
|
|
let gwx = god * wid * (-ebcm * params.modpar.temp1[id]).exp();
|
|
gwb[id][(ksl - 1) as usize][1] += gwx;
|
|
gwe[id][(ksl - 1) as usize][1] += gwx * e;
|
|
}
|
|
} else {
|
|
for id in 0..nd {
|
|
let wid = UN;
|
|
let gwx = god * wid * (-ebcm * params.modpar.temp1[id]).exp();
|
|
gwb[id][(ksl - 1) as usize][1] += gwx;
|
|
gwe[id][(ksl - 1) as usize][1] += gwx * e;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 存储能级数据
|
|
if k < levcom.eod.len() {
|
|
levcom.eod[k] = e;
|
|
levcom.aod[k] = ar;
|
|
levcom.sod[k] = sr;
|
|
levcom.wod[k] = wr;
|
|
levcom.ksod[k] = ksl;
|
|
}
|
|
}
|
|
|
|
// 检查奇宇称超级能级
|
|
for i in 0..nodku {
|
|
if levcom.ymku[i][1] == 0.0 {
|
|
quit_func("No levels in odd superlevel", (i + 1) as i32, (i + 1) as i32);
|
|
}
|
|
levcom.emku[i][1] /= levcom.ymku[i][1];
|
|
}
|
|
|
|
// 计算碰撞强度
|
|
colkur.gst = 8.63e-6 * GES / params.teff.sqrt();
|
|
let tk0 = UN / BOLCM / params.teff;
|
|
|
|
for i in 0..(keve + kodd - 1) {
|
|
let ki = colkur.kku[i] as usize;
|
|
for j in (i + 1)..(keve + kodd) {
|
|
let kj = colkur.kku[j] as usize;
|
|
let u0 = (colkur.eku[i] - colkur.eku[j]).abs() * tk0;
|
|
colkur.omes[ki][kj] += colkur.gst * (-u0).exp();
|
|
colkur.omes[kj][ki] = colkur.omes[ki][kj];
|
|
}
|
|
}
|
|
|
|
// 排序超级能级能量
|
|
let nlevku = nevku + nodku;
|
|
levcom.nlevku = nlevku as i32;
|
|
|
|
// 复制能量到 EU 数组
|
|
for i in 0..nevku {
|
|
levcom.eu[i] = levcom.emku[i][0];
|
|
}
|
|
for i in 0..nodku {
|
|
levcom.eu[nevku + i] = levcom.emku[i][1];
|
|
}
|
|
|
|
// 排序
|
|
let jen = indexx_func(&levcom.eu[0..nlevku]);
|
|
for i in 0..nlevku {
|
|
levcom.jen[i] = jen[i] as i32;
|
|
}
|
|
|
|
// 计算超级能级的广义占据概率
|
|
for i in 0..nlevku {
|
|
let ii = params.ionpar.nfirst[ion] as usize + i;
|
|
let jj = levcom.jen[i] as usize;
|
|
let mut jk = 1;
|
|
let mut jj_adj = jj;
|
|
if jj >= nevku {
|
|
jj_adj = jj - nevku;
|
|
jk = 2;
|
|
}
|
|
|
|
for id in 0..nd {
|
|
if gwb[id][jj_adj][jk - 1] != 0.0 {
|
|
let esup = gwe[id][jj_adj][jk - 1] / gwb[id][jj_adj][jk - 1];
|
|
let wsup = (esup / BOLCM * params.modpar.temp1[id]).exp() / levcom.ymku[jj_adj][jk - 1];
|
|
wop[ii][id] = wsup * gwb[id][jj_adj][jk - 1];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
// ============================================================================
|
|
// 测试
|
|
// ============================================================================
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn test_constants() {
|
|
assert!(BOLCM > 0.0);
|
|
assert!(CCOR > 0.0);
|
|
assert!(GES > 0.0);
|
|
}
|
|
|
|
#[test]
|
|
fn test_e0_arrays() {
|
|
// Fe 离子能量应该递增
|
|
for i in 1..E0FE.len() {
|
|
assert!(E0FE[i] > E0FE[i - 1], "E0FE should be increasing");
|
|
}
|
|
// Ni 离子能量应该递增
|
|
for i in 1..E0NI.len() {
|
|
assert!(E0NI[i] > E0NI[i - 1], "E0NI should be increasing");
|
|
}
|
|
// Cr 离子能量应该递增
|
|
for i in 1..E0CR.len() {
|
|
assert!(E0CR[i] > E0CR[i - 1], "E0CR should be increasing");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_colkur_default() {
|
|
let colkur = ColKur::default();
|
|
assert_eq!(colkur.omes.len(), 100);
|
|
assert_eq!(colkur.omes[0].len(), 100);
|
|
assert_eq!(colkur.eku.len(), 15000);
|
|
assert_eq!(colkur.gku.len(), 15000);
|
|
assert_eq!(colkur.kku.len(), 15000);
|
|
}
|
|
|
|
#[test]
|
|
fn test_read_kurucz_header() {
|
|
// 模拟 Kurucz 文件头部行
|
|
// FORMAT: I7, 13X, I6, 12X, I6
|
|
// 列 1-7: NLINKU (I7)
|
|
// 列 8-20: 跳过 (13X)
|
|
// 列 21-26: KEVE (I6)
|
|
// 列 27-38: 跳过 (12X)
|
|
// 列 39-44: KODD (I6)
|
|
let header_line = format!(
|
|
"{:7}{:13}{:6}{:12}{:6}\n",
|
|
"123", // NLINKU at 1-7
|
|
"", // 13X at 8-20
|
|
"456", // KEVE at 21-26
|
|
"", // 12X at 27-38
|
|
"789" // KODD at 39-44
|
|
);
|
|
println!("Header line length: {}", header_line.len());
|
|
println!("Header line: {:?}", header_line);
|
|
let cursor = std::io::Cursor::new(header_line.as_bytes());
|
|
let mut reader = BufReader::new(cursor);
|
|
|
|
let header = read_kurucz_header(&mut reader).unwrap();
|
|
assert_eq!(header.nlinku, 123);
|
|
assert_eq!(header.keve, 456);
|
|
assert_eq!(header.kodd, 789);
|
|
}
|
|
|
|
#[test]
|
|
fn test_read_kurucz_level() {
|
|
// 模拟 Kurucz 能级数据行
|
|
// FORMAT: 8X, F4.1, 4X, F13.3, 18X, 3E9.2
|
|
// 列 1-8: 跳过 (8X)
|
|
// 列 9-12: YJ (F4.1)
|
|
// 列 13-16: 跳过 (4X)
|
|
// 列 17-29: E (F13.3)
|
|
// 列 30-47: 跳过 (18X)
|
|
// 列 48-56: AR (E9.2)
|
|
// 列 57-65: SR (E9.2)
|
|
// 列 66-74: WR (E9.2)
|
|
let level_line = format!(
|
|
"{:8}{:4}{:4}{:13}{:18}{:9}{:9}{:9}\n",
|
|
"", // 8X at 1-8
|
|
"2.5", // YJ at 9-12
|
|
"", // 4X at 13-16
|
|
"12345.678", // E at 17-29
|
|
"", // 18X at 30-47
|
|
"1.23E-03", // AR at 48-56
|
|
"4.56E-04", // SR at 57-65
|
|
"7.89E-05" // WR at 66-74
|
|
);
|
|
println!("Level line length: {}", level_line.len());
|
|
println!("Level line: {:?}", level_line);
|
|
let cursor = std::io::Cursor::new(level_line.as_bytes());
|
|
let mut reader = BufReader::new(cursor);
|
|
|
|
let level = read_kurucz_level(&mut reader).unwrap();
|
|
assert!((level.yj - 2.5).abs() < 0.01, "YJ mismatch: got {}", level.yj);
|
|
assert!((level.e - 12345.678).abs() < 0.001, "E mismatch: got {}", level.e);
|
|
// 使用更宽松的容差
|
|
assert!((level.ar - 1.23e-3).abs() < 1e-4, "AR mismatch: got {}", level.ar);
|
|
assert!((level.sr - 4.56e-4).abs() < 1e-5, "SR mismatch: got {}", level.sr);
|
|
assert!((level.wr - 7.89e-5).abs() < 1e-6, "WR mismatch: got {}", level.wr);
|
|
}
|
|
|
|
#[test]
|
|
fn test_bolcm_calculation() {
|
|
// 验证 BOLCM 常数
|
|
let expected = 1.0e8 / HK / CAS;
|
|
assert!((BOLCM - expected).abs() < 1e-10);
|
|
}
|
|
}
|