Struct TabulatedResolution 

pub struct TabulatedResolution { /* private fields */ }

A tabulated resolution function from Monte Carlo instrument simulation.

Contains reference kernels R(Δt; E_ref) at discrete energies, stored in TOF-offset space (μs). Kernels are interpolated between reference energies and converted from TOF to energy space when applied.

File Format (VENUS/FTS)

FTS BL10 case i00dd folded triang FWHM 350 ns PSR   ← header
-----                                                 ← separator
   5.00000e-004   0.00000e+000                        ← energy block start
-53.458917835671329 2.051764258257523e-04             ← (tof_offset_μs, weight)
...
                                                      ← blank line separates blocks
   1.00000e-003   0.00000e+000                        ← next energy block
...

Implementations

impl TabulatedResolution

pub fn ref_energies(&self) -> &[f64]

Reference energies (eV), sorted ascending.

pub fn kernels(&self) -> &[(Vec<f64>, Vec<f64>)]

For each reference energy: (tof_offsets_μs, weights) pairs. Weights are peak-normalized (max=1.0).

pub fn flight_path_m(&self) -> f64

Flight path length in meters (needed for TOF↔energy conversion).

pub fn kernel_support_ev(&self, e_ev: f64) -> f64

Kernel support at energy e_ev, in eV.

Returns the maximum energy offset over which the tabulated kernel has non-zero weight at energy e_ev. Past this distance the kernel is exactly zero, so the broadening footprint at a given target energy is fully contained within [e_ev − support, e_ev + support].

Computation:

1. Find the bracketing reference kernel(s) for e_ev via binary search on the sorted ref_energies grid.
2. Take max(|tof_offset|) over all bracketing kernels’ entries with positive weight. Using both bracketing kernels (rather than the single nearest) is conservative — over-estimating the margin is safer than under-estimating when the kernel is interpolated between references.
3. Convert TOF offset to energy offset via |ΔE| = 2·E^(3/2) / (TOF_FACTOR·L) · |Δt|, the magnitude of dE/dt at e_ev along the TOF→E mapping t = TOF_FACTOR·L/√E (chain rule).

Returns 0.0 for non-positive e_ev, an empty kernel set, or a non-positive flight path. Used by the GUI’s fit-energy-range slicing to extend the model-evaluation grid beyond the user’s [E_min, E_max] so the SAMMY EMIN/EMAX- equivalent broadening at the boundaries is correct (#514).

impl TabulatedResolution

pub fn from_text( text: &str, flight_path_m: f64, ) -> Result<Self, ResolutionParseError>

Parse a VENUS/FTS resolution file.

Arguments

• text — File contents as a string.
• flight_path_m — Flight path length in meters.

pub fn from_file( path: &str, flight_path_m: f64, ) -> Result<Self, ResolutionParseError>

Parse a VENUS/FTS resolution file from disk.

pub fn broaden( &self, energies: &[f64], spectrum: &[f64], ) -> Result<Vec<f64>, ResolutionError>

Apply tabulated resolution broadening to a spectrum.

For each energy point:

1. Find bracketing reference energies and interpolate kernel (log-space)
2. Convert TOF offsets to energy offsets using exact TOF↔energy relation
3. Convolve spectrum with interpolated kernel (trapezoidal integration)

Errors

Returns ResolutionError::LengthMismatch if the arrays differ in length, or ResolutionError::UnsortedEnergies if the energy grid is not sorted in non-descending order.

pub fn plan(&self, energies: &[f64]) -> Result<ResolutionPlan, ResolutionError>

Build a reusable broadening plan for a specific target energy grid.

Validates that energies is non-descending — the same sorted-grid precondition enforced by TabulatedResolution::broaden via validate_inputs. An unsorted grid would produce a silently-wrong plan (misbracketed e_prime lookups against e_min / e_max), so it must be caught at build time rather than returning garbage from ResolutionPlan::apply.

The plan hoists every quantity that depends only on (target_energies, self.ref_energies, self.flight_path_m) — namely the TOF conversion, the log-space kernel interpolation, the per-kernel-point e_prime and spectrum-bracket lookup, and the trapezoidal integration widths. Applying the plan to a spectrum becomes a pure gather + multiply-add loop.

Build cost: same as one call to the private broaden_presorted helper (O(N_target × N_kernel) TOF / bracket / interp work, plus ~2 × N_kernel log-interp ops per target energy for interpolated_kernel). Apply cost per target: 1 branch + ~3 loads + 3 flops per retained entry, plus the final divide — typically < 10 % of the build cost. The payoff comes from reusing one plan across many spectra.

Bit-exact with broaden_presorted: pre-computes the same floating-point sequences (TOF, e_prime, dt_width, frac, weight, norm) in the same order.

Errors

Returns ResolutionError::UnsortedEnergies if energies is not non-descending.

Trait Implementations

impl Clone for TabulatedResolution

fn clone(&self) -> TabulatedResolution

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TabulatedResolution

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.