299 lines
8.0 KiB
Rust
299 lines
8.0 KiB
Rust
//! 氢线系列的 ODF（Opacity Distribution Function）计算。
|
||
//!
|
||
//! 重构自 TLUSTY `odfhyd.f`
|
||
//!
|
||
//! 计算氢线系列的不透明度分布函数。
|
||
|
||
use crate::tlusty::math::divstr;
|
||
use crate::tlusty::math::indexx;
|
||
use crate::tlusty::math::odfhst;
|
||
use crate::tlusty::state::constants::{HALF, TWO, UN};
|
||
use crate::tlusty::state::model::StrAux;
|
||
|
||
// 物理常量
|
||
/// 玻尔兹曼常数 / 氢质量
|
||
const CDOP: f64 = 2.0 * 1.38054e-16 / 1.6726e-24;
|
||
/// 光速 (Angstrom/s)
|
||
const CA: f64 = 2.997925e18;
|
||
/// 转换因子
|
||
const CCM: f64 = CA / 1.0e8;
|
||
/// 氢的 Rydberg 频率
|
||
const FRH: f64 = 3.28805e15;
|
||
/// Rydberg 波长 (Angstrom)
|
||
const RYDEL: f64 = 911.764;
|
||
/// 2/3
|
||
const TTW: f64 = 2.0 / 3.0;
|
||
/// Stark 加宽常量
|
||
const C00: f64 = 1.25e-9;
|
||
/// 仪器加宽常量
|
||
const CID: f64 = 0.02654;
|
||
|
||
/// ODFHYD 输入参数
|
||
pub struct OdfhydParams {
|
||
/// 深度索引 (1-indexed)
|
||
pub id: usize,
|
||
/// 跃迁索引 (1-indexed)
|
||
pub itr: usize,
|
||
}
|
||
|
||
/// ODFHYD 配置参数
|
||
pub struct OdfhydConfig {
|
||
/// ODF 采样标志 (0: 标准 ODF, >0: 采样 ODF)
|
||
pub ispodf: i32,
|
||
/// 最大谱线数
|
||
pub nlmx: usize,
|
||
/// 光速 (Angstrom/s)
|
||
pub cas: f64,
|
||
/// 湍流速度 (cm/s)
|
||
pub vtb: f64,
|
||
}
|
||
|
||
/// ODFHYD 原子数据
|
||
pub struct OdfhydAtomicData<'a> {
|
||
/// 下能级索引 (ntrans)
|
||
pub ilow: &'a [i32],
|
||
/// 上能级索引 (ntrans)
|
||
pub iup: &'a [i32],
|
||
/// 主量子数 (nlevel)
|
||
pub nquant: &'a [i32],
|
||
/// ODF 的下量子数 (nlevel)
|
||
pub nqlodf: &'a [i32],
|
||
/// 跃迁起始频率索引 (ntrans)
|
||
pub ifr0: &'a [i32],
|
||
/// 跃迁结束频率索引 (ntrans)
|
||
pub ifr1: &'a [i32],
|
||
/// XKIJ 系数 (ntrans × nlmx)
|
||
pub xkij: &'a [f64],
|
||
/// FIJ 系数 (ntrans × nlmx)
|
||
pub fij: &'a [f64],
|
||
/// ODF 索引 (ntrans)
|
||
pub jndodf: &'a [i32],
|
||
}
|
||
|
||
/// ODFHYD 模型状态
|
||
pub struct OdfhydModelState<'a> {
|
||
/// 温度 (nd)
|
||
pub temp: &'a [f64],
|
||
/// 电子密度 (nd)
|
||
pub elec: &'a [f64],
|
||
/// WNHINT 数组 (nlmx × nd)
|
||
pub wnhint: &'a [f64],
|
||
/// Stark 展宽参数
|
||
pub straux: StrAux,
|
||
}
|
||
|
||
/// ODFHYD ODF 数据
|
||
pub struct OdfhydOdfData<'a> {
|
||
/// ODF 频率数 (ntrans)
|
||
pub nfrodf: &'a [i32],
|
||
/// ODF 频率 (mfro × ntrans)
|
||
pub fros: &'a [f64],
|
||
/// ODF 频率宽度 (mfro × ntrans)
|
||
pub wnus: &'a [f64],
|
||
/// 谱线轮廓 (nd × nfreq 或其他)
|
||
pub prflin: &'a mut [f64],
|
||
/// 频率数组 (nfreq)
|
||
pub freq: &'a [f64],
|
||
/// KFR0 索引 (ntrans)
|
||
pub kfr0: &'a [i32],
|
||
/// INDEXP 标志 (ntrans)
|
||
pub indexp: &'a [i32],
|
||
}
|
||
|
||
/// XI2 函数：计算 1/n^2
|
||
fn xi2(n: i32) -> f64 {
|
||
1.0 / (n as f64 * n as f64)
|
||
}
|
||
|
||
/// 计算氢线系列的 ODF。
|
||
///
|
||
/// # 参数
|
||
///
|
||
/// * `params` - 输入参数（id, itr）
|
||
/// * `config` - 配置参数
|
||
/// * `atomic` - 原子数据
|
||
/// * `model` - 模型状态
|
||
/// * `odf_data` - ODF 数据
|
||
///
|
||
/// # 返回值
|
||
///
|
||
/// 更新后的 PRFLIN 数组
|
||
pub fn odfhyd(
|
||
params: &OdfhydParams,
|
||
config: &OdfhydConfig,
|
||
atomic: &OdfhydAtomicData,
|
||
model: &mut OdfhydModelState,
|
||
odf_data: &mut OdfhydOdfData,
|
||
) {
|
||
let id = params.id;
|
||
let id_idx = id - 1;
|
||
let itr = params.itr;
|
||
let itr_idx = itr - 1;
|
||
|
||
let jo = atomic.jndodf[itr_idx] as usize - 1;
|
||
let ispodf = config.ispodf;
|
||
|
||
// 确定频率点数和初始化数组
|
||
let nf = if ispodf == 0 {
|
||
odf_data.nfrodf[jo] as usize
|
||
} else {
|
||
(atomic.ifr1[itr_idx] - atomic.ifr0[itr_idx] + 1) as usize
|
||
};
|
||
|
||
let mut sig = vec![0.0; nf];
|
||
let mut sgt = vec![0.0; nf];
|
||
let mut odf = vec![0.0; nf];
|
||
let mut iodf = vec![0; nf];
|
||
let mut ynus = vec![0.0; nf];
|
||
let mut alam = vec![0.0; nf];
|
||
|
||
// 初始化频率和波长
|
||
if ispodf == 0 {
|
||
for ij in 0..nf {
|
||
iodf[ij] = 0;
|
||
sig[ij] = 0.0;
|
||
odf[ij] = 0.0;
|
||
ynus[ij] = odf_data.fros[ij + jo * 1000]; // 假设 MFRO = 1000
|
||
alam[ij] = config.cas / ynus[ij];
|
||
}
|
||
} else {
|
||
let ifr0 = atomic.ifr0[itr_idx] as usize - 1;
|
||
for ij in 0..nf {
|
||
sig[ij] = 0.0;
|
||
ynus[ij] = odf_data.freq[ifr0 + ij];
|
||
alam[ij] = config.cas / ynus[ij];
|
||
}
|
||
}
|
||
|
||
// 获取能级索引
|
||
let ii = atomic.ilow[itr_idx] as usize - 1;
|
||
let jj = atomic.iup[itr_idx] as usize - 1;
|
||
|
||
// 计算电子密度因子
|
||
let anes = (TTW * model.elec[id_idx].ln()).exp();
|
||
let f00 = C00 * anes;
|
||
|
||
// 计算跃迁频率
|
||
let nquant_ii = atomic.nquant[ii];
|
||
let nquant_jj = atomic.nquant[jj];
|
||
let fra = FRH * (xi2(nquant_ii) - xi2(nquant_jj));
|
||
|
||
// 计算 Doppler 宽度
|
||
let dopo = fra / CCM * (CDOP * model.temp[id_idx] + config.vtb * config.vtb).sqrt();
|
||
|
||
// 遍历谱线系列
|
||
let nqlodf_ii = atomic.nqlodf[ii] as usize;
|
||
for j in nqlodf_ii..=config.nlmx {
|
||
let wl = RYDEL / (xi2(nquant_ii) - xi2(j as i32));
|
||
let fxk = f00 * atomic.xkij[jo * config.nlmx + j];
|
||
let dbeta = wl * wl / CA / fxk;
|
||
let betad = dbeta * dopo;
|
||
let fid = CID * atomic.fij[jo * config.nlmx + j] * dbeta;
|
||
|
||
// 调用 DIVSTR
|
||
let (adh, divh) = divstr(betad, 1);
|
||
|
||
// 获取 Stark 宽度
|
||
let wprob = model.wnhint[j * id + id_idx];
|
||
|
||
// 更新 straux 中的参数
|
||
model.straux.betad = betad;
|
||
model.straux.adh = adh;
|
||
model.straux.divh = divh;
|
||
|
||
// 调用 ODFHST
|
||
odfhst(nf, fxk, fid, wprob, wl, &alam, &model.straux, &mut sgt);
|
||
|
||
// 累加截面
|
||
for ij in 0..nf {
|
||
sig[ij] += sgt[ij];
|
||
}
|
||
}
|
||
|
||
// 后处理（仅对标准 ODF）
|
||
if ispodf == 0 {
|
||
// 排序
|
||
iodf = indexx(&sig);
|
||
|
||
// 重新排列 ODF
|
||
for ij in 0..nf {
|
||
odf[ij] = sig[iodf[ij]];
|
||
}
|
||
|
||
// 计算频率网格
|
||
let i0 = atomic.ifr0[itr_idx] as usize;
|
||
let i1 = atomic.ifr1[itr_idx] as usize;
|
||
|
||
if odf_data.indexp[itr_idx].abs() == 2 {
|
||
ynus[0] = odf_data.freq[i0 - 1];
|
||
}
|
||
|
||
let mut iw1 = iodf[0];
|
||
for ij in 1..nf {
|
||
let iw2 = iodf[ij];
|
||
if ij > 1 && ij < nf - 1 {
|
||
ynus[ij] = ynus[ij - 1]
|
||
- HALF * (odf_data.wnus[iw1 + jo * 1000] + odf_data.wnus[iw2 + jo * 1000]);
|
||
} else if ij == 1 {
|
||
ynus[ij] = ynus[ij - 1]
|
||
- HALF * (TWO * odf_data.wnus[iw1 + jo * 1000] + odf_data.wnus[iw2 + jo * 1000]);
|
||
} else if ij == nf - 1 {
|
||
ynus[ij] = ynus[ij - 1]
|
||
- HALF * (odf_data.wnus[iw1 + jo * 1000] + TWO * odf_data.wnus[iw2 + jo * 1000]);
|
||
}
|
||
iw1 = iw2;
|
||
}
|
||
|
||
// 插值到频率网格
|
||
odf_data.prflin[id_idx * 100000 + i1 - 1] = 1e-35;
|
||
|
||
for ij0 in i0..i1 {
|
||
let mut ji = 1;
|
||
for ij in 1..nf {
|
||
ji = ij;
|
||
if ynus[ij] <= odf_data.freq[ij0 - 1] {
|
||
break;
|
||
}
|
||
}
|
||
|
||
let prfln = if ji > 0 && ji < nf {
|
||
odf[ji - 1]
|
||
+ (odf[ji] - odf[ji - 1]) * (odf_data.freq[ij0 - 1] - ynus[ji - 1])
|
||
/ (ynus[ji] - ynus[ji - 1])
|
||
} else {
|
||
0.0
|
||
};
|
||
|
||
odf_data.prflin[id_idx * 100000 + ij0 - 1] = prfln;
|
||
}
|
||
} else {
|
||
// 采样 ODF 情况
|
||
let kfr0 = odf_data.kfr0[itr_idx] as usize;
|
||
for ij in 0..nf {
|
||
odf_data.prflin[id_idx * 100000 + kfr0 + ij - 1] = sig[ij];
|
||
}
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
|
||
#[test]
|
||
fn test_xi2() {
|
||
assert!((xi2(1) - 1.0).abs() < 1e-15);
|
||
assert!((xi2(2) - 0.25).abs() < 1e-15);
|
||
assert!((xi2(3) - 1.0 / 9.0).abs() < 1e-15);
|
||
}
|
||
|
||
#[test]
|
||
fn test_odfhyd_constants() {
|
||
// CDOP = 2 * BOLK / HMASS = 2 * 1.38054e-16 / 1.6726e-24 ≈ 1.65e8
|
||
// 注意：Fortran 中的 BOLK 可能是 1.38054e-16，HMASS 是 1.6726e-24
|
||
// CDOP ≈ 1.65e8 cm/s/K^0.5
|
||
assert!(CDOP > 1e7 && CDOP < 1e9);
|
||
assert!((CA - 2.997925e18).abs() < 1e13);
|
||
assert!((FRH - 3.28805e15).abs() < 1e10);
|
||
}
|
||
}
|