1054 lines
29 KiB
Rust
1054 lines
29 KiB
Rust
//! ALI 参数和辐射跃迁率计算 - 变体 2（用于速率矩阵对占据数的导数）。
|
||
//!
|
||
//! 重构自 TLUSTY `alist2.f`
|
||
//!
|
||
//! 计算所有必要的 ALI 参数和辐射跃迁率。
|
||
//! 这是 RATES1 的类似函数，用于速率矩阵对占据数的导数计算。
|
||
//!
|
||
//! ## IRDER 模式
|
||
//! - IRDER = 1: 计算 APT, APN (T 和 N 导数)
|
||
//! - IRDER = 2: 计算 APP (能级导数)
|
||
//! - IRDER = 3: 计算 APT, APN, APP (所有导数)
|
||
|
||
use crate::tlusty::state::constants::{MDEPTH, MFREQ, MLEVEL, MTRANS, MLVEXP, UN};
|
||
|
||
/// ALIST2 输入参数（只读）
|
||
pub struct Alist2Params<'a> {
|
||
// 维度参数
|
||
/// 深度点数
|
||
pub nd: usize,
|
||
/// 频率点数
|
||
pub nfreq: usize,
|
||
/// 能级数
|
||
pub nlevel: usize,
|
||
/// 离子数
|
||
pub nion: usize,
|
||
/// 束缚-自由跃迁数
|
||
pub ntranc: usize,
|
||
/// 束缚-束缚跃迁数
|
||
pub ntrans: usize,
|
||
/// 线性化能级数
|
||
pub nlvexp: usize,
|
||
|
||
// 控制参数
|
||
/// 辐射导数模式 (1, 2, 3)
|
||
pub irder: i32,
|
||
/// 迭代次数
|
||
pub iter: i32,
|
||
/// ODF/OS 选项
|
||
pub ispodf: i32,
|
||
/// 不透明度表选项
|
||
pub ioptab: i32,
|
||
/// 最终迭代标志
|
||
pub lfin: bool,
|
||
/// 混合长度参数
|
||
pub hmix0: f64,
|
||
/// 对流开关
|
||
pub crsw: &'a [f64],
|
||
|
||
// 频率相关
|
||
/// 频率数组 [nfreq]
|
||
pub freq: &'a [f64],
|
||
/// 频率权重 [nfreq]
|
||
pub w0e: &'a [f64],
|
||
/// 跳过标志 [nfreq]
|
||
pub ijx: &'a [i32],
|
||
/// ALI 索引 [nfreq]
|
||
pub ijali: &'a [i32],
|
||
/// 普朗克函数 [nfreq]
|
||
pub bnue: &'a [f64],
|
||
|
||
// 模型状态
|
||
/// 温度 [nd]
|
||
pub temp: &'a [f64],
|
||
/// 电子密度 [nd]
|
||
pub elec: &'a [f64],
|
||
/// 总粒子密度 [nd]
|
||
pub dens: &'a [f64],
|
||
/// 1/密度 [nd]
|
||
pub dens1: &'a [f64],
|
||
/// 柱质量 [nd]
|
||
pub dm: &'a [f64],
|
||
/// 深度差分 [nd-1]
|
||
pub deldmz: &'a [f64],
|
||
/// h/kT [nd]
|
||
pub hkt1: &'a [f64],
|
||
/// h/(kT)² [nd]
|
||
pub hkt21: &'a [f64],
|
||
|
||
// 原子/能级数据
|
||
/// 元素索引 [nlevel]
|
||
pub iel: &'a [i32],
|
||
/// 原子索引 [nlevel]
|
||
pub iatm: &'a [i32],
|
||
/// 能级类型 [nlevel]
|
||
pub ilk: &'a [i32],
|
||
/// 模型能级 [nlevel]
|
||
pub imodl: &'a [i32],
|
||
/// LTE 能级标志 [nlevel]
|
||
pub iltlev: &'a [i32],
|
||
/// 显式能级索引 [nlevel]
|
||
pub iiexp: &'a [i32],
|
||
/// 固定原子标志 [nlevel]
|
||
pub iifix: &'a [i32],
|
||
/// 零占据数标志 [nlevel × nd]
|
||
pub ipzero: &'a [i32],
|
||
/// 参考原子 [nd × natom]
|
||
pub nrefs: &'a [i32],
|
||
|
||
// 跃迁数据
|
||
/// 束缚-自由跃迁索引 [ntranc]
|
||
pub itrbf: &'a [i32],
|
||
/// 跃迁下能级 [ntrans]
|
||
pub ilow: &'a [i32],
|
||
/// 跃迁上能级 [ntrans]
|
||
pub iup: &'a [i32],
|
||
/// 跃迁阈值频率 [ntrans]
|
||
pub fr0: &'a [i32],
|
||
/// 跃迁频率范围起点 [ntrans]
|
||
pub ifr0: &'a [i32],
|
||
/// 跃迁频率范围终点 [ntrans]
|
||
pub ifr1: &'a [i32],
|
||
/// 跃迁频率偏移 [ntrans]
|
||
pub kfr0: &'a [i32],
|
||
/// 跃迁索引类型 [ntrans]
|
||
pub indexp: &'a [i32],
|
||
/// 截面 [ntranc × nfreq]
|
||
pub cross: &'a [f64],
|
||
/// 跃迁吸收 [ntrans × nd]
|
||
pub abtra: &'a [f64],
|
||
/// 跃迁发射 [ntrans × nd]
|
||
pub emtra: &'a [f64],
|
||
/// Van der Waals 宽化因子索引 [ntrans]
|
||
pub mcdw: &'a [i32],
|
||
/// Van der Waals 宽化因子 [nion × nd]
|
||
pub dwf1: &'a [f64],
|
||
/// 合并截面 [nion × nd]
|
||
pub sgmg: &'a [f64],
|
||
/// 能级合并索引 [nlevel]
|
||
pub imrg: &'a [i32],
|
||
/// 线显式标志 [ntrans]
|
||
pub linexp: &'a [bool],
|
||
|
||
// 线数据
|
||
/// 频率对应的主线索引 [nfreq]
|
||
pub ijlin: &'a [i32],
|
||
/// 频率对应的重叠线数 [nfreq]
|
||
pub nlines: &'a [i32],
|
||
/// 重叠线索引 [nfreq × nlines_max]
|
||
pub itrlin: &'a [i32],
|
||
/// 线轮廓 [nd × nfreq]
|
||
pub prflin: &'a [f64],
|
||
|
||
// 辐射场
|
||
/// 辐射强度 [nd]
|
||
pub rad1: &'a [f64],
|
||
/// Eddington 因子 [nd]
|
||
pub fak1: &'a [f64],
|
||
|
||
// ALI 导数
|
||
/// 源函数 T 导数 [nd]
|
||
pub dsfdt: &'a [f64],
|
||
/// 源函数 N 导数 [nd]
|
||
pub dsfdn: &'a [f64],
|
||
/// 源函数能级导数 [nlvexp × nd]
|
||
pub dsfdp: &'a [f64],
|
||
|
||
// ODF/OS 特定
|
||
/// J 迭代索引 [nd]
|
||
pub jidi: &'a [i32],
|
||
/// XJ 迭代 [nd]
|
||
pub xjid: &'a [f64],
|
||
/// Fe 线截面 [njd × nkj]
|
||
pub sigfe: &'a [f64],
|
||
|
||
// 对流相关
|
||
/// 对流能量 [nd]
|
||
pub reint: &'a [f64],
|
||
/// 辐射扩散 [nd]
|
||
pub redif: &'a [f64],
|
||
/// 质量权重 [nd]
|
||
pub wmm: &'a [f64],
|
||
}
|
||
|
||
/// ALIST2 可变状态
|
||
pub struct Alist2State<'a> {
|
||
// 速率数组 [ntrans × nd]
|
||
/// 向上跃迁率
|
||
pub rru: &'a mut [f64],
|
||
/// 向下跃迁率
|
||
pub rrd: &'a mut [f64],
|
||
/// 速率温度导数
|
||
pub drdt: &'a mut [f64],
|
||
|
||
// ALI 参数 [nd]
|
||
pub reit: &'a mut [f64],
|
||
pub rein: &'a mut [f64],
|
||
pub reix: &'a mut [f64],
|
||
pub areit: &'a mut [f64],
|
||
pub arein: &'a mut [f64],
|
||
pub creit: &'a mut [f64],
|
||
pub crein: &'a mut [f64],
|
||
pub creix: &'a mut [f64],
|
||
pub redt: &'a mut [f64],
|
||
pub redtm: &'a mut [f64],
|
||
pub redtp: &'a mut [f64],
|
||
pub redn: &'a mut [f64],
|
||
pub rednm: &'a mut [f64],
|
||
pub rednp: &'a mut [f64],
|
||
pub redx: &'a mut [f64],
|
||
pub redxm: &'a mut [f64],
|
||
pub redxp: &'a mut [f64],
|
||
pub heit: &'a mut [f64],
|
||
pub heitm: &'a mut [f64],
|
||
pub heitp: &'a mut [f64],
|
||
pub hein: &'a mut [f64],
|
||
pub heinm: &'a mut [f64],
|
||
pub heinp: &'a mut [f64],
|
||
pub ehet: &'a mut [f64],
|
||
pub ehen: &'a mut [f64],
|
||
pub eret: &'a mut [f64],
|
||
pub eren: &'a mut [f64],
|
||
pub fcooli: &'a mut [f64],
|
||
pub flfix: &'a mut [f64],
|
||
pub flexp: &'a mut [f64],
|
||
pub flrd: &'a mut [f64],
|
||
pub fprd: &'a mut [f64],
|
||
pub pradt: &'a mut [f64],
|
||
pub prada: &'a mut [f64],
|
||
|
||
// 能级导数 [nlvexp × nd]
|
||
pub heip: &'a mut [f64],
|
||
pub reip: &'a mut [f64],
|
||
pub areip: &'a mut [f64],
|
||
pub creip: &'a mut [f64],
|
||
pub redp: &'a mut [f64],
|
||
pub redpm: &'a mut [f64],
|
||
pub heipm: &'a mut [f64],
|
||
pub redpp: &'a mut [f64],
|
||
pub heipp: &'a mut [f64],
|
||
|
||
// AP 矩阵 [nlvexp × nd]
|
||
pub apt: &'a mut [f64],
|
||
pub apn: &'a mut [f64],
|
||
|
||
// APP 矩阵 [nlvexp × nlvexp × nd]
|
||
pub app: &'a mut [f64],
|
||
|
||
// Rosseland 相关 [nd]
|
||
pub abrosd: &'a mut [f64],
|
||
pub sumdpl: &'a mut [f64],
|
||
|
||
// 辐射压力表面值
|
||
pub prd0: &'a mut f64,
|
||
}
|
||
|
||
/// ALIST2 输出结果
|
||
pub struct Alist2Output {
|
||
/// 辐射压力最小比值
|
||
pub prdx: f64,
|
||
}
|
||
|
||
/// 常量
|
||
const PCK: f64 = 1.5e-4; // h/c 常数因子
|
||
|
||
/// 执行 ALIST2 计算。
|
||
///
|
||
/// # 参数
|
||
/// - `params`: 输入参数
|
||
/// - `state`: 可变状态
|
||
///
|
||
/// # 返回
|
||
/// 计算结果
|
||
pub fn alist2(params: &Alist2Params, state: &mut Alist2State) -> Alist2Output {
|
||
let nd = params.nd;
|
||
let nfreq = params.nfreq;
|
||
let ntranc = params.ntranc;
|
||
let ntrans = params.ntrans;
|
||
let nlvexp = params.nlvexp;
|
||
|
||
// 零初始化所有速率和其他量
|
||
zero_rates(state, nd, ntrans, nlvexp);
|
||
|
||
// 计算 dedm1
|
||
let dedm1 = params.dm[0] / params.dens[0];
|
||
|
||
let mut prdx = 1.0;
|
||
|
||
match params.irder {
|
||
1 => {
|
||
// IRDER = 1: 只计算 APT, APN
|
||
process_irder1(params, state, nd, nfreq, ntranc, nlvexp);
|
||
}
|
||
2 => {
|
||
// IRDER = 2: 只计算 APP
|
||
process_irder2(params, state, nd, nfreq, ntranc, nlvexp);
|
||
}
|
||
3 => {
|
||
// IRDER = 3: 计算所有导数
|
||
process_irder3(params, state, nd, nfreq, ntranc, nlvexp);
|
||
}
|
||
_ => {
|
||
panic!("Invalid IRDER - ALIST2: {}", params.irder);
|
||
}
|
||
}
|
||
|
||
// 乘以频率无关常数
|
||
for id in 0..nd {
|
||
state.redx[id] *= params.wmm[id] * params.dens1[id] * params.dens1[id];
|
||
if id > 0 {
|
||
state.redxm[id] *= params.wmm[id] * params.dens1[id - 1] * params.dens1[id - 1];
|
||
}
|
||
|
||
// 对流冷却
|
||
state.flfix[id] = params.reint[id] * state.fcooli[id] - params.redif[id] * state.flfix[id];
|
||
|
||
// CRSW 缩放
|
||
if (params.crsw[id] - UN).abs() > 1e-10 {
|
||
for itr in 0..ntrans {
|
||
state.rru[itr * nd + id] *= params.crsw[id];
|
||
state.rrd[itr * nd + id] *= params.crsw[id];
|
||
state.drdt[itr * nd + id] *= params.crsw[id];
|
||
}
|
||
if params.irder > 0 {
|
||
for ii in 0..nlvexp {
|
||
state.apt[ii * nd + id] *= params.crsw[id];
|
||
state.apn[ii * nd + id] *= params.crsw[id];
|
||
for jj in 0..nlvexp {
|
||
state.app[(jj * nlvexp + ii) * nd + id] *= params.crsw[id];
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 辐射压力
|
||
for id in 0..nd {
|
||
state.pradt[id] *= PCK;
|
||
state.prada[id] *= PCK;
|
||
if state.prada[id] > 0.0 {
|
||
let prdr = state.pradt[id] / state.prada[id];
|
||
if prdr < prdx {
|
||
prdx = prdr;
|
||
}
|
||
}
|
||
}
|
||
|
||
*state.prd0 = *state.prd0 / params.dens1[0] * params.dm[0] * PCK;
|
||
|
||
// Rosseland 平均不透明度
|
||
let lross = (params.ioptab < 0 && dedm1 > 0.0) && (params.iter == 1 || params.lfin) || params.hmix0 > 0.0;
|
||
if lross {
|
||
for id in 0..nd {
|
||
state.abrosd[id] = state.sumdpl[id] / (state.abrosd[id] * params.dens[id]);
|
||
}
|
||
if params.ioptab < 0 {
|
||
// rosstd 函数调用 (待实现)
|
||
// rosstd(0);
|
||
}
|
||
}
|
||
|
||
Alist2Output { prdx }
|
||
}
|
||
|
||
/// 零初始化所有速率数组
|
||
fn zero_rates(state: &mut Alist2State, nd: usize, ntrans: usize, nlvexp: usize) {
|
||
for id in 0..nd {
|
||
state.reit[id] = 0.0;
|
||
state.rein[id] = 0.0;
|
||
state.reix[id] = 0.0;
|
||
state.areit[id] = 0.0;
|
||
state.arein[id] = 0.0;
|
||
state.creit[id] = 0.0;
|
||
state.crein[id] = 0.0;
|
||
state.creix[id] = 0.0;
|
||
state.redt[id] = 0.0;
|
||
state.redtm[id] = 0.0;
|
||
state.redtp[id] = 0.0;
|
||
state.redn[id] = 0.0;
|
||
state.rednm[id] = 0.0;
|
||
state.rednp[id] = 0.0;
|
||
state.redx[id] = 0.0;
|
||
state.redxm[id] = 0.0;
|
||
state.redxp[id] = 0.0;
|
||
state.heit[id] = 0.0;
|
||
state.heitm[id] = 0.0;
|
||
state.heitp[id] = 0.0;
|
||
state.hein[id] = 0.0;
|
||
state.heinm[id] = 0.0;
|
||
state.heinp[id] = 0.0;
|
||
state.ehet[id] = 0.0;
|
||
state.ehen[id] = 0.0;
|
||
state.eret[id] = 0.0;
|
||
state.eren[id] = 0.0;
|
||
state.fcooli[id] = 0.0;
|
||
state.flfix[id] = 0.0;
|
||
state.flexp[id] = 0.0;
|
||
state.flrd[id] = 0.0;
|
||
state.fprd[id] = 0.0;
|
||
state.pradt[id] = 0.0;
|
||
state.prada[id] = 0.0;
|
||
|
||
for ii in 0..nlvexp {
|
||
state.heip[ii * nd + id] = 0.0;
|
||
state.reip[ii * nd + id] = 0.0;
|
||
state.areip[ii * nd + id] = 0.0;
|
||
state.creip[ii * nd + id] = 0.0;
|
||
state.redp[ii * nd + id] = 0.0;
|
||
state.redpm[ii * nd + id] = 0.0;
|
||
state.heipm[ii * nd + id] = 0.0;
|
||
state.redpp[ii * nd + id] = 0.0;
|
||
state.heipp[ii * nd + id] = 0.0;
|
||
state.apt[ii * nd + id] = 0.0;
|
||
state.apn[ii * nd + id] = 0.0;
|
||
for jj in 0..nlvexp {
|
||
state.app[(jj * nlvexp + ii) * nd + id] = 0.0;
|
||
}
|
||
}
|
||
|
||
for itr in 0..ntrans {
|
||
state.rru[itr * nd + id] = 0.0;
|
||
state.rrd[itr * nd + id] = 0.0;
|
||
state.drdt[itr * nd + id] = 0.0;
|
||
}
|
||
}
|
||
*state.prd0 = 0.0;
|
||
}
|
||
|
||
/// IRDER = 3 的处理（计算所有导数）
|
||
fn process_irder3(
|
||
params: &Alist2Params,
|
||
state: &mut Alist2State,
|
||
nd: usize,
|
||
nfreq: usize,
|
||
ntranc: usize,
|
||
nlvexp: usize,
|
||
) {
|
||
let lross = (params.ioptab < 0 && params.dm[0] / params.dens[0] > 0.0)
|
||
&& (params.iter == 1 || params.lfin)
|
||
|| params.hmix0 > 0.0;
|
||
|
||
if lross {
|
||
for id in 0..nd {
|
||
state.abrosd[id] = 0.0;
|
||
state.sumdpl[id] = 0.0;
|
||
}
|
||
}
|
||
|
||
// 工作数组
|
||
let mut exx = vec![0.0; MDEPTH];
|
||
let mut rbnu = vec![0.0; MDEPTH];
|
||
let mut rbnuf = vec![0.0; MDEPTH];
|
||
|
||
for ij in 0..nfreq {
|
||
if params.ijx[ij] == -1 {
|
||
continue;
|
||
}
|
||
|
||
let fr = params.freq[ij];
|
||
let w0 = params.w0e[ij];
|
||
let lrder = params.ijali[ij] > 0;
|
||
|
||
// 注意：这里需要调用 OPACFD, RTEFR1, ALIFR1
|
||
// 由于这些函数有复杂的参数，这里用占位符表示
|
||
// call opacfd(ij);
|
||
// call rtefr1(ij);
|
||
// call alifr1(ij);
|
||
|
||
// if lross: call rosstd(ij);
|
||
|
||
if params.ioptab < 0 {
|
||
continue;
|
||
}
|
||
|
||
// 连续谱跃迁
|
||
process_continuum_transitions(
|
||
params,
|
||
state,
|
||
ij,
|
||
fr,
|
||
w0,
|
||
lrder,
|
||
nd,
|
||
ntranc,
|
||
nlvexp,
|
||
&mut exx,
|
||
&mut rbnu,
|
||
&mut rbnuf,
|
||
true, // compute_apt_apn_app
|
||
);
|
||
|
||
// 线跃迁
|
||
if params.ispodf == 0 {
|
||
process_line_transitions_standard(
|
||
params,
|
||
state,
|
||
ij,
|
||
fr,
|
||
w0,
|
||
lrder,
|
||
nd,
|
||
nlvexp,
|
||
&exx,
|
||
&rbnu,
|
||
&rbnuf,
|
||
true, // compute_apt_apn_app
|
||
);
|
||
} else {
|
||
process_line_transitions_odf(
|
||
params,
|
||
state,
|
||
ij,
|
||
w0,
|
||
lrder,
|
||
nd,
|
||
nlvexp,
|
||
&exx,
|
||
&rbnu,
|
||
&rbnuf,
|
||
true, // compute_apt_apn_app
|
||
);
|
||
}
|
||
}
|
||
}
|
||
|
||
/// IRDER = 1 的处理（只计算 APT, APN）
|
||
fn process_irder1(
|
||
params: &Alist2Params,
|
||
state: &mut Alist2State,
|
||
nd: usize,
|
||
nfreq: usize,
|
||
ntranc: usize,
|
||
nlvexp: usize,
|
||
) {
|
||
let mut exx = vec![0.0; MDEPTH];
|
||
let mut rbnu = vec![0.0; MDEPTH];
|
||
let mut rbnuf = vec![0.0; MDEPTH];
|
||
|
||
for ij in 0..nfreq {
|
||
if params.ijx[ij] == -1 {
|
||
continue;
|
||
}
|
||
|
||
let fr = params.freq[ij];
|
||
let w0 = params.w0e[ij];
|
||
let lrder = params.ijali[ij] > 0;
|
||
|
||
// call opacfd(ij);
|
||
// call rtefr1(ij);
|
||
// call alifr1(ij);
|
||
|
||
// 连续谱跃迁
|
||
process_continuum_transitions(
|
||
params,
|
||
state,
|
||
ij,
|
||
fr,
|
||
w0,
|
||
lrder,
|
||
nd,
|
||
ntranc,
|
||
nlvexp,
|
||
&mut exx,
|
||
&mut rbnu,
|
||
&mut rbnuf,
|
||
true, // compute_apt_apn
|
||
);
|
||
|
||
// 线跃迁
|
||
if params.ispodf == 0 {
|
||
process_line_transitions_standard(
|
||
params,
|
||
state,
|
||
ij,
|
||
fr,
|
||
w0,
|
||
lrder,
|
||
nd,
|
||
nlvexp,
|
||
&exx,
|
||
&rbnu,
|
||
&rbnuf,
|
||
true, // compute_apt_apn
|
||
);
|
||
} else {
|
||
process_line_transitions_odf(
|
||
params,
|
||
state,
|
||
ij,
|
||
w0,
|
||
lrder,
|
||
nd,
|
||
nlvexp,
|
||
&exx,
|
||
&rbnu,
|
||
&rbnuf,
|
||
true, // compute_apt_apn
|
||
);
|
||
}
|
||
}
|
||
}
|
||
|
||
/// IRDER = 2 的处理（只计算 APP）
|
||
fn process_irder2(
|
||
params: &Alist2Params,
|
||
state: &mut Alist2State,
|
||
nd: usize,
|
||
nfreq: usize,
|
||
ntranc: usize,
|
||
nlvexp: usize,
|
||
) {
|
||
let mut exx = vec![0.0; MDEPTH];
|
||
let mut rbnu = vec![0.0; MDEPTH];
|
||
let mut rbnuf = vec![0.0; MDEPTH];
|
||
|
||
for ij in 0..nfreq {
|
||
if params.ijx[ij] == -1 {
|
||
continue;
|
||
}
|
||
|
||
let fr = params.freq[ij];
|
||
let w0 = params.w0e[ij];
|
||
let lrder = params.ijali[ij] > 0;
|
||
|
||
// call opacfd(ij);
|
||
// call rtefr1(ij);
|
||
// call alifr1(ij);
|
||
|
||
// 连续谱跃迁
|
||
process_continuum_transitions(
|
||
params,
|
||
state,
|
||
ij,
|
||
fr,
|
||
w0,
|
||
lrder,
|
||
nd,
|
||
ntranc,
|
||
nlvexp,
|
||
&mut exx,
|
||
&mut rbnu,
|
||
&mut rbnuf,
|
||
false, // 不计算 apt/apn，只计算 app
|
||
);
|
||
|
||
// 线跃迁
|
||
if params.ispodf == 0 {
|
||
process_line_transitions_standard(
|
||
params,
|
||
state,
|
||
ij,
|
||
fr,
|
||
w0,
|
||
lrder,
|
||
nd,
|
||
nlvexp,
|
||
&exx,
|
||
&rbnu,
|
||
&rbnuf,
|
||
false, // 不计算 apt/apn，只计算 app
|
||
);
|
||
} else {
|
||
process_line_transitions_odf(
|
||
params,
|
||
state,
|
||
ij,
|
||
w0,
|
||
lrder,
|
||
nd,
|
||
nlvexp,
|
||
&exx,
|
||
&rbnu,
|
||
&rbnuf,
|
||
false, // 不计算 apt/apn，只计算 app
|
||
);
|
||
}
|
||
}
|
||
}
|
||
|
||
/// 处理连续谱跃迁
|
||
#[allow(clippy::too_many_arguments)]
|
||
fn process_continuum_transitions(
|
||
params: &Alist2Params,
|
||
state: &mut Alist2State,
|
||
_ij: usize,
|
||
fr: f64,
|
||
w0: f64,
|
||
lrder: bool,
|
||
nd: usize,
|
||
ntranc: usize,
|
||
nlvexp: usize,
|
||
exx: &mut [f64],
|
||
rbnu: &mut [f64],
|
||
rbnuf: &mut [f64],
|
||
compute_apt_apn: bool,
|
||
) {
|
||
// 计算辅助量
|
||
for id in 0..nd {
|
||
exx[id] = (-params.hkt1[id] * fr).exp();
|
||
rbnu[id] = (params.rad1[id] + params.bnue[_ij]) * exx[id];
|
||
rbnuf[id] = rbnu[id] * fr * params.hkt21[id];
|
||
}
|
||
|
||
// 遍历束缚-自由跃迁
|
||
for ibft in 0..ntranc {
|
||
let itr = (params.itrbf[ibft] - 1) as usize;
|
||
let ii = (params.ilow[itr] - 1) as usize;
|
||
let jj = (params.iup[itr] - 1) as usize;
|
||
|
||
for id in 0..nd {
|
||
// 检查零占据数
|
||
if params.ipzero[ii * nd + id] != 0 || params.ipzero[jj * nd + id] != 0 {
|
||
continue;
|
||
}
|
||
|
||
// 获取截面
|
||
let mut sg = get_cross_section(params, ibft, _ij, nd, id);
|
||
if sg <= 0.0 {
|
||
continue;
|
||
}
|
||
|
||
// 应用 Van der Waals 宽化或合并截面
|
||
let icdw = params.mcdw[itr];
|
||
let imer = params.imrg[ii];
|
||
if params.iifix[ii] >= 0 {
|
||
if icdw >= 1 {
|
||
sg *= params.dwf1[icdw as usize * nd + id];
|
||
}
|
||
} else {
|
||
sg = params.sgmg[imer as usize * nd + id];
|
||
}
|
||
|
||
let sgw0 = sg * w0;
|
||
|
||
// 更新跃迁率
|
||
state.rru[itr * nd + id] += sgw0 * params.rad1[id];
|
||
state.rrd[itr * nd + id] += sgw0 * rbnu[id];
|
||
state.drdt[itr * nd + id] += sgw0 * rbnuf[id];
|
||
|
||
if lrder {
|
||
let apfr = (params.abtra[itr * nd + id] - params.emtra[itr * nd + id] * exx[id]) * sgw0;
|
||
let ie = (params.iiexp[ii].abs()) as usize;
|
||
let je = (params.iiexp[jj].abs()) as usize;
|
||
let nrefi = params.nrefs[params.iatm[ii] as usize * nd + id] as usize;
|
||
|
||
// 更新 AP 矩阵
|
||
update_ap_matrices(
|
||
state,
|
||
id,
|
||
ie,
|
||
je,
|
||
ii,
|
||
jj,
|
||
nrefi,
|
||
apfr,
|
||
nd,
|
||
nlvexp,
|
||
params.dsfdt,
|
||
params.dsfdn,
|
||
params.dsfdp,
|
||
compute_apt_apn,
|
||
);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/// 获取截面（占位符）
|
||
fn get_cross_section(_params: &Alist2Params, _ibft: usize, _ij: usize, _nd: usize, _id: usize) -> f64 {
|
||
// 实际实现需要从 params.cross 数组读取
|
||
0.0
|
||
}
|
||
|
||
/// 更新 AP 矩阵
|
||
#[allow(clippy::too_many_arguments)]
|
||
fn update_ap_matrices(
|
||
state: &mut Alist2State,
|
||
id: usize,
|
||
ie: usize,
|
||
je: usize,
|
||
ii: usize,
|
||
jj: usize,
|
||
nrefi: usize,
|
||
apfr: f64,
|
||
nd: usize,
|
||
nlvexp: usize,
|
||
dsfdt: &[f64],
|
||
dsfdn: &[f64],
|
||
dsfdp: &[f64],
|
||
compute_apt_apn: bool,
|
||
) {
|
||
// 下能级贡献
|
||
if ie > 0 && ii != nrefi {
|
||
// 注意：需要检查 iltlev[ii] <= 0
|
||
if compute_apt_apn {
|
||
state.apt[ie * nd + id] += apfr * dsfdt[id];
|
||
state.apn[ie * nd + id] += apfr * dsfdn[id];
|
||
}
|
||
for kk in 0..nlvexp {
|
||
state.app[(kk * nlvexp + ie) * nd + id] += apfr * dsfdp[kk * nd + id];
|
||
}
|
||
}
|
||
|
||
// 上能级贡献
|
||
if je > 0 && jj != nrefi {
|
||
// 注意：需要检查 iltlev[jj] <= 0 && imodl[ii] != ±4
|
||
if compute_apt_apn {
|
||
state.apt[je * nd + id] -= apfr * dsfdt[id];
|
||
state.apn[je * nd + id] -= apfr * dsfdn[id];
|
||
}
|
||
for kk in 0..nlvexp {
|
||
state.app[(kk * nlvexp + je) * nd + id] -= apfr * dsfdp[kk * nd + id];
|
||
}
|
||
}
|
||
}
|
||
|
||
/// 处理标准线跃迁（非 ODF）
|
||
#[allow(clippy::too_many_arguments)]
|
||
fn process_line_transitions_standard(
|
||
params: &Alist2Params,
|
||
state: &mut Alist2State,
|
||
ij: usize,
|
||
fr: f64,
|
||
w0: f64,
|
||
lrder: bool,
|
||
nd: usize,
|
||
nlvexp: usize,
|
||
exx: &[f64],
|
||
rbnu: &[f64],
|
||
rbnuf: &[f64],
|
||
compute_apt_apn: bool,
|
||
) {
|
||
// 主线
|
||
if params.ijlin[ij] > 0 {
|
||
let itr = (params.ijlin[ij] - 1) as usize;
|
||
let ii = (params.ilow[itr] - 1) as usize;
|
||
let jj = (params.iup[itr] - 1) as usize;
|
||
let ie = (params.iiexp[ii].abs()) as usize;
|
||
let je = (params.iiexp[jj].abs()) as usize;
|
||
|
||
for id in 0..nd {
|
||
if params.ipzero[ii * nd + id] != 0 || params.ipzero[jj * nd + id] != 0 {
|
||
continue;
|
||
}
|
||
|
||
// 获取线轮廓
|
||
let sgw0 = params.prflin[id * params.nfreq + ij] * w0;
|
||
|
||
// 更新跃迁率
|
||
state.rru[itr * nd + id] += sgw0 * params.rad1[id];
|
||
state.rrd[itr * nd + id] += sgw0 * rbnu[id];
|
||
state.drdt[itr * nd + id] += sgw0 * rbnuf[id];
|
||
|
||
if lrder {
|
||
let apfr = (params.abtra[itr * nd + id] - params.emtra[itr * nd + id] * exx[id]) * sgw0;
|
||
let nrefi = params.nrefs[params.iatm[ii] as usize * nd + id] as usize;
|
||
|
||
update_ap_matrices(
|
||
state, id, ie, je, ii, jj, nrefi, apfr, nd, nlvexp,
|
||
params.dsfdt, params.dsfdn, params.dsfdp, compute_apt_apn,
|
||
);
|
||
}
|
||
}
|
||
}
|
||
|
||
// 重叠线
|
||
if params.nlines[ij] <= 0 {
|
||
return;
|
||
}
|
||
|
||
for ilint in 0..params.nlines[ij] as usize {
|
||
let itr = (params.itrlin[ij * 100 + ilint] - 1) as usize; // 假设最大 100 条重叠线
|
||
if params.linexp[itr] {
|
||
continue;
|
||
}
|
||
|
||
let ii = (params.ilow[itr] - 1) as usize;
|
||
let jj = (params.iup[itr] - 1) as usize;
|
||
let ie = (params.iiexp[ii].abs()) as usize;
|
||
let je = (params.iiexp[jj].abs()) as usize;
|
||
|
||
// 频率插值
|
||
let ij0 = (params.ifr0[itr] - 1) as usize;
|
||
let ij1 = if ij0 > 0 { ij0 - 1 } else { 0 };
|
||
|
||
let a1 = if ij1 != ij0 {
|
||
(fr - params.freq[ij0]) / (params.freq[ij1] - params.freq[ij0]) * w0
|
||
} else {
|
||
0.0
|
||
};
|
||
let a2 = w0 - a1;
|
||
|
||
for id in 0..nd {
|
||
if params.ipzero[ii * nd + id] != 0 || params.ipzero[jj * nd + id] != 0 {
|
||
continue;
|
||
}
|
||
|
||
let sgw0 = a1 * params.prflin[id * params.nfreq + ij1] + a2 * params.prflin[id * params.nfreq + ij0];
|
||
|
||
state.rru[itr * nd + id] += sgw0 * params.rad1[id];
|
||
state.rrd[itr * nd + id] += sgw0 * rbnu[id];
|
||
state.drdt[itr * nd + id] += sgw0 * rbnuf[id];
|
||
|
||
if lrder {
|
||
let apfr = (params.abtra[itr * nd + id] - params.emtra[itr * nd + id] * exx[id]) * sgw0;
|
||
let nrefi = params.nrefs[params.iatm[ii] as usize * nd + id] as usize;
|
||
|
||
update_ap_matrices(
|
||
state, id, ie, je, ii, jj, nrefi, apfr, nd, nlvexp,
|
||
params.dsfdt, params.dsfdn, params.dsfdp, compute_apt_apn,
|
||
);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/// 处理 ODF 线跃迁
|
||
#[allow(clippy::too_many_arguments)]
|
||
fn process_line_transitions_odf(
|
||
params: &Alist2Params,
|
||
state: &mut Alist2State,
|
||
ij: usize,
|
||
w0: f64,
|
||
lrder: bool,
|
||
nd: usize,
|
||
nlvexp: usize,
|
||
exx: &[f64],
|
||
rbnu: &[f64],
|
||
rbnuf: &[f64],
|
||
compute_apt_apn: bool,
|
||
) {
|
||
if params.nlines[ij] <= 0 {
|
||
return;
|
||
}
|
||
|
||
for ilint in 0..params.nlines[ij] as usize {
|
||
let itr = (params.itrlin[ij * 100 + ilint] - 1) as usize;
|
||
let ii = (params.ilow[itr] - 1) as usize;
|
||
let jj = (params.iup[itr] - 1) as usize;
|
||
let ie = (params.iiexp[ii].abs()) as usize;
|
||
let je = (params.iiexp[jj].abs()) as usize;
|
||
|
||
let kj = ij - (params.ifr0[itr] - 1) as usize + (params.kfr0[itr] - 1) as usize;
|
||
let indxpa = (params.indexp[itr].abs()) as i32;
|
||
|
||
for id in 0..nd {
|
||
if params.ipzero[ii * nd + id] != 0 || params.ipzero[jj * nd + id] != 0 {
|
||
continue;
|
||
}
|
||
|
||
let sgw0 = if indxpa != 3 && indxpa != 4 {
|
||
// 标准 ODF
|
||
params.prflin[id * params.nfreq + kj] * w0
|
||
} else {
|
||
// Fe 线特殊处理
|
||
let kjd = (params.jidi[id] - 1) as usize;
|
||
let sg = (params.xjid[id] * params.sigfe[kjd * 1000 + kj]
|
||
+ (UN - params.xjid[id]) * params.sigfe[(kjd + 1) * 1000 + kj]).exp();
|
||
sg * w0
|
||
};
|
||
|
||
state.rru[itr * nd + id] += sgw0 * params.rad1[id];
|
||
state.rrd[itr * nd + id] += sgw0 * rbnu[id];
|
||
state.drdt[itr * nd + id] += sgw0 * rbnuf[id];
|
||
|
||
if lrder {
|
||
let apfr = (params.abtra[itr * nd + id] - params.emtra[itr * nd + id] * exx[id]) * sgw0;
|
||
let nrefi = params.nrefs[params.iatm[ii] as usize * nd + id] as usize;
|
||
|
||
update_ap_matrices(
|
||
state, id, ie, je, ii, jj, nrefi, apfr, nd, nlvexp,
|
||
params.dsfdt, params.dsfdn, params.dsfdp, compute_apt_apn,
|
||
);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
|
||
#[test]
|
||
fn test_alist2_zero_rates() {
|
||
let nd = 5;
|
||
let ntrans = 10;
|
||
let nlvexp = 3;
|
||
|
||
let mut reit = vec![0.0; MDEPTH];
|
||
let mut rru = vec![0.0; MTRANS * MDEPTH];
|
||
let mut apt = vec![0.0; MLVEXP * MDEPTH];
|
||
|
||
let mut state = Alist2State {
|
||
reit: &mut reit,
|
||
rein: &mut vec![0.0; MDEPTH],
|
||
reix: &mut vec![0.0; MDEPTH],
|
||
areit: &mut vec![0.0; MDEPTH],
|
||
arein: &mut vec![0.0; MDEPTH],
|
||
creit: &mut vec![0.0; MDEPTH],
|
||
crein: &mut vec![0.0; MDEPTH],
|
||
creix: &mut vec![0.0; MDEPTH],
|
||
redt: &mut vec![0.0; MDEPTH],
|
||
redtm: &mut vec![0.0; MDEPTH],
|
||
redtp: &mut vec![0.0; MDEPTH],
|
||
redn: &mut vec![0.0; MDEPTH],
|
||
rednm: &mut vec![0.0; MDEPTH],
|
||
rednp: &mut vec![0.0; MDEPTH],
|
||
redx: &mut vec![0.0; MDEPTH],
|
||
redxm: &mut vec![0.0; MDEPTH],
|
||
redxp: &mut vec![0.0; MDEPTH],
|
||
heit: &mut vec![0.0; MDEPTH],
|
||
heitm: &mut vec![0.0; MDEPTH],
|
||
heitp: &mut vec![0.0; MDEPTH],
|
||
hein: &mut vec![0.0; MDEPTH],
|
||
heinm: &mut vec![0.0; MDEPTH],
|
||
heinp: &mut vec![0.0; MDEPTH],
|
||
ehet: &mut vec![0.0; MDEPTH],
|
||
ehen: &mut vec![0.0; MDEPTH],
|
||
eret: &mut vec![0.0; MDEPTH],
|
||
eren: &mut vec![0.0; MDEPTH],
|
||
fcooli: &mut vec![0.0; MDEPTH],
|
||
flfix: &mut vec![0.0; MDEPTH],
|
||
flexp: &mut vec![0.0; MDEPTH],
|
||
flrd: &mut vec![0.0; MDEPTH],
|
||
fprd: &mut vec![0.0; MDEPTH],
|
||
pradt: &mut vec![0.0; MDEPTH],
|
||
prada: &mut vec![0.0; MDEPTH],
|
||
heip: &mut vec![0.0; MLVEXP * MDEPTH],
|
||
reip: &mut vec![0.0; MLVEXP * MDEPTH],
|
||
areip: &mut vec![0.0; MLVEXP * MDEPTH],
|
||
creip: &mut vec![0.0; MLVEXP * MDEPTH],
|
||
redp: &mut vec![0.0; MLVEXP * MDEPTH],
|
||
redpm: &mut vec![0.0; MLVEXP * MDEPTH],
|
||
heipm: &mut vec![0.0; MLVEXP * MDEPTH],
|
||
redpp: &mut vec![0.0; MLVEXP * MDEPTH],
|
||
heipp: &mut vec![0.0; MLVEXP * MDEPTH],
|
||
apt: &mut apt,
|
||
apn: &mut vec![0.0; MLVEXP * MDEPTH],
|
||
app: &mut vec![0.0; MLVEXP * MLVEXP * MDEPTH],
|
||
abrosd: &mut vec![0.0; MDEPTH],
|
||
sumdpl: &mut vec![0.0; MDEPTH],
|
||
rru: &mut rru,
|
||
rrd: &mut vec![0.0; MTRANS * MDEPTH],
|
||
drdt: &mut vec![0.0; MTRANS * MDEPTH],
|
||
prd0: &mut 0.0,
|
||
};
|
||
|
||
// 初始化一些非零值
|
||
state.reit[0] = 1.0;
|
||
state.rru[0] = 1.0;
|
||
|
||
zero_rates(&mut state, nd, ntrans, nlvexp);
|
||
|
||
// 验证所有值都被清零
|
||
for id in 0..nd {
|
||
assert_eq!(state.reit[id], 0.0);
|
||
}
|
||
for itr in 0..ntrans {
|
||
for id in 0..nd {
|
||
assert_eq!(state.rru[itr * nd + id], 0.0);
|
||
}
|
||
}
|
||
}
|
||
}
|