code_public/radiacode
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fix: CsI(Tl) non-linear response correction + detector calibration overhaul

Browse Source 
Root cause of Am-241 misidentification: the Radiacode 103's CsI(Tl) crystal
shifts low-energy peaks upward (59.5 keV → 71.6 keV for Am-241) due to
non-proportional scintillation response. The model was trained on theoretical
peak positions and couldn't match the shifted real peaks.

Changes:
- Add inverse CsI(Tl) non-linear correction to inference pipeline
  (radiacode_monitor.py, web/config.py, test_detection.py)
  E_apparent = E_true * (1 + 0.37 * exp(-E_true/100))
  Corrects channel mapping so peaks appear at theoretical energies
- Fix energy calibration: DetectorConfig now uses E = 0.33 + 2.97*ch
  with 1023 channels, matching the real detector (was energy_min=20,
  skip_first_channel=True, different channel width)
- Add K-escape peaks for CsI(Tl) iodine X-ray escape (E - 28.5 keV)
- Add asymmetric peak shapes for low-energy tails (< 200 keV)
- Add log1p normalization in dataset and inference (replaces max-norm)
- Add background-subtracted training mode (subtract_background flag)
- Add low-signal augmentation (0.01-5 Bq activities, 30-300s durations)
- Update docker-compose.yml: batch_size=32, duration=30-300s,
  CSI_NONLINEAR_ALPHA/BETA env vars for detect and web
- Web dashboard: apply CsI correction to displayed spectra
- Various UI fixes (Chart.js width, zoom/pan, isotope lines)

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
This commit is contained in:
Jacquin Antoine
2026-05-21 17:35:22 +02:00
parent 3b4446b181
commit 0847a3fc80
21 changed files with 913 additions and 278 deletions
Download Patch File Download Diff File Expand all files Collapse all files

154
train/vega_ml/synthetic_spectra/physics/spectrum_physics.py
View File

@ -184,38 +184,148 @@ def calculate_expected_counts(
return expected
def _k_escape_fraction(energy_kev: float, detector_config: Optional[DetectorConfig] = None) -> float:
"""
Calculate K-escape peak fraction for CsI(Tl) detector.
For iodine K-shell (binding energy ~33.2 keV), when a gamma photon
interacts with the K-shell, there's a chance the K X-ray escapes the
crystal, producing a peak at E - E_Ka (~28.5 keV for I K-alpha).
The escape fraction decreases with energy as the photoelectric cross-section
ratio (K-shell / total) decreases.
Args:
energy_kev: Gamma energy in keV
detector_config: Detector configuration
Returns:
Fraction of photopeak counts that appear in the K-escape peak
"""
if energy_kev <= 33.2:
return 0.0
# K-shell binding energy for iodine
k_binding = 33.2 # keV
# K-escape fraction for CsI(Tl) detector
# Based on measured data: ~35% at 60 keV, ~15% at 150 keV, ~5% at 662 keV
# Model as: fraction = A * (1 - exp(-E/B)) where A and B are fit parameters
# Fitted to typical CsI K-escape measurements
fraction = 0.40 * (1.0 - np.exp(-(energy_kev - k_binding) / 80.0))
return float(np.clip(fraction, 0.0, 0.45))
def _asymmetric_peak(
energy_bins: np.ndarray,
peak_energy: float,
sigma: float,
amplitude: float,
tail_fraction: float = 0.0,
tail_sigma_ratio: float = 3.0
) -> np.ndarray:
"""
Generate an asymmetric peak using an exponentially-modified Gaussian.
For scintillation detectors at low energies, incomplete charge collection
creates a low-energy tail. The tail fraction increases at lower energies.
Args:
energy_bins: Array of energy bin centers (keV)
peak_energy: Center energy of peak (keV)
sigma: Gaussian sigma (keV)
amplitude: Total peak area (counts)
tail_fraction: Fraction of peak area in low-energy tail (0-0.5)
tail_sigma_ratio: Ratio of tail sigma to peak sigma
Returns:
Array of counts in each bin
"""
# Main Gaussian component
main_peak = gaussian_peak(energy_bins, peak_energy, sigma, amplitude * (1 - tail_fraction))
if tail_fraction <= 0:
return main_peak
# Low-energy tail: Gaussian shifted to lower energy with broader width
tail_sigma = sigma * tail_sigma_ratio
tail_energy = peak_energy - 2.0 * sigma # Tail centered 2 sigma below peak
tail_peak = gaussian_peak(energy_bins, tail_energy, tail_sigma, amplitude * tail_fraction)
return main_peak + tail_peak
def generate_peak_spectrum(
energy_bins: np.ndarray,
peak_params: PeakParameters,
detector_config: Optional[DetectorConfig] = None
) -> np.ndarray:
"""
Generate a single gamma peak with detector response.
Generate a single gamma peak with realistic CsI(Tl) detector response.
Includes:
- Asymmetric peak shape (low-energy tail from incomplete charge collection)
- K-escape peak (Iodine K-shell X-ray escape at E - 28.5 keV)
- Energy-dependent resolution
Note: Peaks are placed at theoretical gamma energies. The non-linear
CsI(Tl) response correction is applied in the inference pipeline
(radiacode_monitor.py), not here, to keep training data detector-independent.
Args:
energy_bins: Array of energy bin centers (keV)
energy_bins: Array of energy bin centers (keV) matching detector calibration
peak_params: Peak parameters
detector_config: Detector configuration
Returns:
Array of expected counts in each bin (not yet Poisson sampled)
"""
if detector_config is None:
detector_config = get_default_config()
# Calculate expected counts
amplitude = calculate_expected_counts(peak_params, detector_config)
if amplitude <= 0:
total_amplitude = calculate_expected_counts(peak_params, detector_config)
if total_amplitude <= 0:
return np.zeros_like(energy_bins)
# Calculate peak width
fwhm_kev = calculate_fwhm(peak_params.energy_kev, detector_config.fwhm_at_662)
sigma = fwhm_to_sigma(fwhm_kev)
# Generate Gaussian peak
peak = gaussian_peak(energy_bins, peak_params.energy_kev, sigma, amplitude)
# Low-energy tail fraction: increases at lower energies due to
# incomplete charge collection in CsI(Tl)
if peak_params.energy_kev < 200:
tail_frac = 0.15 * (1.0 - peak_params.energy_kev / 200.0)
else:
tail_frac = 0.0
# Generate main peak (asymmetric)
peak = _asymmetric_peak(
energy_bins, peak_params.energy_kev, sigma,
total_amplitude, tail_fraction=tail_frac
)
# K-escape peak for CsI(Tl)
escape_frac = _k_escape_fraction(peak_params.energy_kev, detector_config)
if escape_frac > 0:
escape_energy = peak_params.energy_kev - 28.5 # I K-alpha at 28.5 keV
if escape_energy > 20: # Only if above detection threshold
escape_amplitude = total_amplitude * escape_frac
# Reduce main peak amplitude
peak = peak * (1 - escape_frac)
# Escape peak has slightly broader resolution
escape_fwhm = calculate_fwhm(escape_energy, detector_config.fwhm_at_662)
escape_sigma = fwhm_to_sigma(escape_fwhm) * 1.3
escape_peak = _asymmetric_peak(
energy_bins, escape_energy, escape_sigma,
escape_amplitude, tail_fraction=0.25
)
peak = peak + escape_peak
return peak
@ -636,11 +746,11 @@ def apply_electronic_noise(
def normalize_spectrum(
spectrum: np.ndarray,
method: str = "max"
method: str = "log1p"
) -> np.ndarray:
"""
Normalize a spectrum for ML training.
Args:
spectrum: Raw count spectrum
method: Normalization method
@ -648,7 +758,8 @@ def normalize_spectrum(
- "sum": Divide by total counts (probability distribution)
- "log": Log transform then max normalize
- "sqrt": Square root transform then max normalize
- "log1p": log(1+x) then max normalize (best for bg-subtracted spectra)
Returns:
Normalized spectrum
"""
@ -657,7 +768,7 @@ def normalize_spectrum(
if max_val > 0:
return spectrum / max_val
return spectrum
elif method == "sum":
total = spectrum.sum()
if total > 0:
@ -678,6 +789,13 @@ def normalize_spectrum(
if max_val > 0:
return sqrt_spec / max_val
return sqrt_spec
elif method == "log1p":
log_spec = np.log1p(np.maximum(spectrum, 0))
max_val = log_spec.max()
if max_val > 0:
return log_spec / max_val
return log_spec
else:
raise ValueError(f"Unknown normalization method: {method}")