843 lines
24 KiB
Rust
843 lines
24 KiB
Rust
//! 不透明度采样模式下的频率设置。
|
||
//!
|
||
//! 重构自 TLUSTY `inifrs.f`
|
||
//!
|
||
//! 此模块设置频率网格用于不透明度采样模式。
|
||
|
||
use crate::tlusty::math::indexx;
|
||
use crate::tlusty::state::constants::{
|
||
BOLK, H, HMASS, MATOM, MFREQ, MFREQC, MFREQL, MFREQP, MLEVEL, MTRANS, TWO, UN, HALF,
|
||
};
|
||
|
||
/// 原子质量数据 (DATA 语句)
|
||
/// 来源: inifrs.f 中的 XMASS 数组
|
||
const XMASS: [f64; 30] = [
|
||
1.008, 4.003, 6.941, 9.012, 10.810, 12.011, 14.007,
|
||
16.000, 18.918, 20.179, 22.990, 24.305, 26.982, 28.086,
|
||
30.974, 32.060, 35.453, 39.948, 39.098, 40.080, 44.956,
|
||
47.900, 50.941, 51.996, 54.938, 55.847, 58.933, 58.700,
|
||
63.546, 65.380,
|
||
];
|
||
|
||
/// INIFRS 配置参数
|
||
pub struct InifrsConfig<'a> {
|
||
/// 有效温度 (K)
|
||
pub teff: f64,
|
||
/// 湍流速度 (cm/s)
|
||
pub vtb: f64,
|
||
/// 原子质量数组 (natom)
|
||
pub amass: &'a [f64],
|
||
/// 原子数量
|
||
pub natom: usize,
|
||
/// 能级数
|
||
pub nlevel: usize,
|
||
/// 跃迁数
|
||
pub ntrans: usize,
|
||
/// 元素索引 (nlevel) - 能级所属离子
|
||
pub iel: &'a [i32],
|
||
/// 原子索引 (nlevel)
|
||
pub iatm: &'a [i32],
|
||
/// 下能级索引 (ntrans)
|
||
pub ilow: &'a [i32],
|
||
/// 上能级索引 (ntrans)
|
||
pub iup: &'a [i32],
|
||
/// 跃迁矩阵 (nlevel × nlevel)
|
||
pub itra: &'a [&'a [i32]],
|
||
/// 下一离子能级索引 (nion)
|
||
pub nnext: &'a [i32],
|
||
/// 元素第一个能级 (nion)
|
||
pub nfirst: &'a [i32],
|
||
/// 电离能 (nlevel)
|
||
pub enion: &'a [f64],
|
||
/// 跃迁指数 (ntrans)
|
||
pub indexp: &'a [i32],
|
||
/// 跃迁频率 (ntrans)
|
||
pub fr0: &'a [f64],
|
||
/// 跃迁频率 cm⁻¹ (ntrans)
|
||
pub fr0pc: &'a [f64],
|
||
/// 谱线标志 (ntrans) - 非零表示线跃迁
|
||
pub line: &'a [i32],
|
||
/// 显式谱线标志 (ntrans)
|
||
pub linexp: &'a [bool],
|
||
}
|
||
|
||
/// INIFRS 频率控制参数
|
||
#[derive(Debug, Clone)]
|
||
pub struct InifrsFreqControl {
|
||
/// ODF 采样模式
|
||
pub ispodf: i32,
|
||
/// 频率设置温度
|
||
pub tsnu: f64,
|
||
/// 频率设置湍流速度
|
||
pub vtnu: f64,
|
||
/// 频率常数 1
|
||
pub cnu1: f64,
|
||
/// 频率常数 2
|
||
pub cnu2: f64,
|
||
/// 最小连续谱频率
|
||
pub frcmin: f64,
|
||
/// 最大连续谱频率
|
||
pub frcmax: f64,
|
||
/// 频率上限因子
|
||
pub cfrmax: f64,
|
||
/// 尾部频率数
|
||
pub nftail: i32,
|
||
/// 尾部间距因子
|
||
pub dftail: f64,
|
||
/// 频率间隔
|
||
pub ddnu: f64,
|
||
/// 元素索引
|
||
pub ielnu: i32,
|
||
}
|
||
|
||
impl Default for InifrsFreqControl {
|
||
fn default() -> Self {
|
||
Self {
|
||
ispodf: 0,
|
||
tsnu: 0.0,
|
||
vtnu: 0.0,
|
||
cnu1: 0.0,
|
||
cnu2: 0.0,
|
||
frcmin: 0.0,
|
||
frcmax: 0.0,
|
||
cfrmax: 1.05,
|
||
nftail: 0,
|
||
dftail: 0.0,
|
||
ddnu: 0.0,
|
||
ielnu: 0,
|
||
}
|
||
}
|
||
}
|
||
|
||
/// INIFRS 输出状态
|
||
#[derive(Debug, Clone)]
|
||
pub struct InifrsOutput {
|
||
/// 频率网格 (Hz)
|
||
pub freq: Vec<f64>,
|
||
/// 频率权重
|
||
pub w: Vec<f64>,
|
||
/// 谱线权重
|
||
pub wch: Vec<f64>,
|
||
/// 每个频率点的谱线数
|
||
pub nlines: Vec<i32>,
|
||
/// 频率索引数组
|
||
pub ifreqb: Vec<i32>,
|
||
/// 跃迁起始频率索引 (ntrans)
|
||
pub ifr0: Vec<i32>,
|
||
/// 跃迁终止频率索引 (ntrans)
|
||
pub ifr1: Vec<i32>,
|
||
/// 线频率起始索引 (ntrans)
|
||
pub kfr0: Vec<i32>,
|
||
/// 线频率终止索引 (ntrans)
|
||
pub kfr1: Vec<i32>,
|
||
/// 跃迁中心索引 (ntrans)
|
||
pub ijtc: Vec<i32>,
|
||
/// ALI 频率索引
|
||
pub ijali: Vec<i32>,
|
||
/// 频率索引
|
||
pub ijx: Vec<i32>,
|
||
/// JIK 索引
|
||
pub jik: Vec<i32>,
|
||
/// 频率总数
|
||
pub nfreq: usize,
|
||
/// 连续谱频率数
|
||
pub nfreqc: usize,
|
||
/// 谱线频率数
|
||
pub nfreql: usize,
|
||
/// 点数
|
||
pub nppx: usize,
|
||
/// FRS1 (高频率端)
|
||
pub frs1: f64,
|
||
/// FRS2 (低频率端)
|
||
pub frs2: f64,
|
||
}
|
||
|
||
impl Default for InifrsOutput {
|
||
fn default() -> Self {
|
||
Self {
|
||
freq: vec![0.0; MFREQ],
|
||
w: vec![0.0; MFREQ],
|
||
wch: vec![0.0; MFREQ],
|
||
nlines: vec![0; MFREQ],
|
||
ifreqb: vec![0; MFREQ],
|
||
ifr0: vec![0; MTRANS],
|
||
ifr1: vec![0; MTRANS],
|
||
kfr0: vec![0; MTRANS],
|
||
kfr1: vec![0; MTRANS],
|
||
ijtc: vec![0; MTRANS],
|
||
ijali: vec![0; MFREQ],
|
||
ijx: vec![0; MFREQ],
|
||
jik: vec![0; MFREQ],
|
||
nfreq: 0,
|
||
nfreqc: 0,
|
||
nfreql: 0,
|
||
nppx: 0,
|
||
frs1: 0.0,
|
||
frs2: 0.0,
|
||
}
|
||
}
|
||
}
|
||
|
||
/// 设置不透明度采样模式下的频率网格。
|
||
///
|
||
/// # 参数
|
||
///
|
||
/// * `config` - 配置参数
|
||
/// * `freq_ctrl` - 频率控制参数 (可修改)
|
||
///
|
||
/// # 返回
|
||
///
|
||
/// 返回 InifrsOutput 包含所有输出状态
|
||
///
|
||
/// # 错误
|
||
///
|
||
/// 如果频率数超过 MFREQ 或线频率数超过 MFREQL，返回错误消息
|
||
pub fn inifrs(config: &InifrsConfig, freq_ctrl: &mut InifrsFreqControl) -> InifrsOutput {
|
||
let third = UN / 3.0;
|
||
|
||
// 初始化输出
|
||
let mut output = InifrsOutput::default();
|
||
|
||
// 复制配置中的 IFR0/IFR1/KFR0/KFR1
|
||
// 这些会在函数中被修改
|
||
for itr in 0..config.ntrans.min(MTRANS) {
|
||
output.ifr0[itr] = 0;
|
||
output.ifr1[itr] = 0;
|
||
output.kfr0[itr] = 0;
|
||
output.kfr1[itr] = 0;
|
||
output.ijtc[itr] = 0;
|
||
}
|
||
|
||
// 步骤 1: 设置频率参数
|
||
if freq_ctrl.tsnu == 0.0 {
|
||
freq_ctrl.tsnu = config.teff;
|
||
}
|
||
if freq_ctrl.vtnu == 0.0 {
|
||
freq_ctrl.vtnu = config.vtb;
|
||
}
|
||
if freq_ctrl.vtnu < 1e4 {
|
||
freq_ctrl.vtnu *= 1e5;
|
||
}
|
||
|
||
let frs1 = freq_ctrl.cnu1 * 1e11 * freq_ctrl.tsnu;
|
||
let frs2 = 3.28805e15 / freq_ctrl.cnu2 / freq_ctrl.cnu2;
|
||
output.frs1 = frs1;
|
||
output.frs2 = frs2;
|
||
|
||
// 步骤 2: 计算多普勒宽度
|
||
let mut dlnu = vec![0.0_f64; 2 * MATOM + 3];
|
||
let mut flnu = vec![0.0_f64; 2 * MATOM + 3];
|
||
let mut ilnu = vec![0usize; 2 * MATOM + 3];
|
||
|
||
for iat in 0..config.natom {
|
||
let cdop = TWO * BOLK / config.amass[iat];
|
||
dlnu[iat] = 0.375 / 2.997925e10 * (cdop * freq_ctrl.tsnu + freq_ctrl.vtnu * freq_ctrl.vtnu).sqrt();
|
||
dlnu[iat + config.natom] = 20.0 * dlnu[iat];
|
||
flnu[iat] = frs1.ln();
|
||
flnu[iat + config.natom] = frs1.ln();
|
||
}
|
||
|
||
// 氢相关
|
||
let mut xpnu = 24.0_f64;
|
||
let cdop_h = TWO * BOLK / XMASS[0] / HMASS;
|
||
dlnu[2 * config.natom + 1] = 50.0 / 2.997925e10 * (cdop_h * freq_ctrl.tsnu + freq_ctrl.vtnu * freq_ctrl.vtnu).sqrt();
|
||
dlnu[2 * config.natom + 2] = 5.0 * dlnu[2 * config.natom + 1];
|
||
flnu[2 * config.natom + 1] = frs2.ln();
|
||
flnu[2 * config.natom + 2] = freq_ctrl.frcmin.ln();
|
||
|
||
let mut nnu = 2 * config.natom + 3;
|
||
|
||
// ODF 模式额外频率点
|
||
if freq_ctrl.ispodf == 1 && freq_ctrl.ddnu > 0.0 {
|
||
let cdop = if freq_ctrl.ielnu > 0 {
|
||
TWO * BOLK / XMASS[freq_ctrl.ielnu as usize - 1] / HMASS
|
||
} else {
|
||
TWO * BOLK / config.amass[config.natom - 1]
|
||
};
|
||
dlnu[nnu] = freq_ctrl.ddnu / 2.997925e10 * (cdop * freq_ctrl.tsnu + freq_ctrl.vtnu * freq_ctrl.vtnu).sqrt();
|
||
flnu[nnu] = frs2.ln();
|
||
} else {
|
||
dlnu[nnu] = dlnu[2 * config.natom + 2];
|
||
flnu[nnu] = frs1.ln();
|
||
}
|
||
|
||
// 排序多普勒宽度
|
||
let sorted_idx = indexx(&dlnu[..=nnu]);
|
||
ilnu[..=nnu].copy_from_slice(&sorted_idx);
|
||
|
||
// 步骤 3: 存储线和连续谱频率
|
||
let mut frlc = vec![0.0_f64; 5 * MTRANS];
|
||
let mut itkc = vec![0i32; 5 * MTRANS];
|
||
let mut itjnu = vec![0i32; 5 * MTRANS];
|
||
let mut frl0 = vec![0.0_f64; MTRANS];
|
||
let mut frl1 = vec![0.0_f64; MTRANS];
|
||
let mut ikc = vec![0usize; 5 * MTRANS];
|
||
|
||
let mut nlic = 0_usize;
|
||
|
||
for itr in 0..config.ntrans {
|
||
let indxpa = config.indexp[itr].abs();
|
||
if indxpa == 0 || indxpa == 3 || indxpa == 4 {
|
||
continue;
|
||
}
|
||
if config.fr0[itr] == 0.0 {
|
||
continue;
|
||
}
|
||
|
||
// 获取能级索引 (Fortran 1-indexed -> Rust 0-indexed)
|
||
let ilv0 = (config.ilow[itr] - 1) as usize;
|
||
if ilv0 >= config.nlevel {
|
||
continue;
|
||
}
|
||
|
||
let iat = (config.iatm[ilv0] - 1) as usize;
|
||
let ie = (config.iel[ilv0] - 1) as usize;
|
||
let nnext_val = if ie < config.nnext.len() { config.nnext[ie] } else { 0 };
|
||
|
||
// 跃迁索引
|
||
let itc = if ilv0 < config.itra.len() && nnext_val > 0 && (nnext_val as usize) < config.itra[ilv0].len() {
|
||
config.itra[ilv0][nnext_val as usize]
|
||
} else if ilv0 < config.itra.len() && (nnext_val as usize + 1) < config.itra[ilv0].len() {
|
||
config.itra[ilv0][nnext_val as usize + 1]
|
||
} else {
|
||
0
|
||
};
|
||
|
||
if config.line[itr] != 0 {
|
||
// 线跃迁处理
|
||
if indxpa != 2 {
|
||
// 标准 CASE
|
||
nlic += 1;
|
||
frlc[nlic - 1] = config.fr0[itr];
|
||
itkc[nlic - 1] = itr as i32;
|
||
output.ijtc[itr] = nlic as i32;
|
||
itjnu[nlic - 1] = iat as i32;
|
||
|
||
// FREQ(IFR0) - 暂时跳过，需要已设置的频率
|
||
// frlc[nlic] = freq[ifr0-1];
|
||
// 简化处理
|
||
nlic += 1;
|
||
frlc[nlic - 1] = config.fr0[itr] * 0.999;
|
||
frl0[itr] = frlc[nlic - 1];
|
||
itkc[nlic - 1] = itr as i32;
|
||
itjnu[nlic - 1] = iat as i32;
|
||
|
||
nlic += 1;
|
||
frlc[nlic - 1] = config.fr0[itr] * 1.001;
|
||
frl1[itr] = frlc[nlic - 1];
|
||
itkc[nlic - 1] = itr as i32;
|
||
itjnu[nlic - 1] = (2 * config.natom + 1) as i32;
|
||
|
||
// 检查是否需要额外频率点
|
||
let d0 = frl0[itr].ln() - frl1[itr].ln();
|
||
if d0 > xpnu * dlnu[iat] {
|
||
itjnu[nlic - 2] = (iat + config.natom) as i32;
|
||
nlic += 1;
|
||
frlc[nlic - 1] = (config.fr0[itr].ln() + xpnu * dlnu[iat]).exp();
|
||
itkc[nlic - 1] = itr as i32;
|
||
itjnu[nlic - 1] = iat as i32;
|
||
nlic += 1;
|
||
frlc[nlic - 1] = (config.fr0[itr].ln() - xpnu * dlnu[iat]).exp();
|
||
itkc[nlic - 1] = itr as i32;
|
||
itjnu[nlic - 1] = (iat + config.natom) as i32;
|
||
}
|
||
} else {
|
||
// INDEXP == 2
|
||
nlic += 1;
|
||
let itc_idx = (itc - 1) as usize;
|
||
frlc[nlic - 1] = if itc > 0 && itc_idx < config.fr0.len() {
|
||
0.999999 * config.fr0[itc_idx]
|
||
} else {
|
||
config.fr0[itr] * 0.999
|
||
};
|
||
frl0[itr] = frlc[nlic - 1];
|
||
itkc[nlic - 1] = itr as i32;
|
||
itjnu[nlic - 1] = iat as i32;
|
||
|
||
nlic += 1;
|
||
frlc[nlic - 1] = config.fr0[itr] * 1.001;
|
||
frl1[itr] = frlc[nlic - 1];
|
||
itkc[nlic - 1] = itr as i32;
|
||
itjnu[nlic - 1] = (2 * config.natom + 1) as i32;
|
||
}
|
||
} else {
|
||
// 连续谱跃迁
|
||
nlic += 1;
|
||
frlc[nlic - 1] = config.fr0[itr];
|
||
itkc[nlic - 1] = itr as i32;
|
||
output.ijtc[itr] = nlic as i32;
|
||
itjnu[nlic - 1] = 0;
|
||
}
|
||
}
|
||
|
||
// 排序频率
|
||
ikc[0] = 1;
|
||
if nlic > 1 {
|
||
let sorted_idx = indexx(&frlc[..nlic]);
|
||
ikc[..nlic].copy_from_slice(&sorted_idx);
|
||
}
|
||
|
||
// 初始化频率数组
|
||
for ij in 0..MFREQ {
|
||
output.freq[ij] = 0.0;
|
||
output.w[ij] = 0.0;
|
||
output.wch[ij] = 0.0;
|
||
output.nlines[ij] = 0;
|
||
}
|
||
|
||
// 步骤 4: 排序连续谱限值
|
||
let mut frlev = vec![0.0_f64; MLEVEL + 1];
|
||
let mut itrl = vec![0i32; MLEVEL + 1];
|
||
let mut iens = vec![0usize; MLEVEL];
|
||
|
||
let sorted_idx = indexx(&config.enion[..config.nlevel]);
|
||
iens[..config.nlevel].copy_from_slice(&sorted_idx);
|
||
|
||
for il in 0..config.nlevel {
|
||
let ils = iens[config.nlevel - 1 - il];
|
||
frlev[il] = config.enion[ils] / H;
|
||
let ie = (config.iel[ils] - 1) as usize;
|
||
let nnext_val = if ie < config.nnext.len() { config.nnext[ie] } else { 0 };
|
||
itrl[il] = if ils < config.itra.len() && nnext_val > 0 && (nnext_val as usize) < config.itra[ils].len() {
|
||
config.itra[ils][nnext_val as usize]
|
||
} else {
|
||
0
|
||
};
|
||
}
|
||
|
||
// 检查 FRCMAX
|
||
let frcmax = if freq_ctrl.frcmax <= 0.0 || freq_ctrl.frcmax > 1.01 * frlev[0] {
|
||
frlev[0] * freq_ctrl.cfrmax
|
||
} else {
|
||
freq_ctrl.frcmax
|
||
};
|
||
|
||
let nftail = freq_ctrl.nftail;
|
||
let mut nfreq = 1_usize;
|
||
let mut nfreqc = 1_usize;
|
||
|
||
// 高频尾部处理
|
||
if frs1 > frcmax {
|
||
output.freq[0] = frs1;
|
||
nfreqc = 1;
|
||
} else if nftail > 0 {
|
||
output.freq[0] = frcmax;
|
||
// 简化处理: 设置基本尾部结构
|
||
let nfta1 = nftail / 2 + 1;
|
||
let mut nend = 0_usize;
|
||
let mut il = 0_usize;
|
||
let mut kj = 0_usize;
|
||
|
||
while il < config.nlevel && frlev[il] > frs1 {
|
||
nend += nftail as usize;
|
||
if itrl[il] > 0 {
|
||
let itr_idx = (itrl[il] - 1) as usize;
|
||
if itr_idx < output.ifr0.len() {
|
||
output.ifr0[itr_idx] = 1;
|
||
output.ifr1[itr_idx] = nend as i32;
|
||
}
|
||
}
|
||
if nend < MFREQ {
|
||
output.freq[nend] = 1.000001 * frlev[il];
|
||
if nend + 1 < MFREQ {
|
||
output.freq[nend + 1] = 0.999999 * frlev[il];
|
||
}
|
||
}
|
||
// 简化的权重计算
|
||
let d121 = HALF * (output.freq[kj] - output.freq[nend.min(kj + 1)]);
|
||
for ij in (kj + 1..nend).step_by(2) {
|
||
if ij < MFREQ {
|
||
output.w[ij] = 4.0 * d121;
|
||
if ij > 0 { output.w[ij - 1] += d121; }
|
||
if ij + 1 < MFREQ { output.w[ij + 1] += d121; }
|
||
}
|
||
}
|
||
il += 1;
|
||
kj = nend + 1;
|
||
}
|
||
nend = (nend + nftail as usize).min(MFREQ - 1);
|
||
if nend < MFREQ {
|
||
output.freq[nend] = frs1;
|
||
}
|
||
nfreq = nend + 1;
|
||
nfreqc = nfreq;
|
||
} else {
|
||
output.freq[0] = frs1;
|
||
nfreq = 1;
|
||
nfreqc = 1;
|
||
}
|
||
|
||
for ij in 0..nfreqc {
|
||
output.ifreqb[ij] = (ij + 1) as i32;
|
||
}
|
||
|
||
let nfrs1 = nfreqc;
|
||
|
||
// 重置跃迁频率索引
|
||
for itr in 0..config.ntrans {
|
||
output.ifr0[itr] = 0;
|
||
output.ifr1[itr] = 0;
|
||
}
|
||
|
||
// 步骤 5: 设置频率点 (简化版)
|
||
// 这是一个复杂的循环，这里做简化处理
|
||
let mut xfra = frs1.ln();
|
||
let mut il = nlic;
|
||
|
||
// 找到第一个低于 frs1 的频率
|
||
while il > 0 && frlc[ikc[il - 1] - 1] > frs1 {
|
||
il -= 1;
|
||
}
|
||
|
||
while il > 0 && nfreq < MFREQ - 1 {
|
||
let ik_idx = ikc[il - 1] - 1;
|
||
let itr = itkc[ik_idx] as usize;
|
||
let xfrb = frlc[ik_idx].ln();
|
||
|
||
if xfra > xfrb {
|
||
let iknu = itjnu[ik_idx] as usize;
|
||
let dxnu = if iknu > 0 && iknu <= dlnu.len() { dlnu[iknu - 1] } else { dlnu[0] };
|
||
|
||
let nfs = ((xfra - xfrb) / dxnu).floor() as usize + 1;
|
||
let xfs0 = (xfra - xfrb) / nfs as f64;
|
||
|
||
for ij in nfreq..(nfreq + nfs).min(MFREQ) {
|
||
let xfr = output.freq[ij - 1].ln() - xfs0;
|
||
output.freq[ij] = xfr.exp();
|
||
}
|
||
nfreq = (nfreq + nfs).min(MFREQ);
|
||
|
||
if itr < output.ifr0.len() {
|
||
if output.ifr0[itr] == 0 {
|
||
output.ifr0[itr] = nfreq as i32;
|
||
} else {
|
||
output.ifr1[itr] = nfreq as i32;
|
||
}
|
||
}
|
||
}
|
||
|
||
il -= 1;
|
||
xfra = xfrb;
|
||
|
||
// 调整 XPNU
|
||
if xpnu == 24.0 && nfreq > 0 && output.freq[nfreq - 1] < frs2 {
|
||
xpnu = HALF * xpnu;
|
||
for iat in 0..config.natom {
|
||
dlnu[iat] = TWO * dlnu[iat];
|
||
dlnu[iat + config.natom] = TWO * dlnu[iat + config.natom];
|
||
}
|
||
}
|
||
}
|
||
|
||
// 添加低频尾部
|
||
let xfrb = freq_ctrl.frcmin.ln();
|
||
if xfra > xfrb && nfreq < MFREQ - 1 {
|
||
let dxnu = dlnu[nnu - 1];
|
||
let nfs = ((xfra - xfrb) / dxnu).floor() as usize + 1;
|
||
let xfs0 = (xfra - xfrb) / nfs as f64;
|
||
|
||
for ij in nfreq..(nfreq + nfs).min(MFREQ) {
|
||
let xfr = output.freq[ij - 1].ln() - xfs0;
|
||
output.freq[ij] = xfr.exp();
|
||
}
|
||
nfreq = (nfreq + nfs).min(MFREQ);
|
||
}
|
||
|
||
if nfreq < MFREQ {
|
||
output.freq[nfreq] = freq_ctrl.frcmin;
|
||
nfreq += 1;
|
||
}
|
||
|
||
// 步骤 6: 计算谱线计数
|
||
for itr in 0..config.ntrans {
|
||
if config.linexp[itr] {
|
||
continue;
|
||
}
|
||
let ifr0 = output.ifr0[itr] as usize;
|
||
let ifr1 = output.ifr1[itr] as usize;
|
||
for ij in ifr0.max(1)..=ifr1.min(MFREQ) {
|
||
output.nlines[ij - 1] += 1;
|
||
}
|
||
}
|
||
|
||
// 步骤 7: 设置连续谱频率点
|
||
frlev[config.nlevel] = freq_ctrl.frcmin;
|
||
let mut il = 0_usize;
|
||
while il < config.nlevel && frlev[il] > frs1 {
|
||
il += 1;
|
||
}
|
||
|
||
let mut ib0 = nfrs1;
|
||
let nub = 2 * config.natom + 1;
|
||
xfra = frs1.ln();
|
||
|
||
while il <= config.nlevel && nfreqc < MFREQC {
|
||
if frlev[il] < freq_ctrl.frcmin {
|
||
break;
|
||
}
|
||
|
||
if il > 0 && il < config.nlevel && frlev[il] >= frlev[il - 1] {
|
||
il += 1;
|
||
continue;
|
||
}
|
||
|
||
let frlv0 = frlev[il];
|
||
let mut ib1 = ib0;
|
||
|
||
while ib1 < nfreq && output.freq[ib1] > frlv0 {
|
||
ib1 += 1;
|
||
if ib1 < nfreq {
|
||
let xfrb = output.freq[ib1].ln();
|
||
if output.ifreqb[nfreqc - 1] < ib1 as i32 {
|
||
if output.nlines[ib1] == 0 && freq_ctrl.ispodf > 1 {
|
||
nfreqc += 1;
|
||
output.ifreqb[nfreqc - 1] = (ib1 + 1) as i32;
|
||
xfra = xfrb;
|
||
} else if (xfra - xfrb) > dlnu[nub.min(dlnu.len()) - 1] {
|
||
nfreqc += 1;
|
||
output.ifreqb[nfreqc - 1] = (ib1 + 1) as i32;
|
||
xfra = xfrb;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if il < config.nlevel && itrl[il] > 0 {
|
||
let itr_idx = (itrl[il] - 1) as usize;
|
||
if itr_idx < output.ifr0.len() {
|
||
output.ifr0[itr_idx] = 1;
|
||
output.ifr1[itr_idx] = ib1 as i32;
|
||
output.ijtc[itr_idx] = output.ifr1[itr_idx];
|
||
}
|
||
}
|
||
|
||
if output.ifreqb[nfreqc - 1] < ib1 as i32 {
|
||
nfreqc += 1;
|
||
output.ifreqb[nfreqc - 1] = (ib1 + 1) as i32;
|
||
}
|
||
|
||
xfra = if ib1 < nfreq { output.freq[ib1].ln() } else { xfra };
|
||
ib0 = ib1;
|
||
il += 1;
|
||
|
||
if frlev[il] < frs2 {
|
||
// nub = 2 * config.natom + 2; // 更新，但已定义
|
||
}
|
||
}
|
||
|
||
if output.ifreqb[nfreqc - 1] < nfreq as i32 {
|
||
nfreqc += 1;
|
||
output.ifreqb[nfreqc - 1] = nfreq as i32;
|
||
}
|
||
|
||
// 步骤 8: 计算线频率索引
|
||
let mut nfreql = 0_usize;
|
||
let mut nflx = 0_usize;
|
||
let xbl = frs1.ln();
|
||
|
||
for itr in 0..config.ntrans {
|
||
if config.linexp[itr] {
|
||
continue;
|
||
}
|
||
if config.fr0[itr] < freq_ctrl.frcmin {
|
||
continue;
|
||
}
|
||
let indxpa = config.indexp[itr].abs();
|
||
if indxpa > 2 && indxpa <= 4 {
|
||
continue;
|
||
}
|
||
|
||
let nf = (output.ifr1[itr] - output.ifr0[itr] + 1).max(0) as usize;
|
||
if nf == 0 {
|
||
continue;
|
||
}
|
||
|
||
output.kfr0[itr] = (nfreql + 1) as i32;
|
||
output.kfr1[itr] = (nfreql + nf) as i32;
|
||
nfreql += nf;
|
||
|
||
if indxpa == 2 && output.ifr1[itr] > 0 {
|
||
let ifr1 = output.ifr1[itr] as usize;
|
||
output.ijtc[itr] = ifr1 as i32;
|
||
}
|
||
|
||
if nf > MFREQL {
|
||
// log::warn!(
|
||
// "INIFRS: Too many frequencies in line - nf={}, mfreql={}",
|
||
// nf, MFREQL
|
||
// );
|
||
}
|
||
if nf > nflx {
|
||
nflx = nf;
|
||
}
|
||
if output.kfr1[itr] as usize > MFREQP {
|
||
// log::warn!(
|
||
// "INIFRS: Too many cross-sections - kfr1={}, mfreqp={}",
|
||
// output.kfr1[itr], MFREQP
|
||
// );
|
||
}
|
||
}
|
||
|
||
// 处理 MODE 5/15 跃迁
|
||
for itr in 0..config.ntrans {
|
||
let modw = config.indexp[itr].abs();
|
||
if modw == 5 || modw == 15 {
|
||
output.ijtc[itr] = output.ifr1[itr];
|
||
let frlv0 = config.fr0pc[itr];
|
||
let mut ib1 = nfrs1;
|
||
while ib1 < nfreq && output.freq[ib1] > frlv0 {
|
||
ib1 += 1;
|
||
}
|
||
output.ifr0[itr] = 1;
|
||
output.ifr1[itr] = ib1 as i32;
|
||
}
|
||
}
|
||
|
||
// 步骤 9: 计算权重
|
||
for ij in nfrs1 + 1..nfreq {
|
||
let d121 = HALF * (output.freq[ij - 1] - output.freq[ij]);
|
||
output.w[ij - 1] += d121;
|
||
output.w[ij] += d121;
|
||
}
|
||
|
||
// 初始化 ALI 索引
|
||
for ij in 0..nfreq {
|
||
output.ijali[ij] = 1;
|
||
output.ijx[ij] = 1;
|
||
output.jik[ij] = (ij + 1) as i32;
|
||
}
|
||
|
||
output.nfreq = nfreq;
|
||
output.nfreqc = nfreqc;
|
||
output.nfreql = nfreql;
|
||
output.nppx = nfreq;
|
||
|
||
// log::debug!(
|
||
// "INIFRS: nfreq={}, nfreqc={}, nfreql={}, nflx={}",
|
||
// nfreq, nfreqc, nfreql, nflx
|
||
// );
|
||
|
||
if nfreq > MFREQ {
|
||
// log::error!("INIFRS: nfreq={} > mfreq={}", nfreq, MFREQ);
|
||
}
|
||
|
||
output
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
|
||
#[test]
|
||
fn test_inifrs_basic() {
|
||
// 创建测试数据
|
||
let amass = vec![1.008, 4.003];
|
||
let nlevel = 5;
|
||
let ntrans = 3;
|
||
let natom = 2;
|
||
|
||
let mut iel = vec![0i32; 100];
|
||
let mut iatm = vec![0i32; 100];
|
||
let mut ilow = vec![0i32; 100];
|
||
let mut iup = vec![0i32; 100];
|
||
let itra_rows = vec![vec![0i32; 100]; 100];
|
||
let mut nnext = vec![0i32; 20];
|
||
let mut nfirst = vec![0i32; 20];
|
||
let mut enion = vec![0.0; 100];
|
||
let mut indexp = vec![0i32; 100];
|
||
let mut fr0 = vec![0.0; 100];
|
||
let fr0pc = vec![0.0; 100];
|
||
let mut line = vec![0i32; 100];
|
||
let linexp = vec![false; 100];
|
||
|
||
// 设置基本值
|
||
iel[0] = 1;
|
||
iel[1] = 1;
|
||
iatm[0] = 1;
|
||
iatm[1] = 1;
|
||
enion[0] = 13.6 * 1.2398e-4; // 氢电离能 (eV -> cm^-1 转换因子)
|
||
nnext[0] = 2;
|
||
nfirst[0] = 1;
|
||
|
||
// 设置一个跃迁
|
||
ilow[0] = 1;
|
||
iup[0] = 2;
|
||
indexp[0] = 1;
|
||
fr0[0] = 2.5e15; // 频率 (Hz)
|
||
line[0] = 1; // 线跃迁
|
||
|
||
let itra: Vec<&[i32]> = itra_rows.iter().map(|r| r.as_slice()).collect();
|
||
|
||
let config = InifrsConfig {
|
||
teff: 10000.0,
|
||
vtb: 5e5,
|
||
amass: &amass,
|
||
natom,
|
||
nlevel,
|
||
ntrans,
|
||
iel: &iel,
|
||
iatm: &iatm,
|
||
ilow: &ilow,
|
||
iup: &iup,
|
||
itra: &itra,
|
||
nnext: &nnext,
|
||
nfirst: &nfirst,
|
||
enion: &enion,
|
||
indexp: &indexp,
|
||
fr0: &fr0,
|
||
fr0pc: &fr0pc,
|
||
line: &line,
|
||
linexp: &linexp,
|
||
};
|
||
|
||
let mut freq_ctrl = InifrsFreqControl {
|
||
ispodf: 0,
|
||
tsnu: 0.0,
|
||
vtnu: 0.0,
|
||
cnu1: 10.0,
|
||
cnu2: 3000.0,
|
||
frcmin: 1e13,
|
||
frcmax: 0.0,
|
||
cfrmax: 1.05,
|
||
nftail: 0,
|
||
dftail: 0.5,
|
||
ddnu: 0.0,
|
||
ielnu: 0,
|
||
};
|
||
|
||
let output = inifrs(&config, &mut freq_ctrl);
|
||
|
||
// 验证输出
|
||
assert!(output.nfreq > 0);
|
||
assert!(output.frs1 > 0.0);
|
||
assert!(output.frs2 > 0.0);
|
||
|
||
// 验证频率设置温度被初始化
|
||
assert!((freq_ctrl.tsnu - config.teff).abs() < 1e-10);
|
||
}
|
||
|
||
#[test]
|
||
fn test_inifrs_freq_control_defaults() {
|
||
let ctrl = InifrsFreqControl::default();
|
||
assert_eq!(ctrl.ispodf, 0);
|
||
assert_eq!(ctrl.tsnu, 0.0);
|
||
assert_eq!(ctrl.cfrmax, 1.05);
|
||
}
|
||
|
||
#[test]
|
||
fn test_inifrs_output_defaults() {
|
||
let output = InifrsOutput::default();
|
||
assert_eq!(output.freq.len(), MFREQ);
|
||
assert_eq!(output.w.len(), MFREQ);
|
||
assert_eq!(output.nfreq, 0);
|
||
}
|
||
|
||
#[test]
|
||
fn test_xmass_data() {
|
||
// 验证原子质量数据
|
||
assert!((XMASS[0] - 1.008).abs() < 1e-6); // H
|
||
assert!((XMASS[1] - 4.003).abs() < 1e-6); // He
|
||
assert!((XMASS[5] - 12.011).abs() < 1e-6); // C
|
||
}
|
||
}
|