essreduce 25.11.6__py3-none-any.whl → 25.12.0__py3-none-any.whl

ess/reduce/live/raw.py

@@ -434,7 +434,9 @@ class RollingDetectorView(Detector):
             indices = sc.cumsum(indices, mode='exclusive')
             if self._projection is not None:
                 indices = self._projection(indices)
-        return roi.ROIFilter(indices=indices, norm=norm)
+        return roi.ROIFilter(
+            indices=indices, norm=norm, spatial_dims=self._detector_number.dims
+        )
 
     def transform_weights(
         self,

ess/reduce/live/roi.py

@@ -4,10 +4,16 @@
 
 from __future__ import annotations
 
+from collections.abc import Sequence
 from typing import TypeVar
 
 import numpy as np
 import scipp as sc
+from matplotlib.path import Path
+
+# Type for polygon vertices: either scipp Variable (coord-based) or sequence of
+# floats (index-based)
+PolygonVertices = sc.Variable | Sequence[float]
 
 
 def select_indices_in_intervals(
@@ -40,11 +46,137 @@ def select_indices_in_intervals(
     return indices.rename_dims({indices.dim: out_dim})
 
 
+def _get_polygon_axis_data(
+    axis_name: str,
+    vertices: PolygonVertices,
+    indices: sc.DataArray,
+) -> tuple[np.ndarray, sc.Variable]:
+    """
+    Get polygon vertices and corresponding coordinates for one axis.
+
+    Parameters
+    ----------
+    axis_name:
+        Name of the axis (dimension or coordinate name).
+    vertices:
+        Polygon vertices for this axis - either a scipp Variable (coord-based)
+        or a sequence of floats (index-based).
+    indices:
+        DataArray with indices to select from.
+
+    Returns
+    -------
+    :
+        Tuple of (polygon_vertices_array, coordinate_values).
+    """
+    if isinstance(vertices, sc.Variable):
+        # Coord-based: use named coordinate from indices
+        if axis_name not in indices.coords:
+            raise KeyError(
+                f"Coordinate '{axis_name}' not found in indices. "
+                f"Available coordinates: {list(indices.coords.keys())}"
+            )
+        coords = indices.coords[axis_name]
+        if indices.coords.is_edges(axis_name):
+            coords = sc.midpoints(coords, dim=axis_name)
+        # Validate units match
+        if vertices.unit != coords.unit:
+            raise sc.UnitError(
+                f"Unit mismatch for '{axis_name}': "
+                f"polygon has unit '{vertices.unit}' "
+                f"but coordinates have unit '{coords.unit}'"
+            )
+        return vertices.values, coords
+    else:
+        # Index-based: use dimension indices as coordinates
+        if axis_name not in indices.sizes:
+            raise KeyError(
+                f"Dimension '{axis_name}' not found in indices. "
+                f"Available dimensions: {list(indices.dims)}"
+            )
+        # Create coordinate from dimension indices
+        coords = sc.arange(axis_name, indices.sizes[axis_name], dtype='float64')
+        return np.asarray(vertices, dtype='float64'), coords
+
+
+def select_indices_in_polygon(
+    polygon: dict[str, PolygonVertices],
+    indices: sc.DataArray,
+) -> sc.Variable:
+    """
+    Return subset of indices that fall within the polygon.
+
+    Parameters
+    ----------
+    polygon:
+        Polygon vertices as a dict mapping axis names to 1-D arrays of vertex
+        positions. Must contain exactly two entries. Each entry can be either:
+
+        - A scipp Variable for coordinate-based selection (uses named coordinates
+          from the indices DataArray, with unit validation)
+        - A sequence of floats for index-based selection (uses dimension indices
+          as coordinates, no unit handling)
+
+        The two axes can independently use either mode.
+    indices:
+        DataArray with indices to select from. For coordinate-based axes, must have
+        coordinates matching the axis names. For index-based axes, must have
+        dimensions matching the axis names.
+
+    Returns
+    -------
+    :
+        Variable with selected indices.
+    """
+    out_dim = 'index'
+
+    if len(polygon) != 2:
+        raise ValueError(
+            f"Polygon must have exactly two coordinate arrays, got {len(polygon)}"
+        )
+
+    # Get the two axis names from the polygon dict
+    axis_a, axis_b = polygon.keys()
+
+    # Get polygon vertices and coordinates for each axis
+    poly_a, a_coords = _get_polygon_axis_data(axis_a, polygon[axis_a], indices)
+    poly_b, b_coords = _get_polygon_axis_data(axis_b, polygon[axis_b], indices)
+
+    # Extract polygon vertices as 2D array
+    vertices_2d = np.column_stack([poly_a, poly_b])
+
+    # Broadcast coordinates to match indices shape and flatten
+    a_flat = sc.broadcast(a_coords, sizes=indices.sizes).values.flatten()
+    b_flat = sc.broadcast(b_coords, sizes=indices.sizes).values.flatten()
+    points = np.column_stack([a_flat, b_flat])
+
+    # Use matplotlib Path for point-in-polygon test
+    polygon_path = Path(vertices_2d)
+    mask = polygon_path.contains_points(points)
+
+    # Get indices that are inside the polygon
+    all_indices = indices.data.flatten(to=out_dim)
+
+    # Apply mask first, then concat if binned (mask is per-bin, not per-index)
+    sc_mask = sc.array(dims=[out_dim], values=mask)
+    selected = all_indices[sc_mask]
+
+    if selected.bins is not None:
+        selected = selected.bins.concat().value
+        selected = selected.rename_dims({selected.dim: out_dim})
+
+    return sc.array(dims=[out_dim], values=selected.values, dtype='int32', unit=None)
+
+
 T = TypeVar('T', sc.DataArray, sc.Variable)
 
 
 def apply_selection(
-    data: T, *, selection: sc.Variable, norm: float = 1.0
+    data: T,
+    *,
+    selection: sc.Variable,
+    norm: float = 1.0,
+    spatial_dims: tuple[str, ...] | None = None,
 ) -> tuple[T, sc.Variable]:
     """
     Apply selection to data.
@@ -58,6 +190,9 @@ def apply_selection(
     norm:
         Normalization factor to apply to the selected data. This is used for cases where
         indices may be selected multiple times.
+    spatial_dims:
+        Dimensions to flatten into 'detector_number'. If None, all dims are flattened.
+        For dense data like (time, x, y), pass ('x', 'y') to preserve time.
 
     Returns
     -------
@@ -65,16 +200,25 @@ def apply_selection(
         Filtered data and scale factor.
     """
     indices, counts = np.unique(selection.values, return_counts=True)
-    if data.ndim != 1:
-        data = data.flatten(to='detector_number')
-    scale = sc.array(dims=[data.dim], values=counts) / norm
-    return data[indices], scale
+    if spatial_dims is None:
+        dims_to_flatten = data.dims
+    else:
+        dims_to_flatten = tuple(d for d in data.dims if d in spatial_dims)
+    if len(dims_to_flatten) > 0 and data.dims != ('detector_number',):
+        data = data.flatten(dims=dims_to_flatten, to='detector_number')
+    scale = sc.array(dims=['detector_number'], values=counts) / norm
+    return data['detector_number', indices], scale
 
 
 class ROIFilter:
     """Filter for selecting a region of interest (ROI)."""
 
-    def __init__(self, indices: sc.Variable | sc.DataArray, norm: float = 1.0) -> None:
+    def __init__(
+        self,
+        indices: sc.Variable | sc.DataArray,
+        norm: float = 1.0,
+        spatial_dims: tuple[str, ...] | None = None,
+    ) -> None:
         """
         Create a new ROI filter.
 
@@ -86,15 +230,50 @@ class ROIFilter:
             2-D array. Each element in the array may correspond to a single index (when
             there is no projection) or a list of indices that were projected into an
             output pixel.
+        spatial_dims:
+            Dimensions of the detector that should be flattened when applying the
+            filter. If None, defaults to indices.dims. For projections where indices
+            represent a subset of the detector, this should be set to the full
+            detector dimensions.
         """
         self._indices = indices
         self._selection = sc.array(dims=['index'], values=[])
         self._norm = norm
+        self._spatial_dims = spatial_dims if spatial_dims is not None else indices.dims
 
     def set_roi_from_intervals(self, intervals: sc.DataGroup) -> None:
         """Set the ROI from (typically 1 or 2) intervals."""
         self._selection = select_indices_in_intervals(intervals, self._indices)
 
+    def set_roi_from_polygon(self, polygon: dict[str, PolygonVertices]) -> None:
+        """
+        Set the ROI from polygon vertices.
+
+        Parameters
+        ----------
+        polygon:
+            Polygon vertices as a dict mapping axis names to 1-D arrays of vertex
+            positions. Must contain exactly two entries. Each entry can be either:
+
+            - A scipp Variable for coordinate-based selection (uses named coordinates
+              from the indices DataArray, with unit validation)
+            - A sequence of floats for index-based selection (uses dimension indices
+              as coordinates, no unit handling)
+
+            The two axes can independently use either mode.
+        """
+        if not isinstance(self._indices, sc.DataArray):
+            raise TypeError("Polygon ROI requires indices to be a DataArray")
+        self._selection = select_indices_in_polygon(
+            polygon=polygon,
+            indices=self._indices,
+        )
+
+    @property
+    def spatial_dims(self) -> tuple[str, ...]:
+        """Dimensions that define the spatial extent of the ROI."""
+        return self._spatial_dims
+
     def apply(self, data: T) -> tuple[T, sc.Variable]:
         """
         Apply the ROI filter to data.
@@ -113,4 +292,9 @@ class ROIFilter:
         :
             Filtered data and scale factor.
         """
-        return apply_selection(data, selection=self._selection, norm=self._norm)
+        return apply_selection(
+            data,
+            selection=self._selection,
+            norm=self._norm,
+            spatial_dims=self.spatial_dims,
+        )

ess/reduce/time_of_flight/eto_to_tof.py

@@ -96,14 +96,14 @@ class TofInterpolator:
 
 
 def _time_of_flight_data_histogram(
-    da: sc.DataArray, lookup: sc.DataArray, ltotal: sc.Variable
+    da: sc.DataArray, lookup: TimeOfFlightLookupTable, ltotal: sc.Variable
 ) -> sc.DataArray:
     # In NeXus, 'time_of_flight' is the canonical name in NXmonitor, but in some files,
     # it may be called 'tof' or 'frame_time'.
     key = next(iter(set(da.coords.keys()) & {"time_of_flight", "tof", "frame_time"}))
     raw_eto = da.coords[key].to(dtype=float, copy=False)
     eto_unit = raw_eto.unit
-    pulse_period = lookup.coords["pulse_period"].to(unit=eto_unit)
+    pulse_period = lookup.pulse_period.to(unit=eto_unit)
 
     # In histogram mode, because there is a wrap around at the end of the pulse, we
     # need to insert a bin edge at that exact location to avoid having the last bin
@@ -117,7 +117,9 @@ def _time_of_flight_data_histogram(
     etos = rebinned.coords[key]
 
     # Create linear interpolator
-    interp = TofInterpolator(lookup, distance_unit=ltotal.unit, time_unit=eto_unit)
+    interp = TofInterpolator(
+        lookup.array, distance_unit=ltotal.unit, time_unit=eto_unit
+    )
 
     # Compute time-of-flight of the bin edges using the interpolator
     tofs = interp(
@@ -199,7 +201,7 @@ def _guess_pulse_stride_offset(
 
 def _prepare_tof_interpolation_inputs(
     da: sc.DataArray,
-    lookup: sc.DataArray,
+    lookup: TimeOfFlightLookupTable,
     ltotal: sc.Variable,
     pulse_stride_offset: int | None,
 ) -> dict:
@@ -227,15 +229,17 @@ def _prepare_tof_interpolation_inputs(
     eto_unit = elem_unit(etos)
 
     # Create linear interpolator
-    interp = TofInterpolator(lookup, distance_unit=ltotal.unit, time_unit=eto_unit)
+    interp = TofInterpolator(
+        lookup.array, distance_unit=ltotal.unit, time_unit=eto_unit
+    )
 
     # Operate on events (broadcast distances to all events)
     ltotal = sc.bins_like(etos, ltotal).bins.constituents["data"]
     etos = etos.bins.constituents["data"]
 
     pulse_index = None
-    pulse_period = lookup.coords["pulse_period"].to(unit=eto_unit)
-    pulse_stride = lookup.coords["pulse_stride"].value
+    pulse_period = lookup.pulse_period.to(unit=eto_unit)
+    pulse_stride = lookup.pulse_stride
 
     if pulse_stride > 1:
         # Compute a pulse index for every event: it is the index of the pulse within a
@@ -291,7 +295,7 @@ def _prepare_tof_interpolation_inputs(
 
 def _time_of_flight_data_events(
     da: sc.DataArray,
-    lookup: sc.DataArray,
+    lookup: TimeOfFlightLookupTable,
     ltotal: sc.Variable,
     pulse_stride_offset: int | None,
 ) -> sc.DataArray:
@@ -375,7 +379,7 @@ def monitor_ltotal_from_straight_line_approximation(
 
 def _compute_tof_data(
     da: sc.DataArray,
-    lookup: sc.DataArray,
+    lookup: TimeOfFlightLookupTable,
     ltotal: sc.Variable,
     pulse_stride_offset: int,
 ) -> sc.DataArray:
@@ -503,7 +507,7 @@ def detector_time_of_arrival_data(
     result = detector_data.bins.assign_coords(
         toa=sc.bins(**parts, validate_indices=False)
     )
-    return result
+    return ToaDetector[RunType](result)
 
 
 def providers() -> tuple[Callable]:

ess/reduce/time_of_flight/fakes.py

@@ -48,20 +48,13 @@ class FakeBeamline:
             self.source = source(pulses=self.npulses)
 
         # Convert the choppers to tof.Chopper
-        self.choppers = [
-            tof_pkg.Chopper(
-                frequency=abs(ch.frequency),
-                direction=tof_pkg.AntiClockwise
-                if (ch.frequency.value > 0.0)
-                else tof_pkg.Clockwise,
-                open=ch.slit_begin,
-                close=ch.slit_end,
-                phase=ch.phase if ch.frequency.value > 0.0 else -ch.phase,
-                distance=sc.norm(ch.axle_position - source_position),
-                name=name,
+        self.choppers = []
+        for name, ch in choppers.items():
+            chop = tof_pkg.Chopper.from_diskchopper(ch, name=name)
+            chop.distance = sc.norm(
+                ch.axle_position - source_position.to(unit=ch.axle_position.unit)
             )
-            for name, ch in choppers.items()
-        ]
+            self.choppers.append(chop)
 
         # Add detectors
         self.monitors = [

ess/reduce/time_of_flight/lut.py

@@ -43,6 +43,8 @@ class SimulationResults:
         For a ``tof`` simulation, this is just the position of the detector where the
         events are recorded. For a ``McStas`` simulation, this is the distance between
         the source and the event monitor.
+    choppers:
+        The parameters of the choppers used in the simulation (if any).
     """
 
     time_of_arrival: sc.Variable
@@ -50,6 +52,7 @@ class SimulationResults:
     wavelength: sc.Variable
     weight: sc.Variable
     distance: sc.Variable
+    choppers: DiskChoppers[AnyRun] | None = None
 
 
 NumberOfSimulatedNeutrons = NewType("NumberOfSimulatedNeutrons", int)
@@ -363,20 +366,26 @@ def make_tof_lookup_table(
                 [table.coords["event_time_offset"], frame_period],
                 dim='event_time_offset',
             ),
-            "pulse_period": pulse_period,
-            "pulse_stride": sc.scalar(pulse_stride, unit=None),
-            "distance_resolution": table.coords["distance"][1]
-            - table.coords["distance"][0],
-            "time_resolution": table.coords["event_time_offset"][1]
-            - table.coords["event_time_offset"][0],
-            "error_threshold": sc.scalar(error_threshold),
         },
     )
 
     # In-place masking for better performance
     _mask_large_uncertainty(table, error_threshold)
 
-    return TimeOfFlightLookupTable(table)
+    return TimeOfFlightLookupTable(
+        array=table,
+        pulse_period=pulse_period,
+        pulse_stride=pulse_stride,
+        distance_resolution=table.coords["distance"][1] - table.coords["distance"][0],
+        time_resolution=table.coords["event_time_offset"][1]
+        - table.coords["event_time_offset"][0],
+        error_threshold=error_threshold,
+        choppers=sc.DataGroup(
+            {k: sc.DataGroup(ch.as_dict()) for k, ch in simulation.choppers.items()}
+        )
+        if simulation.choppers is not None
+        else None,
+    )
 
 
 def simulate_chopper_cascade_using_tof(
@@ -412,22 +421,14 @@ def simulate_chopper_cascade_using_tof(
     """
     import tof
 
-    tof_choppers = [
-        tof.Chopper(
-            frequency=abs(ch.frequency),
-            direction=tof.AntiClockwise
-            if (ch.frequency.value > 0.0)
-            else tof.Clockwise,
-            open=ch.slit_begin,
-            close=ch.slit_end,
-            phase=ch.phase if ch.frequency.value > 0.0 else -ch.phase,
-            distance=sc.norm(
-                ch.axle_position - source_position.to(unit=ch.axle_position.unit)
-            ),
-            name=name,
+    tof_choppers = []
+    for name, ch in choppers.items():
+        chop = tof.Chopper.from_diskchopper(ch, name=name)
+        chop.distance = sc.norm(
+            ch.axle_position - source_position.to(unit=ch.axle_position.unit)
         )
-        for name, ch in choppers.items()
-    ]
+        tof_choppers.append(chop)
+
     source = tof.Source(
         facility=facility, neutrons=neutrons, pulses=pulse_stride, seed=seed
     )
@@ -454,6 +455,7 @@ def simulate_chopper_cascade_using_tof(
         wavelength=events.coords["wavelength"],
         weight=events.data,
         distance=furthest_chopper.distance,
+        choppers=choppers,
     )
 
 

ess/reduce/time_of_flight/types.py

@@ -1,7 +1,9 @@
 # SPDX-License-Identifier: BSD-3-Clause
 # Copyright (c) 2025 Scipp contributors (https://github.com/scipp)
 
-from typing import NewType
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any, NewType
 
 import sciline as sl
 import scipp as sc
@@ -12,10 +14,37 @@ TimeOfFlightLookupTableFilename = NewType("TimeOfFlightLookupTableFilename", str
 """Filename of the time-of-flight lookup table."""
 
 
-TimeOfFlightLookupTable = NewType("TimeOfFlightLookupTable", sc.DataArray)
-"""
-Lookup table giving time-of-flight as a function of distance and time of arrival.
-"""
+@dataclass
+class TimeOfFlightLookupTable:
+    """
+    Lookup table giving time-of-flight as a function of distance and time of arrival.
+    """
+
+    array: sc.DataArray
+    """The lookup table data array that maps (distance, time_of_arrival) to
+    time_of_flight."""
+    pulse_period: sc.Variable
+    """Pulse period of the neutron source."""
+    pulse_stride: int
+    """Pulse stride used when generating the lookup table."""
+    distance_resolution: sc.Variable
+    """Resolution of the distance coordinate in the lookup table."""
+    time_resolution: sc.Variable
+    """Resolution of the time_of_arrival coordinate in the lookup table."""
+    error_threshold: float
+    """The table is masked with NaNs in regions where the standard deviation of the
+    time-of-flight is above this threshold."""
+    choppers: sc.DataGroup | None = None
+    """Chopper parameters used when generating the lookup table, if any. This is made
+    optional so we can still support old lookup tables without chopper info."""
+
+    def save_hdf5(self, filename: str | Path) -> None:
+        """Save the lookup table to an HDF5 file."""
+        sc.DataGroup(asdict(self)).save_hdf5(filename)
+
+    def plot(self, *args, **kwargs) -> Any:
+        """Plot the data array of the lookup table."""
+        return self.array.plot(*args, **kwargs)
 
 
 PulseStrideOffset = NewType("PulseStrideOffset", int | None)

ess/reduce/time_of_flight/workflow.py

@@ -17,7 +17,30 @@ from .types import (
 def load_tof_lookup_table(
     filename: TimeOfFlightLookupTableFilename,
 ) -> TimeOfFlightLookupTable:
-    return TimeOfFlightLookupTable(sc.io.load_hdf5(filename))
+    """Load a time-of-flight lookup table from an HDF5 file."""
+    table = sc.io.load_hdf5(filename)
+
+    # Support old format where the metadata were stored as coordinates of the DataArray.
+    # Note that no chopper info was saved in the old format.
+    if isinstance(table, sc.DataArray):
+        table = {
+            "array": table.drop_coords(
+                [
+                    "pulse_period",
+                    "pulse_stride",
+                    "distance_resolution",
+                    "time_resolution",
+                    "error_threshold",
+                ]
+            ),
+            "pulse_period": table.coords["pulse_period"],
+            "pulse_stride": table.coords["pulse_stride"].value,
+            "distance_resolution": table.coords["distance_resolution"],
+            "time_resolution": table.coords["time_resolution"],
+            "error_threshold": table.coords["error_threshold"].value,
+        }
+
+    return TimeOfFlightLookupTable(**table)
 
 
 def GenericTofWorkflow(

{essreduce-25.11.6.dist-info → essreduce-25.12.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: essreduce
-Version: 25.11.6
+Version: 25.12.0
 Summary: Common data reduction tools for the ESS facility
 Author: Scipp contributors
 License-Expression: BSD-3-Clause
@@ -22,15 +22,16 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: sciline>=25.11.0
 Requires-Dist: scipp>=25.04.0
-Requires-Dist: scippneutron>=25.02.0
+Requires-Dist: scippneutron>=25.11.1
 Requires-Dist: scippnexus>=25.06.0
 Provides-Extra: test
 Requires-Dist: ipywidgets>=8.1; extra == "test"
+Requires-Dist: matplotlib>=3.10.7; extra == "test"
 Requires-Dist: numba>=0.59; extra == "test"
 Requires-Dist: pooch>=1.5; extra == "test"
 Requires-Dist: pytest>=7.0; extra == "test"
 Requires-Dist: scipy>=1.14; extra == "test"
-Requires-Dist: tof>=25.05.0; extra == "test"
+Requires-Dist: tof>=25.11.1; extra == "test"
 Dynamic: license-file
 
 [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg)](CODE_OF_CONDUCT.md)

{essreduce-25.11.6.dist-info → essreduce-25.12.0.dist-info}/RECORD

@@ -10,8 +10,8 @@ ess/reduce/workflow.py,sha256=738-lcdgsORYfQ4A0UTk2IgnbVxC3jBdpscpaOFIpdc,3114
 ess/reduce/data/__init__.py,sha256=uDtqkmKA_Zwtj6II25zntz9T812XhdCn3tktYev4uyY,486
 ess/reduce/data/_registry.py,sha256=ngJMzP-AuMN0EKtws5vYSEPsv_Bn3TZjjIvNUKWQDeA,13992
 ess/reduce/live/__init__.py,sha256=jPQVhihRVNtEDrE20PoKkclKV2aBF1lS7cCHootgFgI,204
-ess/reduce/live/raw.py,sha256=CkPqp4VMNvj0IcFPp1J0n7sVt5PNKdIXnDlALCg9W_Q,31031
-ess/reduce/live/roi.py,sha256=Hs-pW98k41WU6Kl3UQ41kQawk80c2QNOQ_WNctLzDPE,3795
+ess/reduce/live/raw.py,sha256=z3JzKl1tOH51z1PWT3MJERactSFRXrNI_MBmpAHX71g,31094
+ess/reduce/live/roi.py,sha256=t65SfGtCtb8r-f4hkfg2I02CEnOp6Hh5Tv9qOqPOeK0,10588
 ess/reduce/live/workflow.py,sha256=bsbwvTqPhRO6mC__3b7MgU7DWwAnOvGvG-t2n22EKq8,4285
 ess/reduce/nexus/__init__.py,sha256=xXc982vZqRba4jR4z5hA2iim17Z7niw4KlS1aLFbn1Q,1107
 ess/reduce/nexus/_nexus_loader.py,sha256=5J26y_t-kabj0ik0jf3OLSYda3lDLDQhvPd2_ro7Q_0,23927
@@ -21,14 +21,14 @@ ess/reduce/nexus/types.py,sha256=g5oBBEYPH7urF1tDP0tqXtixhQN8JDpe8vmiKrPiUW0,932
 ess/reduce/nexus/workflow.py,sha256=KRzG_flkAGNCkwDGwhTjX3h3Hi4GexMEz84trMw7HIg,24944
 ess/reduce/scripts/grow_nexus.py,sha256=hET3h06M0xlJd62E3palNLFvJMyNax2kK4XyJcOhl-I,3387
 ess/reduce/time_of_flight/__init__.py,sha256=jn8x9rZ6PzyP_wK8ACd3cg9rOpDAu_IqHyTNSeKfVn0,1461
-ess/reduce/time_of_flight/eto_to_tof.py,sha256=NN-UeVuFVg_WIe6ePAxN7HSxFxd-1BCrdasFB5WEfHw,18166
-ess/reduce/time_of_flight/fakes.py,sha256=4viK0OsmwEHSc5bDqSNN0jdo982D-oO4phdLC6vZLng,4527
+ess/reduce/time_of_flight/eto_to_tof.py,sha256=Zh7jxah1hwHY7_O9XNmYD3IfJz6mYUKo5vtr74NWUUQ,18236
+ess/reduce/time_of_flight/fakes.py,sha256=BqpO56PQyO9ua7QlZw6xXMAPBrqjKZEM_jc-VB83CyE,4289
 ess/reduce/time_of_flight/interpolator_numba.py,sha256=wh2YS3j2rOu30v1Ok3xNHcwS7t8eEtZyZvbfXOCtgrQ,3835
 ess/reduce/time_of_flight/interpolator_scipy.py,sha256=_InoAPuMm2qhJKZQBAHOGRFqtvvuQ8TStoN7j_YgS4M,1853
-ess/reduce/time_of_flight/lut.py,sha256=k8_aLQSK4kwvpOIOJgUs8J0DgromMieiKYSl7PTBC18,18788
+ess/reduce/time_of_flight/lut.py,sha256=lle3Kl4AV0Z9-nxT3XwfhZS2DzHYYn0KRpUvNDlNuOk,18812
 ess/reduce/time_of_flight/resample.py,sha256=Opmi-JA4zNH725l9VB99U4O9UlM37f5ACTCGtwBcows,3718
-ess/reduce/time_of_flight/types.py,sha256=xq-CjRZIzcfknqeNcUXMIZxvfK9eYmAJtXv-i4sJamE,1855
-ess/reduce/time_of_flight/workflow.py,sha256=mkgESvQ5Yt3CyAsa1iewkjBOHUqrHm5rRc1EhOQRewQ,2213
+ess/reduce/time_of_flight/types.py,sha256=v7oUWY2tX1FL1FceK7EIOtRnMJevWD-kdBK04t10vlY,3082
+ess/reduce/time_of_flight/workflow.py,sha256=iaCHqY5-CxxUDrgbnOuECJm81QZZl-j0_ihXE4NaAUM,3129
 ess/reduce/widgets/__init__.py,sha256=SoSHBv8Dc3QXV9HUvPhjSYWMwKTGYZLpsWwsShIO97Q,5325
 ess/reduce/widgets/_base.py,sha256=_wN3FOlXgx_u0c-A_3yyoIH-SdUvDENGgquh9S-h5GI,4852
 ess/reduce/widgets/_binedges_widget.py,sha256=ZCQsGjYHnJr9GFUn7NjoZc1CdsnAzm_fMzyF-fTKKVY,2785
@@ -41,9 +41,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.11.6.dist-info/licenses/LICENSE,sha256=nVEiume4Qj6jMYfSRjHTM2jtJ4FGu0g-5Sdh7osfEYw,1553
-essreduce-25.11.6.dist-info/METADATA,sha256=Wgvc05RrqxnRkMjQWOVd3Os8LJ7IPAnQNZk3-IOobls,1937
-essreduce-25.11.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-essreduce-25.11.6.dist-info/entry_points.txt,sha256=PMZOIYzCifHMTe4pK3HbhxUwxjFaZizYlLD0td4Isb0,66
-essreduce-25.11.6.dist-info/top_level.txt,sha256=0JxTCgMKPLKtp14wb1-RKisQPQWX7i96innZNvHBr-s,4
-essreduce-25.11.6.dist-info/RECORD,,
+essreduce-25.12.0.dist-info/licenses/LICENSE,sha256=nVEiume4Qj6jMYfSRjHTM2jtJ4FGu0g-5Sdh7osfEYw,1553
+essreduce-25.12.0.dist-info/METADATA,sha256=ZsK4VI14-0O1zyzUlUAZS3PuqygkEgO7wsc5yIvjWyI,1988
+essreduce-25.12.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+essreduce-25.12.0.dist-info/entry_points.txt,sha256=PMZOIYzCifHMTe4pK3HbhxUwxjFaZizYlLD0td4Isb0,66
+essreduce-25.12.0.dist-info/top_level.txt,sha256=0JxTCgMKPLKtp14wb1-RKisQPQWX7i96innZNvHBr-s,4
+essreduce-25.12.0.dist-info/RECORD,,