498 lines
14 KiB
Rust
498 lines
14 KiB
Rust
//! 准分子不透明度计算（Lyman alpha, beta, gamma 和 Balmer alpha）。
|
||
//!
|
||
//! 重构自 TLUSTY `allard.f`
|
||
//!
|
||
//! 计算氢线的准分子不透明度轮廓，基于 Allard 等人的数据表。
|
||
|
||
use crate::tlusty::state::model::{CalphatD, CallardA, CallardB, CallardC, CallardG, ModelState};
|
||
|
||
// 归一化常数
|
||
// 8.8528e-29 * lambda_0^2 * f_ij
|
||
const XNORMA: f64 = 8.8528e-29 * 1215.6 * 1215.6 * 0.41618; // Lyman alpha
|
||
const XNORMB: f64 = 8.8528e-29 * 1025.73 * 1025.7 * 0.0791; // Lyman beta
|
||
const XNORMG: f64 = 8.8528e-29 * 972.53 * 972.53 * 0.0290; // Lyman gamma
|
||
const XNORMC: f64 = 8.8528e-29 * 6562.0 * 6562.0 * 0.6407; // Balmer alpha
|
||
|
||
/// 准分子不透明度线轮廓计算。
|
||
///
|
||
/// 计算 Lyman alpha, beta, gamma 和 Balmer alpha 线的准分子轮廓。
|
||
///
|
||
/// # 参数
|
||
///
|
||
/// * `xl` - 波长 (Å)
|
||
/// * `t` - 温度 (K)
|
||
/// * `hneutr` - 中性氢粒子密度 (cm⁻³)
|
||
/// * `hcharg` - 电离氢粒子密度 (cm⁻³)
|
||
/// * `iq` - 下能级量子数
|
||
/// * `jq` - 上能级量子数
|
||
/// - iq=1, jq=2: Lyman alpha
|
||
/// - iq=1, jq=3: Lyman beta
|
||
/// - iq=1, jq=4: Lyman gamma
|
||
/// - iq=2, jq=3: Balmer alpha
|
||
/// * `model` - 模型状态（包含 Allard 数据表）
|
||
///
|
||
/// # 返回值
|
||
///
|
||
/// 返回归一化的线轮廓值。如果波长超出范围或其他条件不满足，返回 0.0。
|
||
pub fn allard(
|
||
xl: f64,
|
||
t: f64,
|
||
hneutr: f64,
|
||
hcharg: f64,
|
||
iq: i32,
|
||
jq: i32,
|
||
model: &ModelState,
|
||
) -> f64 {
|
||
let mut prof = 0.0;
|
||
|
||
// Lyman alpha
|
||
if iq == 1 && jq == 2 {
|
||
if model.quasun.nunalp < 0 {
|
||
// 使用温度相关计算
|
||
return allardt_temp(xl, t, hneutr, hcharg, &model.calphatd);
|
||
} else {
|
||
prof = lyman_alpha(xl, hneutr, hcharg, &model.callarda);
|
||
}
|
||
}
|
||
// Lyman beta
|
||
else if iq == 1 && jq == 3 {
|
||
if model.callardb.nxbet == 0 {
|
||
return 0.0;
|
||
}
|
||
prof = lyman_beta(xl, hneutr, hcharg, &model.callardb);
|
||
}
|
||
// Lyman gamma
|
||
else if iq == 1 && jq == 4 {
|
||
if model.callardg.nxgam == 0 {
|
||
return 0.0;
|
||
}
|
||
prof = lyman_gamma(xl, hneutr, hcharg, &model.callardg);
|
||
}
|
||
// Balmer alpha
|
||
else if iq == 2 && jq == 3 {
|
||
prof = balmer_alpha(xl, hcharg, &model.callardc);
|
||
}
|
||
|
||
prof
|
||
}
|
||
|
||
/// Lyman alpha 线轮廓计算。
|
||
fn lyman_alpha(xl: f64, hneutr: f64, hcharg: f64, data: &CallardA) -> f64 {
|
||
let nxalp = data.nxalp as usize;
|
||
|
||
// 检查波长范围
|
||
if xl < data.xlalp[0] || xl > data.xlalp[nxalp - 1] {
|
||
return 0.0;
|
||
}
|
||
|
||
// 计算归一化密度
|
||
let vn1 = hneutr / data.stnnea;
|
||
let vn2 = hcharg / data.stncha;
|
||
let vns = vn1 * data.vneua + vn2 * data.vchaa;
|
||
|
||
// 检查密度是否过高（只警告一次）
|
||
// 注意：原始 Fortran 代码有警告输出，这里保留标志检查但不输出
|
||
// if data.iwarna == 0 && (vn1 * data.vneua > 0.3 || vn2 * data.vchaa > 0.3) {
|
||
// // 可以在这里添加警告逻辑
|
||
// }
|
||
|
||
let vn11 = vn1 * vn1;
|
||
let vn22 = vn2 * vn2;
|
||
let vn12 = vn1 * vn2;
|
||
let xnorm = 1.0 / (1.0 + vns + 0.5 * vns * vns);
|
||
|
||
// 二分查找波长索引
|
||
let j = binary_search(xl, &data.xlalp, nxalp);
|
||
|
||
// 线性插值
|
||
let a1 = (xl - data.xlalp[j - 1]) / (data.xlalp[j] - data.xlalp[j - 1]);
|
||
|
||
let p1 = vn1 * ((1.0 - a1) * data.plalp[j - 1][0] + a1 * data.plalp[j][0]);
|
||
let p11 = vn11 * ((1.0 - a1) * data.plalp[j - 1][1] + a1 * data.plalp[j][1]);
|
||
let p2 = vn2 * ((1.0 - a1) * data.plalp[j - 1][2] + a1 * data.plalp[j][2]);
|
||
let p22 = vn22 * ((1.0 - a1) * data.plalp[j - 1][3] + a1 * data.plalp[j][3]);
|
||
let p12 = vn12 * ((1.0 - a1) * data.plalp[j - 1][4] + a1 * data.plalp[j][4]);
|
||
|
||
(p1 + p2 + p11 + p22 + p12) * xnorm * XNORMA
|
||
}
|
||
|
||
/// Lyman beta 线轮廓计算。
|
||
fn lyman_beta(xl: f64, hneutr: f64, hcharg: f64, data: &CallardB) -> f64 {
|
||
let nxbet = data.nxbet as usize;
|
||
|
||
// 检查波长范围
|
||
if xl < data.xlbet[0] || xl > data.xlbet[nxbet - 1] {
|
||
return 0.0;
|
||
}
|
||
|
||
// 计算归一化密度
|
||
let vn1 = hneutr / data.stnneb;
|
||
let vn2 = hcharg / data.stnchb;
|
||
let vns = vn1 * data.vneub + vn2 * data.vchab;
|
||
|
||
let vn11 = vn1 * vn1;
|
||
let vn22 = vn2 * vn2;
|
||
let vn12 = vn1 * vn2;
|
||
let xnorm = 1.0 / (1.0 + vns + 0.5 * vns * vns);
|
||
|
||
// 二分查找波长索引
|
||
let j = binary_search(xl, &data.xlbet, nxbet);
|
||
|
||
// 线性插值
|
||
let a1 = (xl - data.xlbet[j - 1]) / (data.xlbet[j] - data.xlbet[j - 1]);
|
||
|
||
let p1 = vn1 * ((1.0 - a1) * data.plbet[j - 1][0] + a1 * data.plbet[j][0]);
|
||
let p11 = vn11 * ((1.0 - a1) * data.plbet[j - 1][1] + a1 * data.plbet[j][1]);
|
||
let p2 = vn2 * ((1.0 - a1) * data.plbet[j - 1][2] + a1 * data.plbet[j][2]);
|
||
let p22 = vn22 * ((1.0 - a1) * data.plbet[j - 1][3] + a1 * data.plbet[j][3]);
|
||
let p12 = vn12 * ((1.0 - a1) * data.plbet[j - 1][4] + a1 * data.plbet[j][4]);
|
||
|
||
(p1 + p2 + p11 + p22 + p12) * xnorm * XNORMB
|
||
}
|
||
|
||
/// Lyman gamma 线轮廓计算。
|
||
fn lyman_gamma(xl: f64, hneutr: f64, hcharg: f64, data: &CallardG) -> f64 {
|
||
let nxgam = data.nxgam as usize;
|
||
|
||
// 检查波长范围
|
||
if xl < data.xlgam[0] || xl > data.xlgam[nxgam - 1] {
|
||
return 0.0;
|
||
}
|
||
|
||
// 计算归一化密度
|
||
let vn1 = hneutr / data.stnneg;
|
||
let vn2 = hcharg / data.stnchg;
|
||
let vns = vn1 * data.vneug + vn2 * data.vchag;
|
||
|
||
let vn11 = vn1 * vn1;
|
||
let vn22 = vn2 * vn2;
|
||
let vn12 = vn1 * vn2;
|
||
let xnorm = 1.0 / (1.0 + vns + 0.5 * vns * vns);
|
||
|
||
// 二分查找波长索引
|
||
let j = binary_search(xl, &data.xlgam, nxgam);
|
||
|
||
// 线性插值
|
||
let a1 = (xl - data.xlgam[j - 1]) / (data.xlgam[j] - data.xlgam[j - 1]);
|
||
|
||
let p1 = vn1 * ((1.0 - a1) * data.plgam[j - 1][0] + a1 * data.plgam[j][0]);
|
||
let p11 = vn11 * ((1.0 - a1) * data.plgam[j - 1][1] + a1 * data.plgam[j][1]);
|
||
let p2 = vn2 * ((1.0 - a1) * data.plgam[j - 1][2] + a1 * data.plgam[j][2]);
|
||
let p22 = vn22 * ((1.0 - a1) * data.plgam[j - 1][3] + a1 * data.plgam[j][3]);
|
||
let p12 = vn12 * ((1.0 - a1) * data.plgam[j - 1][4] + a1 * data.plgam[j][4]);
|
||
|
||
(p1 + p2 + p11 + p22 + p12) * xnorm * XNORMG
|
||
}
|
||
|
||
/// Balmer alpha 线轮廓计算。
|
||
fn balmer_alpha(xl: f64, hcharg: f64, data: &CallardC) -> f64 {
|
||
let nxbal = data.nxbal as usize;
|
||
|
||
// 检查波长范围
|
||
if xl < data.xlbal[0] || xl > data.xlbal[nxbal - 1] {
|
||
return 0.0;
|
||
}
|
||
|
||
// Balmer alpha 只考虑电离氢
|
||
let vn1 = 0.0;
|
||
let vn2 = hcharg / data.stnchc;
|
||
let vns = vn1 * data.vneuc + vn2 * data.vchac;
|
||
|
||
let vn11 = vn1 * vn1;
|
||
let vn22 = vn2 * vn2;
|
||
let vn12 = vn1 * vn2;
|
||
let xnorm = 1.0 / (1.0 + vns + 0.5 * vns * vns);
|
||
|
||
// 二分查找波长索引
|
||
let j = binary_search(xl, &data.xlbal, nxbal);
|
||
|
||
// 线性插值
|
||
let a1 = (xl - data.xlbal[j - 1]) / (data.xlbal[j] - data.xlbal[j - 1]);
|
||
|
||
let p1 = vn1 * ((1.0 - a1) * data.plbal[j - 1][0] + a1 * data.plbal[j][0]);
|
||
let p11 = vn11 * ((1.0 - a1) * data.plbal[j - 1][1] + a1 * data.plbal[j][1]);
|
||
let p2 = vn2 * ((1.0 - a1) * data.plbal[j - 1][2] + a1 * data.plbal[j][2]);
|
||
let p22 = vn22 * ((1.0 - a1) * data.plbal[j - 1][3] + a1 * data.plbal[j][3]);
|
||
let p12 = vn12 * ((1.0 - a1) * data.plbal[j - 1][4] + a1 * data.plbal[j][4]);
|
||
|
||
(p1 + p2 + p11 + p22 + p12) * xnorm * XNORMC
|
||
}
|
||
|
||
/// 温度相关的 Lyman alpha 线轮廓计算。
|
||
///
|
||
/// 当 nunalp < 0 时使用此函数。
|
||
fn allardt_temp(xl: f64, t: f64, hneutr: f64, hcharg: f64, data: &CalphatD) -> f64 {
|
||
let ntalpd = data.ntalpd as usize;
|
||
|
||
// 找到接近实际温度的两个部分表
|
||
let mut it0 = 0usize;
|
||
for it in 1..=ntalpd {
|
||
it0 = it;
|
||
if t < data.talpd[it - 1] {
|
||
it0 = it - 1;
|
||
break;
|
||
}
|
||
}
|
||
|
||
// 处理边界情况
|
||
if it0 == 0 {
|
||
it0 = 1;
|
||
return compute_single_table_temp(xl, hneutr, hcharg, it0 - 1, data);
|
||
}
|
||
if it0 >= ntalpd {
|
||
it0 = ntalpd;
|
||
return compute_single_table_temp(xl, hneutr, hcharg, it0 - 1, data);
|
||
}
|
||
|
||
// 在不同温度的表之间进行插值
|
||
let prof0 = compute_single_table_temp(xl, hneutr, hcharg, it0 - 1, data);
|
||
if prof0 == 0.0 {
|
||
return 0.0;
|
||
}
|
||
|
||
let prof1 = compute_single_table_temp(xl, hneutr, hcharg, it0, data);
|
||
if prof1 == 0.0 {
|
||
return 0.0;
|
||
}
|
||
|
||
// 温度插值
|
||
let dt = data.talpd[it0] - data.talpd[it0 - 1];
|
||
if dt.abs() < 1e-10 {
|
||
prof0
|
||
} else {
|
||
(prof0 * (data.talpd[it0] - t) + prof1 * (t - data.talpd[it0 - 1])) / dt
|
||
}
|
||
}
|
||
|
||
/// 计算单个温度表的轮廓值（温度相关版本）。
|
||
fn compute_single_table_temp(
|
||
xl: f64,
|
||
hneutr: f64,
|
||
hcharg: f64,
|
||
it_idx: usize,
|
||
data: &CalphatD,
|
||
) -> f64 {
|
||
let nx = data.nxalpd[it_idx] as usize;
|
||
if nx == 0 {
|
||
return 0.0;
|
||
}
|
||
|
||
// 检查波长是否在范围内
|
||
if xl < data.xlalpd[0][it_idx] || xl > data.xlalpd[nx - 1][it_idx] {
|
||
return 0.0;
|
||
}
|
||
|
||
// 计算归一化密度
|
||
let vn1 = hneutr / data.stnead[it_idx];
|
||
let vn2 = hcharg / data.stnchd[it_idx];
|
||
let vns = vn1 * data.vneuad[it_idx] + vn2 * data.vchaad[it_idx];
|
||
let vn11 = vn1 * vn1;
|
||
let vn22 = vn2 * vn2;
|
||
let vn12 = vn1 * vn2;
|
||
let xnorm = 1.0 / (1.0 + vns + 0.5 * vns * vns);
|
||
|
||
// 二分查找波长索引
|
||
let mut jl = 0usize;
|
||
let mut ju = nx + 1;
|
||
while ju - jl > 1 {
|
||
let jm = (ju + jl) / 2;
|
||
if xl > data.xlalpd[jm - 1][it_idx] {
|
||
jl = jm;
|
||
} else {
|
||
ju = jm;
|
||
}
|
||
}
|
||
let j = if jl == 0 { 1 } else if jl == nx { nx - 1 } else { jl };
|
||
|
||
// 线性插值
|
||
let a1 = (xl - data.xlalpd[j - 1][it_idx])
|
||
/ (data.xlalpd[j][it_idx] - data.xlalpd[j - 1][it_idx]);
|
||
|
||
let p1 = vn1 * ((1.0 - a1) * data.plalpd[j - 1][0][it_idx] + a1 * data.plalpd[j][0][it_idx]);
|
||
let p11 = vn11 * ((1.0 - a1) * data.plalpd[j - 1][1][it_idx] + a1 * data.plalpd[j][1][it_idx]);
|
||
let p2 = vn2 * ((1.0 - a1) * data.plalpd[j - 1][2][it_idx] + a1 * data.plalpd[j][2][it_idx]);
|
||
let p22 = vn22 * ((1.0 - a1) * data.plalpd[j - 1][3][it_idx] + a1 * data.plalpd[j][3][it_idx]);
|
||
let p12 = vn12 * ((1.0 - a1) * data.plalpd[j - 1][4][it_idx] + a1 * data.plalpd[j][4][it_idx]);
|
||
|
||
(p1 + p2 + p11 + p22 + p12) * xnorm * XNORMA
|
||
}
|
||
|
||
/// 二分查找波长索引。
|
||
///
|
||
/// 返回索引 j，使得 x[j-1] <= xl < x[j]。
|
||
/// Fortran 原始代码使用的是 1-indexed。
|
||
fn binary_search(xl: f64, x: &[f64], n: usize) -> usize {
|
||
let mut jl = 0usize;
|
||
let mut ju = n + 1;
|
||
|
||
// 判断数组是升序还是降序
|
||
let ascending = x[n - 1] > x[0];
|
||
|
||
while ju - jl > 1 {
|
||
let jm = (ju + jl) / 2;
|
||
if ascending == (xl > x[jm - 1]) {
|
||
jl = jm;
|
||
} else {
|
||
ju = jm;
|
||
}
|
||
}
|
||
|
||
// 边界检查
|
||
if jl == 0 {
|
||
1
|
||
} else if jl == n {
|
||
n - 1
|
||
} else {
|
||
jl
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
use approx::assert_relative_eq;
|
||
|
||
fn create_test_callard_a() -> CallardA {
|
||
let mut data = CallardA::default();
|
||
data.nxalp = 3;
|
||
data.xlalp[0] = 1210.0;
|
||
data.xlalp[1] = 1215.0;
|
||
data.xlalp[2] = 1220.0;
|
||
data.stnnea = 1e14;
|
||
data.stncha = 1e12;
|
||
data.vneua = 1.0;
|
||
data.vchaa = 1.0;
|
||
data.iwarna = 1; // 禁用警告
|
||
|
||
for i in 0..3 {
|
||
for j in 0..5 {
|
||
data.plalp[i][j] = 1e-20;
|
||
}
|
||
}
|
||
data
|
||
}
|
||
|
||
fn create_test_callard_b() -> CallardB {
|
||
let mut data = CallardB::default();
|
||
data.nxbet = 3;
|
||
data.xlbet[0] = 1020.0;
|
||
data.xlbet[1] = 1025.0;
|
||
data.xlbet[2] = 1030.0;
|
||
data.stnneb = 1e14;
|
||
data.stnchb = 1e12;
|
||
data.vneub = 1.0;
|
||
data.vchab = 1.0;
|
||
data.iwarnb = 1;
|
||
|
||
for i in 0..3 {
|
||
for j in 0..5 {
|
||
data.plbet[i][j] = 1e-20;
|
||
}
|
||
}
|
||
data
|
||
}
|
||
|
||
fn create_test_callard_g() -> CallardG {
|
||
let mut data = CallardG::default();
|
||
data.nxgam = 3;
|
||
data.xlgam[0] = 970.0;
|
||
data.xlgam[1] = 972.0;
|
||
data.xlgam[2] = 975.0;
|
||
data.stnneg = 1e14;
|
||
data.stnchg = 1e12;
|
||
data.vneug = 1.0;
|
||
data.vchag = 1.0;
|
||
data.iwarng = 1;
|
||
|
||
for i in 0..3 {
|
||
for j in 0..5 {
|
||
data.plgam[i][j] = 1e-20;
|
||
}
|
||
}
|
||
data
|
||
}
|
||
|
||
fn create_test_callard_c() -> CallardC {
|
||
let mut data = CallardC::default();
|
||
data.nxbal = 3;
|
||
data.xlbal[0] = 6550.0;
|
||
data.xlbal[1] = 6562.0;
|
||
data.xlbal[2] = 6580.0;
|
||
data.stnchc = 1e12;
|
||
data.vneuc = 1.0;
|
||
data.vchac = 1.0;
|
||
|
||
for i in 0..3 {
|
||
for j in 0..5 {
|
||
data.plbal[i][j] = 1e-20;
|
||
}
|
||
}
|
||
data
|
||
}
|
||
|
||
fn create_test_model() -> ModelState {
|
||
let mut model = ModelState::default();
|
||
model.callarda = create_test_callard_a();
|
||
model.callardb = create_test_callard_b();
|
||
model.callardg = create_test_callard_g();
|
||
model.callardc = create_test_callard_c();
|
||
model.quasun.nunalp = 0; // 使用非温度相关计算
|
||
model
|
||
}
|
||
|
||
#[test]
|
||
fn test_binary_search() {
|
||
let x = vec![1210.0, 1215.0, 1220.0];
|
||
|
||
// 升序数组
|
||
let j = binary_search(1212.0, &x, 3);
|
||
assert_eq!(j, 1);
|
||
|
||
let j = binary_search(1217.0, &x, 3);
|
||
assert_eq!(j, 2);
|
||
}
|
||
|
||
#[test]
|
||
fn test_allard_lyman_alpha_in_range() {
|
||
let model = create_test_model();
|
||
let prof = allard(1215.0, 10000.0, 1e14, 1e12, 1, 2, &model);
|
||
assert!(prof > 0.0);
|
||
}
|
||
|
||
#[test]
|
||
fn test_allard_lyman_alpha_out_of_range() {
|
||
let model = create_test_model();
|
||
let prof = allard(1000.0, 10000.0, 1e14, 1e12, 1, 2, &model);
|
||
assert_relative_eq!(prof, 0.0, epsilon = 1e-30);
|
||
}
|
||
|
||
#[test]
|
||
fn test_allard_lyman_beta_in_range() {
|
||
let model = create_test_model();
|
||
let prof = allard(1025.0, 10000.0, 1e14, 1e12, 1, 3, &model);
|
||
assert!(prof > 0.0);
|
||
}
|
||
|
||
#[test]
|
||
fn test_allard_lyman_gamma_in_range() {
|
||
let model = create_test_model();
|
||
let prof = allard(972.0, 10000.0, 1e14, 1e12, 1, 4, &model);
|
||
assert!(prof > 0.0);
|
||
}
|
||
|
||
#[test]
|
||
fn test_allard_balmer_alpha_in_range() {
|
||
let model = create_test_model();
|
||
let prof = allard(6562.0, 10000.0, 1e14, 1e12, 2, 3, &model);
|
||
assert!(prof >= 0.0); // Balmer alpha 只考虑电离氢
|
||
}
|
||
|
||
#[test]
|
||
fn test_allard_invalid_transition() {
|
||
let model = create_test_model();
|
||
// 无效的量子数组合
|
||
let prof = allard(6562.0, 10000.0, 1e14, 1e12, 3, 4, &model);
|
||
assert_relative_eq!(prof, 0.0, epsilon = 1e-30);
|
||
}
|
||
}
|