852 lines
25 KiB
Rust
852 lines
25 KiB
Rust
//! Iron-peak 元素不透明度采样初始化。
|
||
//!
|
||
//! 重构自 TLUSTY `iroset.f`
|
||
//!
|
||
//! # 功能
|
||
//!
|
||
//! - 设置深度点插值网格 (JIDR, JIDN, JIDI, XJID)
|
||
//! - 读取超级能级数据 (LEVCD)
|
||
//! - 读取谱线数据 (INKUL)
|
||
//! - 计算谱线截面并存储到 SIGFE
|
||
//!
|
||
//! # I/O 操作
|
||
//!
|
||
//! - fort.6: 进度输出
|
||
//! - fort.10: 调试输出
|
||
//! - fort.41: 谱线截面摘要
|
||
|
||
use super::Result;
|
||
use crate::tlusty::math::quit as quit_func;
|
||
use crate::tlusty::math::voigte as voigte_func;
|
||
use crate::tlusty::state::atomic::AtomicData;
|
||
use crate::tlusty::state::config::BasNum;
|
||
use crate::tlusty::state::constants::*;
|
||
use crate::tlusty::state::model::ModelState;
|
||
use crate::tlusty::state::odfpar::OdfData;
|
||
use std::io::Write;
|
||
|
||
// ============================================================================
|
||
// 常量参数
|
||
// ============================================================================
|
||
|
||
/// 碰撞展宽系数 (来自 Fortran PARAMETER)
|
||
const CSIG: f64 = 0.0149736;
|
||
|
||
// ============================================================================
|
||
// LINED COMMON 块 (谱线数据)
|
||
// ============================================================================
|
||
|
||
/// 谱线数据结构。
|
||
/// 对应 COMMON /LINED/
|
||
#[derive(Debug, Clone)]
|
||
pub struct Lined {
|
||
/// 波长 (Å)
|
||
pub wave: Vec<f64>,
|
||
/// 多普勒宽度 (深度依赖)
|
||
pub vdop: Vec<Vec<f32>>,
|
||
/// 阻尼参数 (深度依赖)
|
||
pub agam: Vec<Vec<f32>>,
|
||
/// 线强参数 (深度依赖)
|
||
pub sig0: Vec<Vec<f32>>,
|
||
/// 跃迁索引 [line][0=下能级, 1=上能级]
|
||
pub jtr: Vec<[i32; 2]>,
|
||
}
|
||
|
||
impl Lined {
|
||
pub fn new(nline: usize, nd: usize) -> Self {
|
||
Self {
|
||
wave: vec![0.0; nline],
|
||
vdop: vec![vec![0.0; nd]; nline],
|
||
agam: vec![vec![0.0; nd]; nline],
|
||
sig0: vec![vec![0.0; nd]; nline],
|
||
jtr: vec![[0; 2]; nline],
|
||
}
|
||
}
|
||
}
|
||
|
||
// ============================================================================
|
||
// COLKUR COMMON 块 (碰撞强度)
|
||
// ============================================================================
|
||
|
||
/// Kurucz 碰撞强度数据。
|
||
/// 对应 COMMON /COLKUR/
|
||
#[derive(Debug, Clone)]
|
||
pub struct ColKur {
|
||
/// 碰撞强度矩阵 Ω
|
||
pub omes: Vec<Vec<f64>>,
|
||
/// Kurucz 能级能量
|
||
pub eku: Vec<f64>,
|
||
/// Kurucz 能级 g 值
|
||
pub gku: Vec<f64>,
|
||
/// 碰撞强度总和
|
||
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],
|
||
}
|
||
}
|
||
}
|
||
|
||
// ============================================================================
|
||
// 输入参数
|
||
// ============================================================================
|
||
|
||
/// IROSET 输入参数。
|
||
pub struct IrosetParams<'a> {
|
||
/// 深度点数
|
||
pub nd: i32,
|
||
/// 频率点数
|
||
pub nfreq: i32,
|
||
/// 离子数
|
||
pub nion: i32,
|
||
/// 有效温度 (K)
|
||
pub teff: f64,
|
||
/// β 引力因子
|
||
pub bergfc: f64,
|
||
/// 原子数据
|
||
pub atomic: &'a AtomicData,
|
||
/// 模型状态
|
||
pub model: &'a ModelState,
|
||
/// ODF 数据
|
||
pub odf: &'a mut OdfData,
|
||
/// 基本数值
|
||
pub basnum: &'a BasNum,
|
||
/// 占据概率写入选项
|
||
pub ifwop: &'a [i32],
|
||
/// Kurucz 文件路径列表
|
||
pub fiodf1_list: &'a [String],
|
||
}
|
||
|
||
/// IROSET 输出。
|
||
#[derive(Debug, Clone)]
|
||
pub struct IrosetOutput {
|
||
/// 最大频率点数/跃迁
|
||
pub nftmx: i32,
|
||
/// 总截面数
|
||
pub nftt: i32,
|
||
}
|
||
|
||
// ============================================================================
|
||
// Callback 接口
|
||
// ============================================================================
|
||
|
||
/// IROSET 子程序回调接口。
|
||
///
|
||
/// 用于在 IROSET 内部调用 LEVCD、INKUL、IJALI2 等子程序。
|
||
/// 这允许调用者提供具体实现，同时保持 IROSET 的流程与 Fortran 一致。
|
||
pub trait IrosetCallbacks {
|
||
/// 调用 LEVCD(ION, IOBS) - 设置超级能级
|
||
///
|
||
/// # 参数
|
||
/// * `ion` - 离子索引 (1-based)
|
||
/// * `iobs` - 观测标志 (0=标准, 1=使用观测能级, 2=使用所有能级)
|
||
fn call_levcd(&mut self, ion: usize, iobs: i32);
|
||
|
||
/// 调用 INKUL(ION, IOBS) - 读取谱线数据
|
||
///
|
||
/// # 参数
|
||
/// * `ion` - 离子索引 (1-based)
|
||
/// * `iobs` - 观测标志
|
||
fn call_inkul(&mut self, ion: usize, iobs: i32);
|
||
|
||
/// 调用 IJALI2() - 设置 ALI 频率索引
|
||
///
|
||
/// 在完全混合 CL/ALI 方案中，设置个别跃迁的 ALI 处理标志。
|
||
/// 对应 Fortran line 170: CALL IJALI2
|
||
fn call_ijali2(&mut self);
|
||
}
|
||
|
||
/// 空回调实现（默认不做任何操作）
|
||
#[derive(Debug, Clone, Default)]
|
||
pub struct NoOpCallbacks;
|
||
|
||
impl IrosetCallbacks for NoOpCallbacks {
|
||
fn call_levcd(&mut self, _ion: usize, _iobs: i32) {}
|
||
fn call_inkul(&mut self, _ion: usize, _iobs: i32) {}
|
||
fn call_ijali2(&mut self) {}
|
||
}
|
||
|
||
// ============================================================================
|
||
// 核心计算函数
|
||
// ============================================================================
|
||
|
||
/// 设置深度点插值索引。
|
||
///
|
||
/// 计算 JIDR, JIDN, JIDC, JIDI, XJID 数组。
|
||
fn setup_depth_interpolation(
|
||
nd: i32,
|
||
jids: i32,
|
||
dm: &[f64],
|
||
jidr: &mut [i32],
|
||
jidi: &mut [i32],
|
||
xjid: &mut [f64],
|
||
) -> (i32, i32) {
|
||
let mut jidn: i32;
|
||
let mut jidc: i32 = 2; // 默认值
|
||
|
||
jidr[0] = 1;
|
||
|
||
if jids == 0 {
|
||
// 默认：3 个深度点
|
||
jidr[1] = (0.7 * nd as f64) as i32;
|
||
jidr[2] = nd;
|
||
jidn = 3;
|
||
jidc = 2;
|
||
} else {
|
||
// 用户指定间隔
|
||
let mut i: usize = 1;
|
||
while jidr[i - 1] < nd && i < MDODF {
|
||
jidr[i] = jidr[i - 1] + jids;
|
||
if jidr[i] <= (0.7 * nd as f64) as i32 {
|
||
jidc = jidr[i];
|
||
}
|
||
i += 1;
|
||
}
|
||
jidn = i as i32;
|
||
|
||
if jidr[i - 1] > nd {
|
||
if jidr[i - 2] >= nd - 5 {
|
||
jidn -= 1;
|
||
}
|
||
jidr[(jidn - 1) as usize] = nd;
|
||
}
|
||
|
||
if jidn > MDODF as i32 {
|
||
quit_func(
|
||
" Too many depths for Fe x-sections",
|
||
jidn,
|
||
MDODF as i32,
|
||
);
|
||
}
|
||
}
|
||
|
||
// 计算对数深度
|
||
let mut dml = vec![0.0f64; nd as usize];
|
||
for id in 0..nd as usize {
|
||
dml[id] = dm[id].ln();
|
||
}
|
||
|
||
// 设置插值权重
|
||
for i in 0..(jidn - 1) as usize {
|
||
let dxi = dml[jidr[i + 1] as usize - 1] - dml[jidr[i] as usize - 1];
|
||
for id in jidr[i] as usize..jidr[i + 1] as usize {
|
||
jidi[id] = (i + 1) as i32;
|
||
xjid[id] = (dml[jidr[i + 1] as usize - 1] - dml[id]) / dxi;
|
||
}
|
||
}
|
||
jidi[0] = 1;
|
||
xjid[0] = 1.0;
|
||
|
||
(jidn, jidc)
|
||
}
|
||
|
||
/// 执行 IROSET 核心计算（简化版本）。
|
||
///
|
||
/// # 参数
|
||
/// - `params`: 输入参数
|
||
/// - `lined`: 谱线数据 (可变，由 LEVCD/INKUL 填充)
|
||
/// - `colkur`: 碰撞强度数据 (可变)
|
||
/// - `wop`: 占据概率数组 (可变)
|
||
/// - `callbacks`: 子程序回调接口
|
||
///
|
||
/// # 返回
|
||
/// 计算结果
|
||
pub fn iroset_pure<C: IrosetCallbacks>(
|
||
params: &mut IrosetParams,
|
||
lined: &mut Lined,
|
||
_colkur: &mut ColKur,
|
||
wop: &mut [Vec<f64>],
|
||
callbacks: &mut C,
|
||
) -> IrosetOutput {
|
||
let nd = params.nd as usize;
|
||
let nion = params.nion as usize;
|
||
|
||
let splcom = &mut params.odf.splcom;
|
||
let odfion = ¶ms.odf.odfion;
|
||
let atomic = params.atomic;
|
||
let model = params.model;
|
||
|
||
// 设置深度点插值
|
||
let (jidn, jidc) = setup_depth_interpolation(
|
||
params.nd,
|
||
splcom.jids,
|
||
&model.modpar.dm,
|
||
&mut splcom.jidr,
|
||
&mut splcom.jidi,
|
||
&mut splcom.xjid,
|
||
);
|
||
splcom.jidn = jidn;
|
||
|
||
// 预计算频率相关量
|
||
let xfrma = splcom.frs1.ln();
|
||
let dxnu = splcom.dxnu;
|
||
let ijd = ((9.0 / dxnu) as i32).max(2);
|
||
|
||
let mut nftt: i32 = 0;
|
||
let mut nftmx: i32 = 0;
|
||
|
||
// 处理每个离子
|
||
for ion in 0..nion {
|
||
// 边界检查
|
||
if ion >= odfion.inodf1.len() {
|
||
break;
|
||
}
|
||
let ind = odfion.inodf1[ion];
|
||
if ind <= 0 {
|
||
continue;
|
||
}
|
||
|
||
// 检查是否所有能级都在 LTE
|
||
if atomic.iondat.nllim[ion] >= atomic.iondat.nlevs[ion] {
|
||
// 设置所有能级的 WOP = UN
|
||
let nfirst = atomic.ionpar.nfirst[ion] as usize - 1;
|
||
let nlast = atomic.ionpar.nlast[ion] as usize - 1;
|
||
for id in 0..nd {
|
||
for i in nfirst..=nlast {
|
||
wop[i][id] = UN;
|
||
}
|
||
}
|
||
continue;
|
||
}
|
||
|
||
// 设置超级能级并读取谱线数据
|
||
// 对应 Fortran: CALL LEVCD(ION,IOBS)
|
||
let iobs = odfion.ikobs[ion];
|
||
|
||
// 调用 LEVCD 设置超级能级
|
||
// Fortran line 109: CALL LEVCD(ION,IOBS)
|
||
callbacks.call_levcd(ion + 1, iobs);
|
||
|
||
// 对应 Fortran: CALL INKUL(ION,IOBS)
|
||
// Fortran line 110: CALL INKUL(ION,IOBS)
|
||
callbacks.call_inkul(ion + 1, iobs);
|
||
|
||
// 输出进度信息 (对应 WRITE(6,610))
|
||
eprintln!(
|
||
"\n *** superlines for {:4}: {:4} selected internal lines: {:10}",
|
||
ion + 1,
|
||
atomic.printp.typion[ion],
|
||
params.odf.levcom.nlinku
|
||
);
|
||
|
||
if params.odf.levcom.nlinku > MLINE as i32 {
|
||
quit_func(
|
||
"too many internal lines",
|
||
params.odf.levcom.nlinku,
|
||
MLINE as i32,
|
||
);
|
||
}
|
||
|
||
// 处理每个跃迁（简化版本）
|
||
// 完整实现需要遍历所有跃迁并计算截面
|
||
// 这里只做基本的计数
|
||
|
||
// 计算 FCOL（简化）
|
||
let levcom = ¶ms.odf.levcom;
|
||
for k in 0..levcom.nlinku as usize {
|
||
if k < lined.wave.len() && lined.wave[k] > 0.0 {
|
||
let _frl = CAS / lined.wave[k];
|
||
// 简化的频率点计数
|
||
let nft = (ijd * 2) as i32;
|
||
if nft > nftmx {
|
||
nftmx = nft;
|
||
}
|
||
nftt += nft;
|
||
}
|
||
}
|
||
}
|
||
|
||
splcom.nftt = nftt;
|
||
|
||
// 对应 Fortran WRITE(10,*):
|
||
// WRITE(10,*) ' Max. number of freq. per transition:',NFTMX
|
||
// WRITE(10,*) ' Number of iron line cross-sections: ',NFTT
|
||
eprintln!(" Max. number of freq. per transition:{}", nftmx);
|
||
eprintln!(" Number of iron line cross-sections: {}", nftt);
|
||
|
||
// 对应 Fortran line 170: CALL IJALI2
|
||
// 设置 ALI 频率索引
|
||
callbacks.call_ijali2();
|
||
|
||
IrosetOutput { nftmx, nftt }
|
||
}
|
||
|
||
// ============================================================================
|
||
// 带 I/O 的入口函数
|
||
// ============================================================================
|
||
|
||
/// 执行 IROSET，包含 I/O 操作。
|
||
///
|
||
/// # 参数
|
||
/// - `params`: 输入参数
|
||
/// - `lined`: 谱线数据
|
||
/// - `colkur`: 碰撞强度数据
|
||
/// - `wop`: 占据概率数组
|
||
/// - `writer6`: 标准输出写入器 (fort.6)
|
||
/// - `writer10`: 调试输出写入器 (fort.10)
|
||
/// - `writer41`: 截面摘要写入器 (fort.41)
|
||
///
|
||
/// # 返回
|
||
/// 计算结果
|
||
pub fn iroset<W6: Write, W10: Write, W41: Write, C: IrosetCallbacks>(
|
||
params: &mut IrosetParams,
|
||
lined: &mut Lined,
|
||
colkur: &mut ColKur,
|
||
wop: &mut [Vec<f64>],
|
||
writer6: &mut W6,
|
||
writer10: &mut W10,
|
||
writer41: &mut W41,
|
||
callbacks: &mut C,
|
||
) -> Result<IrosetOutput> {
|
||
let nd = params.nd as usize;
|
||
let nfreq = params.nfreq as usize;
|
||
let nion = params.nion as usize;
|
||
|
||
let splcom = &mut params.odf.splcom;
|
||
let levcom = &mut params.odf.levcom;
|
||
let odfion = ¶ms.odf.odfion;
|
||
let atomic = params.atomic;
|
||
let model = params.model;
|
||
|
||
// 设置深度点插值
|
||
let (jidn, jidc) = setup_depth_interpolation(
|
||
params.nd,
|
||
splcom.jids,
|
||
&model.modpar.dm,
|
||
&mut splcom.jidr,
|
||
&mut splcom.jidi,
|
||
&mut splcom.xjid,
|
||
);
|
||
splcom.jidn = jidn;
|
||
|
||
// 预计算频率相关量
|
||
let xfrma = splcom.frs1.ln();
|
||
let dxnu = splcom.dxnu;
|
||
let ijd = ((9.0 / dxnu) as i32).max(2);
|
||
|
||
let mut nftt: i32 = 0;
|
||
let mut nftmx: i32 = 0;
|
||
|
||
// 临时数组
|
||
let mut sigt = vec![vec![0.0f64; nfreq]; MDODF];
|
||
|
||
// 处理每个离子
|
||
for ion in 0..nion {
|
||
// 边界检查
|
||
if ion >= odfion.inodf1.len() {
|
||
break;
|
||
}
|
||
let ind = odfion.inodf1[ion];
|
||
if ind <= 0 {
|
||
continue;
|
||
}
|
||
|
||
// 检查是否所有能级都在 LTE
|
||
if atomic.iondat.nllim[ion] >= atomic.iondat.nlevs[ion] {
|
||
let nfirst = atomic.ionpar.nfirst[ion] as usize - 1;
|
||
let nlast = atomic.ionpar.nlast[ion] as usize - 1;
|
||
for id in 0..nd {
|
||
for i in nfirst..=nlast {
|
||
wop[i][id] = UN;
|
||
}
|
||
}
|
||
continue;
|
||
}
|
||
|
||
// 设置超级能级并读取谱线数据
|
||
// 对应 Fortran: CALL LEVCD(ION,IOBS)
|
||
let iobs = odfion.ikobs[ion];
|
||
|
||
// 调用 LEVCD 设置超级能级
|
||
// Fortran line 109: CALL LEVCD(ION,IOBS)
|
||
callbacks.call_levcd(ion + 1, iobs);
|
||
|
||
// 对应 Fortran: CALL INKUL(ION,IOBS)
|
||
// Fortran line 110: CALL INKUL(ION,IOBS)
|
||
callbacks.call_inkul(ion + 1, iobs);
|
||
|
||
// 进度输出
|
||
writeln!(
|
||
writer6,
|
||
"\n *** superlines for {:4}: {:4} selected internal lines: {:10}",
|
||
ion + 1,
|
||
atomic.printp.typion[ion],
|
||
levcom.nlinku
|
||
)?;
|
||
|
||
if levcom.nlinku > MLINE as i32 {
|
||
quit_func("too many internal lines", levcom.nlinku, MLINE as i32);
|
||
}
|
||
|
||
let n1 = atomic.ionpar.nfirst[ion] as usize;
|
||
let nlii = atomic.ionpar.nlast[ion] as usize - n1 + 1;
|
||
|
||
// 处理每个跃迁对
|
||
for il in 0..(nlii - 1) {
|
||
let mut kevl = 0;
|
||
let mut kodl = 0;
|
||
|
||
if levcom.jen[il] <= levcom.nevku[ion] {
|
||
kevl = levcom.jen[il];
|
||
} else {
|
||
kodl = levcom.jen[il] - levcom.nevku[ion];
|
||
}
|
||
|
||
let ilok = n1 + il - 1;
|
||
|
||
for iu in (il + 1)..nlii {
|
||
let iupk = n1 + iu - 1;
|
||
let itr = atomic.trapar.itra[ilok][iupk];
|
||
if itr <= 0 {
|
||
continue;
|
||
}
|
||
|
||
let itr_idx = (itr - 1) as usize;
|
||
let indxp = atomic.trapar.indexp[itr_idx].abs();
|
||
let mut w1 = 0.0;
|
||
let mut w2 = 0.0;
|
||
let mut ifrku: usize = 0;
|
||
let mut nft = 0;
|
||
let mut nlt = 0;
|
||
let mut kevu = 0;
|
||
let mut kodu = 0;
|
||
|
||
if levcom.jen[iu] <= levcom.nevku[ion] {
|
||
kevu = levcom.jen[iu];
|
||
} else {
|
||
kodu = levcom.jen[iu] - levcom.nevku[ion];
|
||
}
|
||
|
||
let (kev, kod, gsuper) = if kevl != 0 {
|
||
(
|
||
kevl,
|
||
kodu,
|
||
levcom.ymku[(levcom.jen[il] - 1) as usize][0],
|
||
)
|
||
} else {
|
||
(
|
||
kevu,
|
||
kodl,
|
||
levcom.ymku[(levcom.jen[il] - levcom.nevku[ion] - 1) as usize][1],
|
||
)
|
||
};
|
||
|
||
// 初始化 SIGT
|
||
for ij in 0..nfreq {
|
||
for i in 0..jidn as usize {
|
||
sigt[i][ij] = 0.0;
|
||
}
|
||
}
|
||
|
||
let mut fcol = 0.0;
|
||
|
||
for k in 0..levcom.nlinku as usize {
|
||
let ksev_val = levcom.ksev[k];
|
||
let ksod_val = levcom.ksod[k];
|
||
|
||
if ksev_val != kev && ksod_val != kod {
|
||
continue;
|
||
}
|
||
|
||
nlt += 1;
|
||
let frl = CAS / lined.wave[k];
|
||
let mut ijl = ((xfrma - frl.ln()) / dxnu) as i32 + splcom.nfrs1;
|
||
let mut ijl = ijl as usize;
|
||
if ijl >= nfreq {
|
||
ijl = nfreq - 1;
|
||
}
|
||
|
||
let d0 = ((model.frqall.freq[ijl] - frl)
|
||
/ (model.frqall.freq[ijl] - model.frqall.freq[ijl + 1]))
|
||
.abs();
|
||
|
||
if d0 > HALF {
|
||
while ijl > 0 && frl > model.frqall.freq[ijl] {
|
||
ijl -= 1;
|
||
}
|
||
while ijl < nfreq - 1 && frl < model.frqall.freq[ijl] {
|
||
ijl += 1;
|
||
}
|
||
|
||
if ijl > 0 {
|
||
let d1 = frl - model.frqall.freq[ijl];
|
||
let d2 = model.frqall.freq[ijl - 1] - frl;
|
||
if d2 < d1 {
|
||
ijl -= 1;
|
||
}
|
||
}
|
||
}
|
||
|
||
let ij0 = ijl.saturating_sub(ijd as usize).max(0);
|
||
let ij1 = (ijl + ijd as usize).min(nfreq - 1);
|
||
|
||
if ifrku == 0 {
|
||
ifrku = ij0;
|
||
}
|
||
nft = (ij1 - ifrku + 1) as i32;
|
||
|
||
for ij in ij0..=ij1 {
|
||
let dnu = model.frqall.freq[ij] - frl;
|
||
for i in 0..jidn as usize {
|
||
let vv = dnu * lined.vdop[k][i] as f64;
|
||
let prfk = voigte_func(vv, lined.agam[k][i] as f64) / gsuper;
|
||
sigt[i][ij] += lined.sig0[k][i] as f64 * prfk;
|
||
}
|
||
}
|
||
|
||
fcol += lined.sig0[k][jidc as usize - 1] as f64
|
||
/ lined.vdop[k][jidc as usize - 1] as f64;
|
||
}
|
||
|
||
// 设置振子强度（只读访问，实际写入需要可变引用）
|
||
let _osc0_val = if indxp == 3 || indxp == 4 {
|
||
atomic.trapar.strlx
|
||
} else if fcol > 0.0 {
|
||
fcol / gsuper / CSIG
|
||
} else {
|
||
0.0
|
||
};
|
||
|
||
if nlt > 0 {
|
||
w1 = CAS / model.frqall.freq[ifrku];
|
||
w2 = CAS / model.frqall.freq[ifrku + nft as usize - 1];
|
||
}
|
||
|
||
if nft > 0 {
|
||
nftt += nft;
|
||
|
||
// 存储截面对数
|
||
for ij in ifrku..(ifrku + nft as usize) {
|
||
let kj = ij - ifrku + nftt as usize - nft as usize + 1;
|
||
// Fortran line 189-191: 检查是否超过 MCFE 限制
|
||
if kj > MCFE {
|
||
quit_func(
|
||
" Too many Fe cross-sect. to store",
|
||
kj as i32,
|
||
MCFE as i32,
|
||
);
|
||
}
|
||
for i in 0..jidn as usize {
|
||
let sxx = (sigt[i][ij] + 1e-40f64).ln();
|
||
if kj < splcom.sigfe[0].len() && i < splcom.sigfe[0][kj].len() {
|
||
splcom.sigfe[0][kj][i] = sxx as f32;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 输出谱线摘要
|
||
writeln!(
|
||
writer41,
|
||
"{:4}{:4}{:12.3}{:12.3}{:10}{:10}{:10}{:12.3e}",
|
||
il + 1,
|
||
iu + 1,
|
||
w1,
|
||
w2,
|
||
ifrku + 1,
|
||
nft,
|
||
nlt,
|
||
_osc0_val
|
||
)?;
|
||
|
||
if nft > nftmx {
|
||
nftmx = nft;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 调试输出
|
||
writeln!(
|
||
writer10,
|
||
" Max. number of freq. per transition: {}",
|
||
nftmx
|
||
)?;
|
||
writeln!(
|
||
writer10,
|
||
" Number of iron line cross-sections: {}",
|
||
nftt
|
||
)?;
|
||
|
||
splcom.nftt = nftt;
|
||
|
||
// 对应 Fortran line 170: CALL IJALI2
|
||
// 设置 ALI 频率索引
|
||
callbacks.call_ijali2();
|
||
|
||
Ok(IrosetOutput { nftmx, nftt })
|
||
}
|
||
|
||
// ============================================================================
|
||
// 测试
|
||
// ============================================================================
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
|
||
#[test]
|
||
fn test_csig_constant() {
|
||
assert!((CSIG - 0.0149736).abs() < 1e-10);
|
||
}
|
||
|
||
#[test]
|
||
fn test_lined_creation() {
|
||
let lined = Lined::new(100, 3);
|
||
assert_eq!(lined.wave.len(), 100);
|
||
assert_eq!(lined.vdop.len(), 100);
|
||
assert_eq!(lined.vdop[0].len(), 3);
|
||
assert_eq!(lined.jtr.len(), 100);
|
||
}
|
||
|
||
#[test]
|
||
fn test_colkur_default() {
|
||
let colkur = ColKur::default();
|
||
assert_eq!(colkur.omes.len(), 100);
|
||
assert_eq!(colkur.eku.len(), 15000);
|
||
assert_eq!(colkur.kku.len(), 15000);
|
||
}
|
||
|
||
#[test]
|
||
fn test_setup_depth_interpolation() {
|
||
let nd = 50;
|
||
let dm: Vec<f64> = (1..=nd).map(|i| i as f64 * 0.1).collect();
|
||
|
||
let mut jidr = vec![0; MDODF];
|
||
let mut jidi = vec![0; MDEPTH];
|
||
let mut xjid = vec![0.0; MDEPTH];
|
||
|
||
// 测试默认模式 (jids = 0)
|
||
let (jidn, jidc) = setup_depth_interpolation(nd, 0, &dm, &mut jidr, &mut jidi, &mut xjid);
|
||
|
||
assert_eq!(jidn, 3);
|
||
assert_eq!(jidc, 2);
|
||
assert_eq!(jidr[0], 1);
|
||
assert_eq!(jidr[2], nd);
|
||
|
||
// 测试用户指定间隔模式
|
||
let mut jidr2 = vec![0; MDODF];
|
||
let mut jidi2 = vec![0; MDEPTH];
|
||
let mut xjid2 = vec![0.0; MDEPTH];
|
||
|
||
let (jidn2, _jidc2) =
|
||
setup_depth_interpolation(nd, 10, &dm, &mut jidr2, &mut jidi2, &mut xjid2);
|
||
|
||
assert!(jidn2 >= 3);
|
||
assert_eq!(jidr2[0], 1);
|
||
}
|
||
|
||
#[test]
|
||
fn test_iroset_pure_empty() {
|
||
// 测试空输入
|
||
let mut atomic = AtomicData::default();
|
||
let mut model = ModelState::default();
|
||
let mut odf = OdfData::default();
|
||
|
||
// 设置基本参数
|
||
atomic.ionpar.nfirst[0] = 1;
|
||
atomic.ionpar.nlast[0] = 5;
|
||
atomic.iondat.nlevs[0] = 5;
|
||
atomic.iondat.nllim[0] = 5; // 所有能级在 LTE
|
||
|
||
// 初始化模型数据
|
||
model.modpar.dm = vec![0.1, 0.2, 0.3]; // 3 个深度点
|
||
|
||
let basnum = BasNum::default();
|
||
let ifwop = vec![0; 10];
|
||
|
||
let mut params = IrosetParams {
|
||
nd: 3,
|
||
nfreq: 100,
|
||
nion: 1,
|
||
teff: 10000.0,
|
||
bergfc: 0.0,
|
||
atomic: &atomic,
|
||
model: &model,
|
||
odf: &mut odf,
|
||
basnum: &basnum,
|
||
ifwop: &ifwop,
|
||
fiodf1_list: &[],
|
||
};
|
||
|
||
let mut lined = Lined::new(100, 3);
|
||
let mut colkur = ColKur::default();
|
||
let mut wop = vec![vec![0.0; 3]; 10];
|
||
let mut callbacks = NoOpCallbacks;
|
||
|
||
let result = iroset_pure(&mut params, &mut lined, &mut colkur, &mut wop, &mut callbacks);
|
||
|
||
// 由于所有能级在 LTE，应该跳过处理
|
||
assert!(result.nftmx >= 0);
|
||
assert!(result.nftt >= 0);
|
||
}
|
||
|
||
#[test]
|
||
fn test_iroset_with_writer() {
|
||
use std::io::Cursor;
|
||
|
||
let mut atomic = AtomicData::default();
|
||
let mut model = ModelState::default();
|
||
let mut odf = OdfData::default();
|
||
|
||
atomic.iondat.nlevs[0] = 5;
|
||
atomic.iondat.nllim[0] = 5;
|
||
|
||
// 初始化模型数据
|
||
model.modpar.dm = vec![0.1, 0.2, 0.3]; // 3 个深度点
|
||
|
||
let basnum = BasNum::default();
|
||
let ifwop = vec![0; 10];
|
||
|
||
let mut params = IrosetParams {
|
||
nd: 3,
|
||
nfreq: 100,
|
||
nion: 1,
|
||
teff: 10000.0,
|
||
bergfc: 0.0,
|
||
atomic: &atomic,
|
||
model: &model,
|
||
odf: &mut odf,
|
||
basnum: &basnum,
|
||
ifwop: &ifwop,
|
||
fiodf1_list: &[],
|
||
};
|
||
|
||
let mut lined = Lined::new(100, 3);
|
||
let mut colkur = ColKur::default();
|
||
let mut wop = vec![vec![0.0; 3]; 10];
|
||
let mut callbacks = NoOpCallbacks;
|
||
|
||
let mut writer6 = Cursor::new(Vec::new());
|
||
let mut writer10 = Cursor::new(Vec::new());
|
||
let mut writer41 = Cursor::new(Vec::new());
|
||
|
||
let result = iroset(
|
||
&mut params,
|
||
&mut lined,
|
||
&mut colkur,
|
||
&mut wop,
|
||
&mut writer6,
|
||
&mut writer10,
|
||
&mut writer41,
|
||
&mut callbacks,
|
||
)
|
||
.unwrap();
|
||
|
||
assert!(result.nftmx >= 0);
|
||
|
||
// 验证调试输出
|
||
let debug_output = String::from_utf8(writer10.into_inner()).unwrap();
|
||
assert!(debug_output.contains("freq."));
|
||
}
|
||
}
|