essreduce 25.3.1__py3-none-any.whl → 25.4.1__py3-none-any.whl

ess/reduce/live/raw.py

@@ -380,7 +380,8 @@ class RollingDetectorView(Detector):
             pixel_noise = sc.scalar(0.0, unit='m')
             noise_replica_count = 0
         else:
-            noise_replica_count = 16
+            # Unclear what a good number is, could be made configurable.
+            noise_replica_count = 4
         wf = GenericNeXusWorkflow(run_types=[SampleRun], monitor_types=[])
         wf[RollingDetectorViewWindow] = window
         if projection == 'cylinder_mantle_z':
@@ -606,9 +607,14 @@ def position_with_noisy_replicas(
     noise_dim = position_noise.dim
     size = position.size * replicas
     # "Paint" the short array of noise on top of the (replicated) position data.
-    noise = sc.concat(
-        [position_noise] * ceil(size / position_noise.size), dim=noise_dim
-    )[:size].fold(dim=noise_dim, sizes={'replica': replicas, **position.sizes})
+    noise = (
+        sc.broadcast(
+            position_noise,
+            sizes={'dummy': ceil(size / position_noise.size), **position_noise.sizes},
+        )
+        .flatten(to=noise_dim)[:size]
+        .fold(dim=noise_dim, sizes={'replica': replicas, **position.sizes})
+    )
     return sc.concat([position, noise + position], dim='replica')
 
 

ess/reduce/nexus/types.py

@@ -198,19 +198,15 @@ NeXusDetectorName = NeXusName[snx.NXdetector]
 """Name of a detector (bank) in a NeXus file."""
 
 
-class NeXusComponent(
-    sciline.ScopeTwoParams[Component, RunType, sc.DataGroup], sc.DataGroup
-):
+class NeXusComponent(sciline.Scope[Component, RunType, sc.DataGroup], sc.DataGroup):
     """Raw data from a NeXus component."""
 
 
-class AllNeXusComponents(
-    sciline.ScopeTwoParams[Component, RunType, sc.DataGroup], sc.DataGroup
-):
+class AllNeXusComponents(sciline.Scope[Component, RunType, sc.DataGroup], sc.DataGroup):
     """Raw data from all NeXus components of one class."""
 
 
-class NeXusData(sciline.ScopeTwoParams[Component, RunType, sc.DataArray], sc.DataArray):
+class NeXusData(sciline.Scope[Component, RunType, sc.DataArray], sc.DataArray):
     """
     Data array loaded from an NXevent_data or NXdata group.
 
@@ -218,7 +214,7 @@ class NeXusData(sciline.ScopeTwoParams[Component, RunType, sc.DataArray], sc.Dat
     """
 
 
-class Position(sciline.ScopeTwoParams[Component, RunType, sc.Variable], sc.Variable):
+class Position(sciline.Scope[Component, RunType, sc.Variable], sc.Variable):
     """Position of a component such as source, sample, monitor, or detector."""
 
 
@@ -227,7 +223,7 @@ class DetectorPositionOffset(sciline.Scope[RunType, sc.Variable], sc.Variable):
 
 
 class MonitorPositionOffset(
-    sciline.ScopeTwoParams[RunType, MonitorType, sc.Variable], sc.Variable
+    sciline.Scope[RunType, MonitorType, sc.Variable], sc.Variable
 ):
     """Offset for the monitor position, added to base position."""
 
@@ -241,7 +237,7 @@ class CalibratedBeamline(sciline.Scope[RunType, sc.DataArray], sc.DataArray):
 
 
 class CalibratedMonitor(
-    sciline.ScopeTwoParams[RunType, MonitorType, sc.DataArray], sc.DataArray
+    sciline.Scope[RunType, MonitorType, sc.DataArray], sc.DataArray
 ):
     """Calibrated data from a monitor."""
 
@@ -250,9 +246,7 @@ class DetectorData(sciline.Scope[RunType, sc.DataArray], sc.DataArray):
     """Calibrated detector merged with neutron event or histogram data."""
 
 
-class MonitorData(
-    sciline.ScopeTwoParams[RunType, MonitorType, sc.DataArray], sc.DataArray
-):
+class MonitorData(sciline.Scope[RunType, MonitorType, sc.DataArray], sc.DataArray):
     """Calibrated monitor merged with neutron event or histogram data."""
 
 
@@ -314,7 +308,7 @@ class NeXusDataLocationSpec(NeXusLocationSpec, Generic[Component, RunType]):
 
 
 class NeXusTransformationChain(
-    sciline.ScopeTwoParams[Component, RunType, snx.TransformationChain],
+    sciline.Scope[Component, RunType, snx.TransformationChain],
     snx.TransformationChain,
 ): ...
 

ess/reduce/time_of_flight/eto_to_tof.py

@@ -14,6 +14,10 @@ import scipp as sc
 from scipp._scipp.core import _bins_no_validate
 from scippneutron._utils import elem_unit
 
+try:
+    from .interpolator_numba import Interpolator as InterpolatorImpl
+except ImportError:
+    from .interpolator_scipy import Interpolator as InterpolatorImpl
 from .to_events import to_events
 from .types import (
     DistanceResolution,
@@ -286,12 +290,6 @@ def compute_tof_lookup_table(
 
 class TofInterpolator:
     def __init__(self, lookup: sc.DataArray, distance_unit: str, time_unit: str):
-        from scipy.interpolate import RegularGridInterpolator
-
-        # TODO: to make use of multi-threading, we could write our own interpolator.
-        # This should be simple enough as we are making the bins linspace, so computing
-        # bin indices is fast.
-
         self._distance_unit = distance_unit
         self._time_unit = time_unit
 
@@ -307,20 +305,26 @@ class TofInterpolator:
         # monotonic, so we cannot use e.g. [-0.5, 0.5, 0.5, 1.5] in the case of
         # pulse_stride=2. Instead we use [-0.25, 0.25, 0.75, 1.25].
         base_grid = np.arange(float(lookup.sizes["pulse"]))
-        self._interpolator = RegularGridInterpolator(
-            (
-                np.sort(np.concatenate([base_grid - 0.25, base_grid + 0.25])),
-                lookup.coords["distance"].to(unit=distance_unit, copy=False).values,
-                lookup.coords["event_time_offset"]
-                .to(unit=self._time_unit, copy=False)
-                .values,
-            ),
-            np.repeat(
+        self._pulse_edges = np.sort(
+            np.concatenate([base_grid - 0.25, base_grid + 0.25])
+        )
+
+        self._time_edges = (
+            lookup.coords["event_time_offset"]
+            .to(unit=self._time_unit, copy=False)
+            .values
+        )
+        self._distance_edges = (
+            lookup.coords["distance"].to(unit=distance_unit, copy=False).values
+        )
+
+        self._interpolator = InterpolatorImpl(
+            time_edges=self._time_edges,
+            distance_edges=self._distance_edges,
+            pulse_edges=self._pulse_edges,
+            values=np.repeat(
                 lookup.data.to(unit=self._time_unit, copy=False).values, 2, axis=0
             ),
-            method="linear",
-            bounds_error=False,
-            fill_value=np.nan,
         )
 
     def __call__(
@@ -348,24 +352,12 @@ class TofInterpolator:
         pulse_index = pulse_index.values
         ltotal = ltotal.values
         event_time_offset = event_time_offset.values
-        # Check bounds for pulse_index and ltotal.
-        # We do not check the event_time_offset dimension because histogrammed monitors
-        # often have binning which can be anything (does not necessarily stop at 71ms).
-        # Raising an error here would be too restrictive, and warnings would add noise
-        # to the workflows.
-        for i, (name, values) in enumerate(
-            {'pulse_index': pulse_index, 'ltotal': ltotal}.items()
-        ):
-            vmin = self._interpolator.grid[i][0]
-            vmax = self._interpolator.grid[i][-1]
-            if np.any(values < vmin) or np.any(values > vmax):
-                raise ValueError(
-                    "Some requested values are outside of lookup table bounds for "
-                    f"axis {i}: {name}, min: {vmin}, max: {vmax}."
-                )
+
         return sc.array(
             dims=out_dims,
-            values=self._interpolator((pulse_index, ltotal, event_time_offset)),
+            values=self._interpolator(
+                times=event_time_offset, distances=ltotal, pulse_indices=pulse_index
+            ),
             unit=self._time_unit,
         )
 
@@ -379,7 +371,8 @@ def _time_of_flight_data_histogram(
     # In NeXus, 'time_of_flight' is the canonical name in NXmonitor, but in some files,
     # it may be called 'tof'.
     key = next(iter(set(da.coords.keys()) & {"time_of_flight", "tof"}))
-    eto_unit = da.coords[key].unit
+    raw_eto = da.coords[key].to(dtype=float, copy=False)
+    eto_unit = raw_eto.unit
     pulse_period = pulse_period.to(unit=eto_unit)
 
     # In histogram mode, because there is a wrap around at the end of the pulse, we
@@ -387,9 +380,7 @@ def _time_of_flight_data_histogram(
     # with one finite left edge and a NaN right edge (it becomes NaN as it would be
     # outside the range of the lookup table).
     new_bins = sc.sort(
-        sc.concat(
-            [da.coords[key], sc.scalar(0.0, unit=eto_unit), pulse_period], dim=key
-        ),
+        sc.concat([raw_eto, sc.scalar(0.0, unit=eto_unit), pulse_period], dim=key),
         key=key,
     )
     rebinned = da.rebin({key: new_bins})
@@ -416,7 +407,11 @@ def _time_of_flight_data_histogram(
     interp = TofInterpolator(lookup, distance_unit=ltotal.unit, time_unit=eto_unit)
 
     # Compute time-of-flight of the bin edges using the interpolator
-    tofs = interp(pulse_index=pulse_index, ltotal=ltotal, event_time_offset=etos)
+    tofs = interp(
+        pulse_index=pulse_index,
+        ltotal=ltotal.broadcast(sizes=etos.sizes),
+        event_time_offset=etos,
+    )
 
     return rebinned.assign_coords(tof=tofs)
 
@@ -487,7 +482,7 @@ def _time_of_flight_data_events(
     pulse_stride: int,
     pulse_stride_offset: int,
 ) -> sc.DataArray:
-    etos = da.bins.coords["event_time_offset"]
+    etos = da.bins.coords["event_time_offset"].to(dtype=float, copy=False)
     eto_unit = elem_unit(etos)
 
     # Create linear interpolator
@@ -621,17 +616,21 @@ def resample_tof_data(da: TofData) -> ResampledTofData:
         Histogrammed data with the time-of-flight coordinate.
     """
     dim = next(iter(set(da.dims) & {"time_of_flight", "tof"}))
-    events = to_events(da.rename_dims({dim: "tof"}), "event")
+    data = da.rename_dims({dim: "tof"}).drop_coords(
+        [name for name in da.coords if name != "tof"]
+    )
+    events = to_events(data, "event")
 
     # Define a new bin width, close to the original bin width.
     # TODO: this could be a workflow parameter
     coord = da.coords["tof"]
     bin_width = (coord[dim, 1:] - coord[dim, :-1]).nanmedian()
     rehist = events.hist(tof=bin_width)
-    for key, var in da.coords.items():
-        if dim not in var.dims:
-            rehist.coords[key] = var
-    return ResampledTofData(rehist)
+    return ResampledTofData(
+        rehist.assign_coords(
+            {key: var for key, var in da.coords.items() if dim not in var.dims}
+        )
+    )
 
 
 def default_parameters() -> dict:

ess/reduce/time_of_flight/fakes.py

@@ -23,6 +23,7 @@ class FakeBeamline:
         events_per_pulse: int = 200000,
         seed: int | None = None,
         source: Callable | None = None,
+        source_position: sc.Variable | None = None,
     ):
         import math
 
@@ -32,6 +33,8 @@ class FakeBeamline:
         self.frequency = pulse.frequency
         self.npulses = math.ceil((run_length * self.frequency).to(unit="").value)
         self.events_per_pulse = events_per_pulse
+        if source_position is None:
+            source_position = sc.vector([0, 0, 0], unit='m')
 
         # Create a source
         if source is None:
@@ -54,7 +57,7 @@ class FakeBeamline:
                 open=ch.slit_begin,
                 close=ch.slit_end,
                 phase=abs(ch.phase),
-                distance=ch.axle_position.fields.z,
+                distance=sc.norm(ch.axle_position - source_position),
                 name=name,
             )
             for name, ch in choppers.items()
@@ -117,3 +120,7 @@ def pulse_skipping_choppers():
             radius=sc.scalar(30.0, unit="cm"),
         ),
     }
+
+
+def source_position():
+    return sc.vector([0, 0, 0], unit='m')

ess/reduce/time_of_flight/interpolator_numba.py

@@ -0,0 +1,165 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright (c) 2025 Scipp contributors (https://github.com/scipp)
+import numpy as np
+from numba import njit, prange
+
+
+@njit(boundscheck=False, cache=True, fastmath=False, parallel=True)
+def interpolate(
+    x: np.ndarray,
+    y: np.ndarray,
+    z: np.ndarray,
+    values: np.ndarray,
+    xp: np.ndarray,
+    yp: np.ndarray,
+    zp: np.ndarray,
+    fill_value: float,
+    out: np.ndarray,
+):
+    """
+    Linear interpolation of data on a 3D regular grid.
+
+    Parameters
+    ----------
+    x:
+        1D array of grid edges along the x-axis. They must be linspaced.
+    y:
+        1D array of grid edges along the y-axis. They must be linspaced.
+    z:
+        1D array of grid edges along the z-axis. They must be linspaced.
+    values:
+        3D array of values on the grid. The shape must be (nz, ny, nx).
+    xp:
+        1D array of x-coordinates where to interpolate (size N).
+    yp:
+        1D array of y-coordinates where to interpolate (size N).
+    zp:
+        1D array of z-coordinates where to interpolate (size N).
+    fill_value:
+        Value to use for points outside of the grid.
+    out:
+        1D array where the interpolated values will be stored (size N).
+    """
+    if not (len(xp) == len(yp) == len(zp) == len(out)):
+        raise ValueError("Interpolator: all input arrays must have the same size.")
+
+    nx = len(x)
+    ny = len(y)
+    nz = len(z)
+    npoints = len(xp)
+    xmin = x[0]
+    xmax = x[nx - 1]
+    ymin = y[0]
+    ymax = y[ny - 1]
+    zmin = z[0]
+    zmax = z[nz - 1]
+    dx = x[1] - xmin
+    dy = y[1] - ymin
+    dz = z[1] - zmin
+
+    one_over_dx = 1.0 / dx
+    one_over_dy = 1.0 / dy
+    one_over_dz = 1.0 / dz
+    norm = one_over_dx * one_over_dy * one_over_dz
+
+    for i in prange(npoints):
+        xx = xp[i]
+        yy = yp[i]
+        zz = zp[i]
+
+        if (
+            (xx < xmin)
+            or (xx > xmax)
+            or (yy < ymin)
+            or (yy > ymax)
+            or (zz < zmin)
+            or (zz > zmax)
+        ):
+            out[i] = fill_value
+
+        else:
+            ix = nx - 2 if xx == xmax else int((xx - xmin) * one_over_dx)
+            iy = ny - 2 if yy == ymax else int((yy - ymin) * one_over_dy)
+            iz = nz - 2 if zz == zmax else int((zz - zmin) * one_over_dz)
+
+            x1 = x[ix]
+            x2 = x[ix + 1]
+            y1 = y[iy]
+            y2 = y[iy + 1]
+            z1 = z[iz]
+            z2 = z[iz + 1]
+
+            a111 = values[iz, iy, ix]
+            a211 = values[iz, iy, ix + 1]
+            a121 = values[iz, iy + 1, ix]
+            a221 = values[iz, iy + 1, ix + 1]
+            a112 = values[iz + 1, iy, ix]
+            a212 = values[iz + 1, iy, ix + 1]
+            a122 = values[iz + 1, iy + 1, ix]
+            a222 = values[iz + 1, iy + 1, ix + 1]
+
+            x2mxx = x2 - xx
+            xxmx1 = xx - x1
+            y2myy = y2 - yy
+            yymy1 = yy - y1
+            out[i] = (
+                (z2 - zz)
+                * (
+                    y2myy * (x2mxx * a111 + xxmx1 * a211)
+                    + yymy1 * (x2mxx * a121 + xxmx1 * a221)
+                )
+                + (zz - z1)
+                * (
+                    y2myy * (x2mxx * a112 + xxmx1 * a212)
+                    + yymy1 * (x2mxx * a122 + xxmx1 * a222)
+                )
+            ) * norm
+
+
+class Interpolator:
+    def __init__(
+        self,
+        time_edges: np.ndarray,
+        distance_edges: np.ndarray,
+        pulse_edges: np.ndarray,
+        values: np.ndarray,
+        fill_value: float = np.nan,
+    ):
+        """
+        Interpolator for 3D regular grid data (Numba implementation).
+
+        Parameters
+        ----------
+        time_edges:
+            1D array of time edges.
+        distance_edges:
+            1D array of distance edges.
+        pulse_edges:
+            1D array of pulse edges.
+        values:
+            3D array of values on the grid. The shape must be (nz, ny, nx).
+        fill_value:
+            Value to use for points outside of the grid.
+        """
+        self.time_edges = time_edges
+        self.distance_edges = distance_edges
+        self.pulse_edges = pulse_edges
+        self.values = values
+        self.fill_value = fill_value
+
+    def __call__(
+        self, times: np.ndarray, distances: np.ndarray, pulse_indices: np.ndarray
+    ) -> np.ndarray:
+        out = np.empty_like(times)
+        interpolate(
+            x=self.time_edges,
+            y=self.distance_edges,
+            z=self.pulse_edges,
+            values=self.values,
+            xp=times,
+            yp=distances,
+            zp=pulse_indices,
+            fill_value=self.fill_value,
+            out=out,
+        )
+        return out

ess/reduce/time_of_flight/interpolator_scipy.py

@@ -0,0 +1,60 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright (c) 2025 Scipp contributors (https://github.com/scipp)
+
+import numpy as np
+
+
+class Interpolator:
+    def __init__(
+        self,
+        time_edges: np.ndarray,
+        distance_edges: np.ndarray,
+        pulse_edges: np.ndarray,
+        values: np.ndarray,
+        method: str = "linear",
+        bounds_error: bool = False,
+        fill_value: float = np.nan,
+        **kwargs,
+    ):
+        """
+        Interpolator for 3D regular grid data (SciPy implementation).
+
+        Parameters
+        ----------
+        time_edges:
+            1D array of time edges.
+        distance_edges:
+            1D array of distance edges.
+        pulse_edges:
+            1D array of pulse edges.
+        values:
+            3D array of values on the grid. The shape must be (nz, ny, nx).
+        method:
+            Method of interpolation. Default is "linear".
+        bounds_error:
+            If True, when interpolated values are requested outside of the domain,
+            a ValueError is raised. If False, fill_value is used.
+        fill_value:
+            Value to use for points outside of the grid.
+        kwargs:
+            Additional arguments to pass to scipy.interpolate.RegularGridInterpolator.
+        """
+        from scipy.interpolate import RegularGridInterpolator
+
+        self._interp = RegularGridInterpolator(
+            (
+                pulse_edges,
+                distance_edges,
+                time_edges,
+            ),
+            values,
+            method=method,
+            bounds_error=bounds_error,
+            fill_value=fill_value,
+            **kwargs,
+        )
+
+    def __call__(
+        self, times: np.ndarray, distances: np.ndarray, pulse_indices: np.ndarray
+    ) -> np.ndarray:
+        return self._interp((pulse_indices, distances, times))

ess/reduce/time_of_flight/simulation.py

@@ -9,7 +9,9 @@ from .types import SimulationResults
 
 
 def simulate_beamline(
+    *,
     choppers: Mapping[str, DiskChopper],
+    source_position: sc.Variable,
     neutrons: int = 1_000_000,
     pulses: int = 1,
     seed: int | None = None,
@@ -25,6 +27,9 @@ def simulate_beamline(
         A dict of DiskChopper objects representing the choppers in the beamline. See
         https://scipp.github.io/scippneutron/user-guide/chopper/processing-nexus-choppers.html#Build-DiskChopper
         for more information.
+    source_position:
+        A scalar variable with ``dtype=vector3`` that defines the source position.
+        Must be in the same coordinate system as the choppers' axle positions.
     neutrons:
         Number of neutrons to simulate.
     pulses:
@@ -45,7 +50,9 @@ def simulate_beamline(
             open=ch.slit_begin,
             close=ch.slit_end,
             phase=abs(ch.phase),
-            distance=ch.axle_position.fields.z,
+            distance=sc.norm(
+                ch.axle_position - source_position.to(unit=ch.axle_position.unit)
+            ),
             name=name,
         )
         for name, ch in choppers.items()
@@ -54,7 +61,7 @@ def simulate_beamline(
     if not tof_choppers:
         events = source.data.squeeze().flatten(to='event')
         return SimulationResults(
-            time_of_arrival=events.coords["time"],
+            time_of_arrival=events.coords["birth_time"],
             speed=events.coords["speed"],
             wavelength=events.coords["wavelength"],
             weight=events.data,

ess/reduce/time_of_flight/to_events.py

@@ -34,7 +34,7 @@ def to_events(
     rng = np.random.default_rng()
     event_coords = {}
     edge_dims = []
-    midp_dims = set()
+    midp_dims = set(da.dims)
     midp_coord_names = []
     # Separate bin-edge and midpoints coords
     for name in da.coords:
@@ -43,9 +43,9 @@ def to_events(
         if is_edges:
             if name in dims:
                 edge_dims.append(name)
+                midp_dims -= {name}
         else:
             midp_coord_names.append(name)
-            midp_dims.update(set(dims))
 
     edge_sizes = {dim: da.sizes[da.coords[dim].dim] for dim in edge_dims}
     for dim in edge_dims:

{essreduce-25.3.1.dist-info → essreduce-25.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: essreduce
-Version: 25.3.1
+Version: 25.4.1
 Summary: Common data reduction tools for the ESS facility
 Author: Scipp contributors
 License: BSD 3-Clause License
@@ -51,16 +51,18 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: sciline>=24.06.2
+Requires-Dist: sciline>=25.04.1
 Requires-Dist: scipp>=25.01.0
 Requires-Dist: scippneutron>=25.02.0
 Requires-Dist: scippnexus>=24.11.0
 Provides-Extra: test
 Requires-Dist: ipywidgets; extra == "test"
+Requires-Dist: numba; extra == "test"
 Requires-Dist: pooch; extra == "test"
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: scipy>=1.7.0; extra == "test"
 Requires-Dist: tof>=25.01.2; extra == "test"
+Dynamic: license-file
 
 [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg)](CODE_OF_CONDUCT.md)
 [![PyPI badge](http://img.shields.io/pypi/v/essreduce.svg)](https://pypi.python.org/pypi/essreduce)

{essreduce-25.3.1.dist-info → essreduce-25.4.1.dist-info}/RECORD

@@ -8,21 +8,23 @@ ess/reduce/ui.py,sha256=zmorAbDwX1cU3ygDT--OP58o0qU7OBcmJz03jPeYSLA,10884
 ess/reduce/uncertainty.py,sha256=LR4O6ApB6Z-W9gC_XW0ajupl8yFG-du0eee1AX_R-gk,6990
 ess/reduce/workflow.py,sha256=sL34T_2Cjl_8iFlegujxI9VyOUwo6erVC8pOXnfWgYw,3060
 ess/reduce/live/__init__.py,sha256=jPQVhihRVNtEDrE20PoKkclKV2aBF1lS7cCHootgFgI,204
-ess/reduce/live/raw.py,sha256=hyWkDJ0WYE2TS12dVxpRUh6RkzcUJL0bVDd4JjTidi0,24217
+ess/reduce/live/raw.py,sha256=66qV0G2rP8gK5tXuk-syTlDLE2jT3ehfmSnET7Xzfd0,24392
 ess/reduce/live/roi.py,sha256=Hs-pW98k41WU6Kl3UQ41kQawk80c2QNOQ_WNctLzDPE,3795
 ess/reduce/live/workflow.py,sha256=bsbwvTqPhRO6mC__3b7MgU7DWwAnOvGvG-t2n22EKq8,4285
 ess/reduce/nexus/__init__.py,sha256=59bxKkNYg8DYcSykNvH6nCa5SYchJC4SbgZEKhkNdYc,967
 ess/reduce/nexus/_nexus_loader.py,sha256=5N48AMJx1AaFZb6WZPPbVKUlXyFMVVtZrn7Bae57O3A,19842
 ess/reduce/nexus/json_generator.py,sha256=ME2Xn8L7Oi3uHJk9ZZdCRQTRX-OV_wh9-DJn07Alplk,2529
 ess/reduce/nexus/json_nexus.py,sha256=QrVc0p424nZ5dHX9gebAJppTw6lGZq9404P_OFl1giA,10282
-ess/reduce/nexus/types.py,sha256=15XcHbNbOfnAYjWXzzKyYDVNyNixRnP0hJ-Q2duwMWE,9896
+ess/reduce/nexus/types.py,sha256=vTQD4oQ5JKBHAYy9LWFICSo-dhVi3wX5IinMgjRDtF8,9806
 ess/reduce/nexus/workflow.py,sha256=EiD6-58eGwoN5fbo47UTZy_oYFitCbwlIH-xqDOSp4c,24326
 ess/reduce/scripts/grow_nexus.py,sha256=hET3h06M0xlJd62E3palNLFvJMyNax2kK4XyJcOhl-I,3387
 ess/reduce/time_of_flight/__init__.py,sha256=TSHfyoROwFhM2k3jHzamw3zeb0OQOaiuvgCgDEPEQ_g,1097
-ess/reduce/time_of_flight/eto_to_tof.py,sha256=4itpEB2Vb5-6HvgFfKIV0_-l8zS4UJgB5uBp12L6cls,25827
-ess/reduce/time_of_flight/fakes.py,sha256=rlBgceFVbHIhP_xPyUzYVf-2wEu--G8hA-kxPzAnPbM,4236
-ess/reduce/time_of_flight/simulation.py,sha256=CireE9m9kFbUXhGUeY2L3SoMy7kpqopxKj__h4tSKzo,2614
-ess/reduce/time_of_flight/to_events.py,sha256=_5CcUOWvguDcK8uo2pPZWzXnWoiZhC1w-zF8xysaIvU,4339
+ess/reduce/time_of_flight/eto_to_tof.py,sha256=Nq2gx7aejoZ_ExLTr9I6KZMqDxCKAx1PpGHslpNXkKU,25271
+ess/reduce/time_of_flight/fakes.py,sha256=REyHkJsSSq2_l5UOtpsv2aKkhCuro_i3KpVsxxITbW0,4470
+ess/reduce/time_of_flight/interpolator_numba.py,sha256=AgB2R8iw-IOb3YXLWTQVBflhWq5qgb7aqfvDExwLRW8,4682
+ess/reduce/time_of_flight/interpolator_scipy.py,sha256=sRJj2ncBiUMv6g9h-MJzI9xyY0Ir0degpAv6FIeSMBw,1834
+ess/reduce/time_of_flight/simulation.py,sha256=cIF_nWkLQlcWUCW2_wvWBU2ocg_8CSfOnfkoqdLdUgs,2923
+ess/reduce/time_of_flight/to_events.py,sha256=w9mHpnWd3vwN2ouob-GK_1NPrTjCaOzPuC2QuEey-m0,4342
 ess/reduce/time_of_flight/types.py,sha256=Iv1XGLbrZ9bD4CPAVhsIPkAaB46YC7l7yf5XweljLqk,5047
 ess/reduce/widgets/__init__.py,sha256=SoSHBv8Dc3QXV9HUvPhjSYWMwKTGYZLpsWwsShIO97Q,5325
 ess/reduce/widgets/_base.py,sha256=_wN3FOlXgx_u0c-A_3yyoIH-SdUvDENGgquh9S-h5GI,4852
@@ -36,9 +38,9 @@ ess/reduce/widgets/_spinner.py,sha256=2VY4Fhfa7HMXox2O7UbofcdKsYG-AJGrsgGJB85nDX
 ess/reduce/widgets/_string_widget.py,sha256=iPAdfANyXHf-nkfhgkyH6gQDklia0LebLTmwi3m-iYQ,1482
 ess/reduce/widgets/_switchable_widget.py,sha256=fjKz99SKLhIF1BLgGVBSKKn3Lu_jYBwDYGeAjbJY3Q8,2390
 ess/reduce/widgets/_vector_widget.py,sha256=aTaBqCFHZQhrIoX6-sSqFWCPePEW8HQt5kUio8jP1t8,1203
-essreduce-25.3.1.dist-info/LICENSE,sha256=nVEiume4Qj6jMYfSRjHTM2jtJ4FGu0g-5Sdh7osfEYw,1553
-essreduce-25.3.1.dist-info/METADATA,sha256=xzclNXH4P_JVuujgIOjGtTw_7OQtH5s2e4_FlwUWDBs,3708
-essreduce-25.3.1.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-essreduce-25.3.1.dist-info/entry_points.txt,sha256=PMZOIYzCifHMTe4pK3HbhxUwxjFaZizYlLD0td4Isb0,66
-essreduce-25.3.1.dist-info/top_level.txt,sha256=0JxTCgMKPLKtp14wb1-RKisQPQWX7i96innZNvHBr-s,4
-essreduce-25.3.1.dist-info/RECORD,,
+essreduce-25.4.1.dist-info/licenses/LICENSE,sha256=nVEiume4Qj6jMYfSRjHTM2jtJ4FGu0g-5Sdh7osfEYw,1553
+essreduce-25.4.1.dist-info/METADATA,sha256=_E84IwG_gnTsMoorflvf6T4K5oJB7IjpsUUTB4bhVh8,3768
+essreduce-25.4.1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+essreduce-25.4.1.dist-info/entry_points.txt,sha256=PMZOIYzCifHMTe4pK3HbhxUwxjFaZizYlLD0td4Isb0,66
+essreduce-25.4.1.dist-info/top_level.txt,sha256=0JxTCgMKPLKtp14wb1-RKisQPQWX7i96innZNvHBr-s,4
+essreduce-25.4.1.dist-info/RECORD,,

{essreduce-25.3.1.dist-info → essreduce-25.4.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (76.0.0)
+Generator: setuptools (78.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any