Files
2026-10-12 18:55:48 +08:00

247 lines
10 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

"""实验流程编排:参数 → 生成 → 采样 → 校准 → 拟合 → 统计(纯数据,Pyodide 可运行)。
里程碑映射:
- M0:单指数信号 + 10 ns 直接采样 + 噪声 + NLS 寿命拟合;
- M2:四通道光纤延时采样 + 通道误差注入 + 校准(名义 vs 标定)对比;
- M4:单通道直接采样 vs 四相位等效采样 的双指数 τ₂ 蒙特卡洛对比。
"""
import numpy as np
from .core import acquisition, calibration, fitting, signal, statistics
from . import ALGO_VERSION
M0_DEFAULTS = {
"preset": "single", # single / monte_carlo / measured_ref
"tau": 52.8, # ns(仅 single 预设生效)
"amplitude": 1.0,
"b0": 0.0,
"b1": 0.0,
"window_ns": 400.0,
"dt_ns": 10.0,
"t0_ns": 0.0,
"snr_db": 50.0, # None → 无噪声
"bits": 12, # None → 不量化
"bandwidth_sigma_ns": 0.0,
"jitter_ns": 0.0,
}
CONT_STEP_NS = 0.01 # 连续曲线网格步长(仅用于画图与插值)
def _resolve(params):
"""合并默认参数并解析为信号/采集两组参数。"""
p = dict(M0_DEFAULTS)
p.update({k: v for k, v in (params or {}).items() if v is not None or k in ("snr_db", "bits", "b0", "b1")})
sig_params = signal.resolve_preset(p["preset"], tau=p["tau"], amplitude=p["amplitude"],
b0=p["b0"], b1=p["b1"])
return p, sig_params
def run_m0(params=None, seed=42):
"""单次 M0 实验:生成 → 采样 → 拟合。返回纯数据 dict。"""
p, sig_params = _resolve(params)
rng = np.random.default_rng(seed)
t_cont = np.arange(0.0, float(p["window_ns"]) + CONT_STEP_NS / 2, CONT_STEP_NS)
y_cont = signal.generate(t_cont, sig_params)
acq_params = {
"dt_ns": p["dt_ns"], "t0_ns": p["t0_ns"], "window_ns": p["window_ns"],
"snr_db": p.get("snr_db"), "bits": p.get("bits"),
"bandwidth_sigma_ns": p["bandwidth_sigma_ns"], "jitter_ns": p["jitter_ns"],
}
acq = acquisition.run_single_channel(t_cont, y_cont, acq_params, rng)
fit = fitting.fit_single_exp_nls(acq["t_samples"], acq["y_samples"])
tau_true = float(sig_params["tau2"])
rel_err = abs(fit["tau"] - tau_true) / tau_true if tau_true else None
return {
"meta": {
"experiment": "m0_single_channel_fit",
"algo_version": ALGO_VERSION,
"data_origin": "software-simulated",
"seed": int(seed),
"params": {k: (v if not isinstance(v, float) else round(v, 6)) for k, v in p.items()},
},
"t_cont": t_cont, "y_cont": y_cont,
"t_samples": acq["t_samples"], "y_clean": acq["y_clean"], "y_samples": acq["y_samples"],
"n_samples": acq["n_samples"], "sigma": acq["sigma"],
"snr_db": acq["snr_db"], "bits": acq["bits"],
"fit": {k: v for k, v in fit.items() if k != "residual"},
"residual": fit["residual"],
"tau_hat": fit["tau"], "tau_true": tau_true, "rel_error": rel_err,
}
def run_m0_repeats(params=None, repeats=20, seed=0):
"""重复 M0 实验(不同种子)→ τ̂ 分布统计。"""
p, sig_params = _resolve(params)
tau_true = float(sig_params["tau2"])
tau_hats, n_pts = [], []
for i in range(int(repeats)):
rec = run_m0(params, seed=seed + i)
tau_hats.append(rec["tau_hat"])
n_pts.append(rec["n_samples"])
arr = np.asarray(tau_hats, dtype=float)
mean = float(np.mean(arr))
return {
"meta": {
"experiment": "m0_repeats",
"algo_version": ALGO_VERSION,
"data_origin": "software-simulated",
"base_seed": int(seed), "repeats": int(repeats),
"params": {k: v for k, v in p.items()},
},
"tau_true": tau_true,
"tau_hats": tau_hats,
"n_samples": int(n_pts[0]) if n_pts else 0,
"mean": mean,
"std": float(np.std(arr, ddof=1)) if len(arr) > 1 else 0.0,
"rel_std": float(np.std(arr, ddof=1) / mean) if len(arr) > 1 and mean else None,
"bias": float((mean - tau_true) / tau_true) if tau_true else None,
}
# ---------- M2:四通道误差注入与校准 ----------
M2_DEFAULTS = {
"preset": "single", "tau": 52.8, "window_ns": 400.0, "dt_ns": 10.0,
"snr_db": 50.0, "bits": 12,
"delays_ns": [0.0, 47.5, 95.0, 142.5],
"gain_errors": [0.0, 0.10, -0.08, 0.06], # 通道失配(相对,教学上取可见幅度)
"delay_errors": [0.0, 0.5, -0.4, 0.3], # 延时误差 ns
"baselines": [0.0, 0.02, -0.015, 0.01], # 基线(相对峰值)
"calib_residual_ns": 0.05, # 标定残差 ns(对应原项目 0.01ns 级)
}
def run_m2(params=None, seed=42):
"""M2:四通道采样 + 误差注入 + 三种处理方案对比(不校准 / 基线增益校准 / 完整校准)。"""
p = dict(M2_DEFAULTS)
p.update({k: v for k, v in (params or {}).items()})
rng = np.random.default_rng(seed)
sig_params = signal.resolve_preset(p["preset"], tau=p["tau"])
t_cont = np.arange(0.0, float(p["window_ns"]) + CONT_STEP_NS / 2, CONT_STEP_NS)
y_cont = signal.generate(t_cont, sig_params)
acq = acquisition.run_multi_channel(t_cont, y_cont, {
"delays": p["delays_ns"], "gain_errors": p["gain_errors"],
"delay_errors": p["delay_errors"], "baselines": p["baselines"],
"dt_ns": p["dt_ns"], "window_ns": p["window_ns"],
"snr_db": p["snr_db"], "bits": p["bits"],
}, rng)
# 方案 raw:完全不校准(原始数据 + 名义延时)
cal_raw = calibration.calibrate_channels(
acq["channels"], p["dt_ns"], method="nominal",
do_baseline=False, do_gain=False)
# 方案 nominal:基线 + 增益校准,延时仍用名义值
cal_nominal = calibration.calibrate_channels(acq["channels"], p["dt_ns"], method="nominal")
# 方案 calibrated:完整校准(标定延时 = 真实延时 + 标定残差)
true_delays = [d + e for d, e in zip(p["delays_ns"], p["delay_errors"])]
calib_delays = [d + r for d, r in zip(true_delays,
[0.0] + [p["calib_residual_ns"]] * (len(true_delays) - 1))]
cal_calib = calibration.calibrate_channels(acq["channels"], p["dt_ns"],
delay_est_ns=calib_delays)
def _fit(cal):
if cal["n_points"] < 3:
return None
try:
return fitting.fit_single_exp_nls(cal["t_rebuilt"], cal["y_rebuilt"])["tau"]
except Exception:
return None
tau_true = float(sig_params["tau2"])
return {
"meta": {"experiment": "m2_four_channel_calibration",
"algo_version": ALGO_VERSION, "data_origin": "software-simulated",
"seed": int(seed), "params": p},
"tau_true": tau_true,
"channels": acq["channels"],
"sigma": acq["sigma"], "peak": acq["peak"],
"raw": {"t": cal_raw["t_rebuilt"], "y": cal_raw["y_rebuilt"],
"tau_hat": _fit(cal_raw), "n_points": cal_raw["n_points"],
"continuity": cal_raw["continuity"]},
"nominal": {"t": cal_nominal["t_rebuilt"], "y": cal_nominal["y_rebuilt"],
"tau_hat": _fit(cal_nominal), "n_points": cal_nominal["n_points"],
"continuity": cal_nominal["continuity"]},
"calibrated": {"t": cal_calib["t_rebuilt"], "y": cal_calib["y_rebuilt"],
"tau_hat": _fit(cal_calib), "n_points": cal_calib["n_points"],
"continuity": cal_calib["continuity"],
"baselines": cal_calib["baselines"], "gains": cal_calib["gains"],
"delay_est_ns": cal_calib["delay_used_ns"]},
}
# ---------- M4:单通道 vs 四相位等效采样(双指数 τ₂ 蒙特卡洛) ----------
M4_DEFAULTS = {
"preset": "monte_carlo", # 双指数 0.16/0.60 + 0.84/52.80(报告 5.4.4 真值)
"window_ns": 400.0, "dt_ns": 10.0,
"snr_db": 50.0, "bits": 14,
"delays_ns": [0.0, 47.5, 95.0, 142.5],
"gain_errors": [0.0] * 4, "delay_errors": [0.0] * 4, "baselines": [0.0] * 4,
}
def _fit_double_tau2(t, y):
if len(t) < 6:
return None
try:
return fitting.fit_double_exp_nls(t, y)["tau2"]
except Exception:
return None
def _gen_single(seed, p):
"""单通道 10ns 直接采样 → 双指数拟合 τ₂。"""
rng = np.random.default_rng(seed)
sig_params = signal.resolve_preset(p["preset"])
t_cont = np.arange(0.0, float(p["window_ns"]) + CONT_STEP_NS / 2, CONT_STEP_NS)
y_cont = signal.generate(t_cont, sig_params)
acq = acquisition.run_single_channel(t_cont, y_cont, {
"dt_ns": p["dt_ns"], "window_ns": p["window_ns"],
"snr_db": p["snr_db"], "bits": p["bits"],
}, rng)
return _fit_double_tau2(acq["t_samples"], acq["y_samples"])
def _gen_fiber(seed, p):
"""四相位等效采样(理想校准)→ 重建 → 双指数拟合 τ₂。"""
rng = np.random.default_rng(seed)
sig_params = signal.resolve_preset(p["preset"])
t_cont = np.arange(0.0, float(p["window_ns"]) + CONT_STEP_NS / 2, CONT_STEP_NS)
y_cont = signal.generate(t_cont, sig_params)
acq = acquisition.run_multi_channel(t_cont, y_cont, {
"delays": p["delays_ns"], "gain_errors": p["gain_errors"],
"delay_errors": p["delay_errors"], "baselines": p["baselines"],
"dt_ns": p["dt_ns"], "window_ns": p["window_ns"],
"snr_db": p["snr_db"], "bits": p["bits"],
}, rng)
cal = calibration.calibrate_channels(acq["channels"], p["dt_ns"], method="nominal",
do_baseline=False, do_gain=False)
return _fit_double_tau2(cal["t_rebuilt"], cal["y_rebuilt"])
def run_m4_compare(repeats=200, seed=0, snr_db=50.0):
"""M4 核心:单通道 vs 四相位 的 τ₂ 蒙特卡洛对比(复现 7.65%→0.60% 量级)。"""
p = dict(M4_DEFAULTS)
p["snr_db"] = snr_db
st_single = statistics.monte_carlo(
lambda s: _gen_single(s, p), repeats=repeats, seed=seed, tau_true=52.80)
st_fiber = statistics.monte_carlo(
lambda s: _gen_fiber(s, p), repeats=repeats, seed=seed, tau_true=52.80)
return {
"meta": {"experiment": "m4_monte_carlo_single_vs_fiber",
"algo_version": ALGO_VERSION, "data_origin": "software-simulated",
"repeats": int(repeats), "base_seed": int(seed),
"params": {k: v for k, v in p.items()}},
"tau_true": 52.80,
"single": st_single,
"fiber": st_fiber,
}