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

ess/reduce/nexus/workflow.py

@@ -370,6 +370,8 @@ def get_calibrated_detector(
     ----------
     detector:
         NeXus detector group.
+    transform:
+        Transformation matrix for the detector.
     offset:
         Offset to add to the detector position.
     bank_sizes:
@@ -430,8 +432,8 @@ def assemble_detector_data(
 
 def get_calibrated_monitor(
     monitor: NeXusComponent[MonitorType, RunType],
+    transform: NeXusTransformation[MonitorType, RunType],
     offset: MonitorPositionOffset[RunType, MonitorType],
-    source_position: Position[snx.NXsource, RunType],
 ) -> EmptyMonitor[RunType, MonitorType]:
     """
     Extract the data array corresponding to a monitor's signal field.
@@ -443,16 +445,16 @@ def get_calibrated_monitor(
     ----------
     monitor:
         NeXus monitor group.
+    transform:
+        Transformation matrix for the monitor.
     offset:
         Offset to add to the monitor position.
-    source_position:
-        Position of the neutron source.
     """
-    monitor = nexus.compute_component_position(monitor)
+    transform_unit = transform.value.unit
     return EmptyMonitor[RunType, MonitorType](
         nexus.extract_signal_data_array(monitor).assign_coords(
-            position=monitor['position'] + offset.to(unit=monitor['position'].unit),
-            source_position=source_position,
+            position=transform.value * sc.vector([0, 0, 0], unit=transform_unit)
+            + offset.to(unit=transform_unit),
         )
     )
 

ess/reduce/normalization.py

@@ -2,7 +2,11 @@
 # Copyright (c) 2025 Scipp contributors (https://github.com/scipp)
 """Normalization routines for neutron data reduction."""
 
+from __future__ import annotations
+
+import enum
 import functools
+import warnings
 
 import scipp as sc
 
@@ -14,6 +18,7 @@ def normalize_by_monitor_histogram(
     *,
     monitor: sc.DataArray,
     uncertainty_broadcast_mode: UncertaintyBroadcastMode,
+    skip_range_check: bool = False,
 ) -> sc.DataArray:
     """Normalize detector data by a normalized histogrammed monitor.
 
@@ -23,10 +28,13 @@ def normalize_by_monitor_histogram(
     - For *event* detectors, the monitor values are mapped to the detector
       using :func:`scipp.lookup`. That is, for detector event :math:`d_i`,
       :math:`m_i` is the monitor bin value at the same coordinate.
-    - For *histogram* detectors, the monitor is rebinned using to the detector
+    - For *histogram* detectors, the monitor is generally rebinned using the detector
       binning using :func:`scipp.rebin`. Thus, detector value :math:`d_i` and
       monitor value :math:`m_i` correspond to the same bin.
 
+        - In case the detector coordinate does not have a dimension in common with the
+          monitor, :func:`scipp.lookup` is used as in the event case.
+
     In both cases, let :math:`x_i` be the lower bound of monitor bin :math:`i`
     and let :math:`\\Delta x_i = x_{i+1} - x_i` be the width of that bin.
 
@@ -47,6 +55,16 @@ def normalize_by_monitor_histogram(
         Must be one-dimensional and have a dimension coordinate, typically "wavelength".
     uncertainty_broadcast_mode:
         Choose how uncertainties of the monitor are broadcast to the sample data.
+    skip_range_check:
+        If false (default), the detector data must be within the range of the monitor
+        coordinate. Set this to true to disable the check.
+        The value of out-of-range bins / events is undefined in that case.
+
+        This is useful when the detector contains data outside the monitor range, and it
+        is difficult or impossible to slice the detector without also removing in-range
+        data. In this case, the caller can mask those data points and skip the range
+        check. ``normalize_by_monitor_histogram`` does not take masks into account when
+        checking ranges as that is expensive to implement in a general case.
 
     Returns
     -------
@@ -60,22 +78,45 @@ def normalize_by_monitor_histogram(
     normalize_by_monitor_integrated:
         Normalize by an integrated monitor.
     """
-    _check_monitor_range_contains_detector(monitor=monitor, detector=detector)
+    if not skip_range_check:
+        _check_monitor_range_contains_detector(monitor=monitor, detector=detector)
 
     dim = monitor.dim
 
-    if detector.bins is None:
-        monitor = monitor.rebin({dim: detector.coords[dim]})
-    detector = _mask_detector_for_norm(detector=detector, monitor=monitor)
-    coord = monitor.coords[dim]
-    delta_w = sc.DataArray(coord[1:] - coord[:-1], masks=monitor.masks)
-    norm = broadcast_uncertainties(
-        monitor / delta_w, prototype=detector, mode=uncertainty_broadcast_mode
-    )
-
-    if detector.bins is None:
-        return detector / norm.rebin({dim: detector.coords[dim]})
-    return detector.bins / sc.lookup(norm, dim=dim)
+    match _HistogramNormalizationMode.deduce(detector, dim):
+        case _HistogramNormalizationMode.Events:
+            detector = _mask_detector_for_norm(detector=detector, monitor=monitor)
+            norm = _histogram_monitor_term(
+                monitor,
+                dim,
+                broadcast_to=detector,
+                uncertainty_broadcast_mode=uncertainty_broadcast_mode,
+            )
+            if dim in detector.bins.coords:
+                return detector.bins / sc.lookup(norm, dim=dim)
+            else:
+                return detector / norm
+
+        case _HistogramNormalizationMode.BinsCommonDim:
+            monitor = monitor.rebin({dim: detector.coords[dim]})
+            detector = _mask_detector_for_norm(detector=detector, monitor=monitor)
+            norm = _histogram_monitor_term(
+                monitor,
+                dim,
+                broadcast_to=detector,
+                uncertainty_broadcast_mode=uncertainty_broadcast_mode,
+            )
+            return detector / norm
+
+        case _HistogramNormalizationMode.BinsDifferentDim:
+            detector = _mask_detector_for_norm(detector=detector, monitor=monitor)
+            # No broadcast here because there are no common dims, use lookup instead.
+            norm = _histogram_monitor_term(
+                monitor,
+                dim,
+                uncertainty_broadcast_mode=uncertainty_broadcast_mode,
+            )
+            return detector / sc.lookup(norm)[_compute_bin_centers(detector, dim)]
 
 
 def normalize_by_monitor_integrated(
@@ -83,6 +124,7 @@ def normalize_by_monitor_integrated(
     *,
     monitor: sc.DataArray,
     uncertainty_broadcast_mode: UncertaintyBroadcastMode,
+    skip_range_check: bool = False,
 ) -> sc.DataArray:
     """Normalize detector data by an integrated monitor.
 
@@ -113,6 +155,16 @@ def normalize_by_monitor_integrated(
         Must be one-dimensional and have a dimension coordinate, typically "wavelength".
     uncertainty_broadcast_mode:
         Choose how uncertainties of the monitor are broadcast to the sample data.
+    skip_range_check:
+        If false (default), the detector data must be within the range of the monitor
+        coordinate. Set this to true to disable the check.
+        The value of out-of-range bins / events is undefined in that case.
+
+        This is useful when the detector contains data outside the monitor range, and it
+        is difficult or impossible to slice the detector without also removing in-range
+        data. In this case, the caller can mask those data points and skip the range
+        check. ``normalize_by_monitor_histogram`` does not take masks into account when
+        checking ranges as that is expensive to implement in a general case.
 
     Returns
     -------
@@ -126,7 +178,8 @@ def normalize_by_monitor_integrated(
     normalize_by_monitor_histogram:
         Normalize by a monitor histogram.
     """
-    _check_monitor_range_contains_detector(monitor=monitor, detector=detector)
+    if not skip_range_check:
+        _check_monitor_range_contains_detector(monitor=monitor, detector=detector)
     detector = _mask_detector_for_norm(detector=detector, monitor=monitor)
     norm = monitor.nansum().data
     norm = broadcast_uncertainties(
@@ -149,15 +202,15 @@ def _check_monitor_range_contains_detector(
     # monitor range that is less than the detector bins which is fine for the events,
     # but would be wrong if the detector was subsequently histogrammed.
     if (det_coord := detector.coords.get(dim)) is not None:
-        lo = det_coord[dim, :-1].nanmin()
-        hi = det_coord[dim, 1:].nanmax()
+        ...
     elif (det_coord := detector.bins.coords.get(dim)) is not None:
-        lo = det_coord.nanmin()
-        hi = det_coord.nanmax()
+        ...
     else:
         raise sc.CoordError(
             f"Missing '{dim}' coordinate in detector for monitor normalization."
         )
+    lo = det_coord.nanmin()
+    hi = det_coord.nanmax()
 
     if monitor.coords[dim].min() > lo or monitor.coords[dim].max() < hi:
         raise ValueError(
@@ -181,13 +234,17 @@ def _mask_detector_for_norm(
     if (monitor_mask := _monitor_mask(monitor)) is None:
         return detector
 
-    if (detector_coord := detector.coords.get(monitor.dim)) is not None:
+    if (detector_coord := detector.coords.get(dim)) is not None:
         # Apply the mask to the bins or a dense detector.
-        # Use rebin to reshape the mask to the detector.
-        mask = sc.DataArray(monitor_mask, coords={dim: monitor.coords[dim]}).rebin(
-            {dim: detector_coord}
-        ).data != sc.scalar(0, unit=None)
-        return detector.assign_masks({"_monitor_mask": mask})
+        mask_da = sc.DataArray(monitor_mask, coords={dim: monitor.coords[dim]})
+        if dim in detector_coord.dims:
+            # Use rebin to reshape the mask to the detector.
+            mask = mask_da.rebin({dim: detector_coord}).data != sc.scalar(0, unit=None)
+            return detector.assign_masks(_monitor_mask=mask)
+        # else: need to use lookup to apply mask at matching coord elements
+        return detector.assign_masks(
+            _monitor_mask=sc.lookup(mask_da)[_compute_bin_centers(detector, dim)]
+        )
 
     # else: Apply the mask to the events.
     if dim not in detector.bins.coords:
@@ -197,7 +254,7 @@ def _mask_detector_for_norm(
     event_mask = sc.lookup(
         sc.DataArray(monitor_mask, coords={dim: monitor.coords[dim]})
     )[detector.bins.coords[dim]]
-    return detector.bins.assign_masks({"_monitor_mask": event_mask})
+    return detector.bins.assign_masks(_monitor_mask=event_mask)
 
 
 def _monitor_mask(monitor: sc.DataArray) -> sc.Variable | None:
@@ -213,3 +270,74 @@ def _monitor_mask(monitor: sc.DataArray) -> sc.Variable | None:
     if not masks:
         return None
     return functools.reduce(sc.logical_or, masks)
+
+
+def _histogram_monitor_term(
+    monitor: sc.DataArray,
+    dim: str,
+    *,
+    broadcast_to: sc.DataArray | None = None,
+    uncertainty_broadcast_mode: UncertaintyBroadcastMode,
+) -> sc.DataArray:
+    if not monitor.coords.is_edges(dim, dim):
+        raise sc.CoordError(
+            f"Monitor coordinage {dim} must be bin-edges for normalization."
+        )
+    coord = monitor.coords[dim]
+    delta_w = sc.DataArray(coord[1:] - coord[:-1], masks=monitor.masks)
+    norm = monitor / delta_w
+
+    if broadcast_to is not None:
+        return broadcast_uncertainties(
+            norm, prototype=broadcast_to, mode=uncertainty_broadcast_mode
+        )
+
+    match uncertainty_broadcast_mode:
+        case UncertaintyBroadcastMode.fail:
+            return norm
+        case UncertaintyBroadcastMode.drop:
+            return sc.values(norm)
+        case _:
+            warnings.warn(
+                "Cannot broadcast uncertainties in this case.",
+                UserWarning,
+                stacklevel=3,
+            )
+            return norm
+
+
+class _HistogramNormalizationMode(enum.Enum):
+    Events = enum.auto()
+    """Use an event coordinate to lookup monitor values."""
+    BinsCommonDim = enum.auto()
+    """Use a bin coordinate which contains the monitor dimension.
+
+    The coordinate may be multi-dimensional but one dimension matches
+    the dimension of the monitor.
+    """
+    BinsDifferentDim = enum.auto()
+    """Use a bin coordinate which does not contain the monitor dimension.
+
+    The coordinate may be multi-dimensions, e.g., in the DREAM powder workflow
+    where it has dims (two_theta, dspacing [bin-edges]).
+    """
+
+    @classmethod
+    def deduce(cls, detector: sc.DataArray, dim: str) -> _HistogramNormalizationMode:
+        # Use an event-coord when available:
+        if detector.bins is not None and dim in detector.bins.coords:
+            return _HistogramNormalizationMode.Events
+        # else: use a bin-coord.
+
+        det_coord = detector.coords[dim]
+        if dim in det_coord.dims:
+            return _HistogramNormalizationMode.BinsCommonDim
+        return _HistogramNormalizationMode.BinsDifferentDim
+
+
+def _compute_bin_centers(da: sc.DataArray, name: str) -> sc.Variable:
+    coord = da.coords[name]
+    for dim in coord.dims:
+        if da.coords.is_edges(name, dim):
+            coord = sc.midpoints(coord, dim=dim)
+    return coord

ess/reduce/time_of_flight/__init__.py

@@ -30,6 +30,8 @@ from .types import (
     TimeOfFlightLookupTableFilename,
     ToaDetector,
     TofDetector,
+    TofLookupTable,
+    TofLookupTableFilename,
     TofMonitor,
 )
 from .workflow import GenericTofWorkflow
@@ -54,6 +56,8 @@ __all__ = [
     "TimeResolution",
     "ToaDetector",
     "TofDetector",
+    "TofLookupTable",
+    "TofLookupTableFilename",
     "TofLookupTableWorkflow",
     "TofMonitor",
     "providers",

ess/reduce/time_of_flight/eto_to_tof.py

@@ -35,9 +35,9 @@ from .types import (
     DetectorLtotal,
     MonitorLtotal,
     PulseStrideOffset,
-    TimeOfFlightLookupTable,
     ToaDetector,
     TofDetector,
+    TofLookupTable,
     TofMonitor,
 )
 
@@ -96,7 +96,7 @@ class TofInterpolator:
 
 
 def _time_of_flight_data_histogram(
-    da: sc.DataArray, lookup: TimeOfFlightLookupTable, ltotal: sc.Variable
+    da: sc.DataArray, lookup: TofLookupTable, 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'.
@@ -201,7 +201,7 @@ def _guess_pulse_stride_offset(
 
 def _prepare_tof_interpolation_inputs(
     da: sc.DataArray,
-    lookup: TimeOfFlightLookupTable,
+    lookup: TofLookupTable,
     ltotal: sc.Variable,
     pulse_stride_offset: int | None,
 ) -> dict:
@@ -295,7 +295,7 @@ def _prepare_tof_interpolation_inputs(
 
 def _time_of_flight_data_events(
     da: sc.DataArray,
-    lookup: TimeOfFlightLookupTable,
+    lookup: TofLookupTable,
     ltotal: sc.Variable,
     pulse_stride_offset: int | None,
 ) -> sc.DataArray:
@@ -317,7 +317,19 @@ def _time_of_flight_data_events(
     parts = da.bins.constituents
     parts["data"] = tofs
     result = da.bins.assign_coords(tof=sc.bins(**parts, validate_indices=False))
-    return result.bins.drop_coords("event_time_offset")
+    out = result.bins.drop_coords("event_time_offset")
+
+    # The result may still have an 'event_time_zero' dimension (in the case of an
+    # event monitor where events were not grouped by pixel).
+    if "event_time_zero" in out.dims:
+        if ("event_time_zero" in out.coords) and (
+            "event_time_zero" not in out.bins.coords
+        ):
+            out.bins.coords["event_time_zero"] = sc.bins_like(
+                out, out.coords["event_time_zero"]
+            )
+        out = out.bins.concat("event_time_zero")
+    return out
 
 
 def detector_ltotal_from_straight_line_approximation(
@@ -357,6 +369,7 @@ def detector_ltotal_from_straight_line_approximation(
 
 def monitor_ltotal_from_straight_line_approximation(
     monitor_beamline: EmptyMonitor[RunType, MonitorType],
+    source_position: Position[snx.NXsource, RunType],
 ) -> MonitorLtotal[RunType, MonitorType]:
     """
     Compute Ltotal for the monitor.
@@ -369,7 +382,10 @@ def monitor_ltotal_from_straight_line_approximation(
         Beamline data for the monitor that contains the positions necessary to compute
         the straight-line approximation to Ltotal (source and monitor positions).
     """
-    graph = scn.conversion.graph.beamline.beamline(scatter=False)
+    graph = {
+        **scn.conversion.graph.beamline.beamline(scatter=False),
+        'source_position': lambda: source_position,
+    }
     return MonitorLtotal[RunType, MonitorType](
         monitor_beamline.transform_coords(
             "Ltotal", graph=graph, keep_intermediate=False
@@ -379,7 +395,7 @@ def monitor_ltotal_from_straight_line_approximation(
 
 def _compute_tof_data(
     da: sc.DataArray,
-    lookup: TimeOfFlightLookupTable,
+    lookup: TofLookupTable,
     ltotal: sc.Variable,
     pulse_stride_offset: int,
 ) -> sc.DataArray:
@@ -397,7 +413,7 @@ def _compute_tof_data(
 
 def detector_time_of_flight_data(
     detector_data: RawDetector[RunType],
-    lookup: TimeOfFlightLookupTable,
+    lookup: TofLookupTable,
     ltotal: DetectorLtotal[RunType],
     pulse_stride_offset: PulseStrideOffset,
 ) -> TofDetector[RunType]:
@@ -431,7 +447,7 @@ def detector_time_of_flight_data(
 
 def monitor_time_of_flight_data(
     monitor_data: RawMonitor[RunType, MonitorType],
-    lookup: TimeOfFlightLookupTable,
+    lookup: TofLookupTable,
     ltotal: MonitorLtotal[RunType, MonitorType],
     pulse_stride_offset: PulseStrideOffset,
 ) -> TofMonitor[RunType, MonitorType]:
@@ -465,7 +481,7 @@ def monitor_time_of_flight_data(
 
 def detector_time_of_arrival_data(
     detector_data: RawDetector[RunType],
-    lookup: TimeOfFlightLookupTable,
+    lookup: TofLookupTable,
     ltotal: DetectorLtotal[RunType],
     pulse_stride_offset: PulseStrideOffset,
 ) -> ToaDetector[RunType]:

ess/reduce/time_of_flight/lut.py

@@ -13,7 +13,7 @@ import sciline as sl
 import scipp as sc
 
 from ..nexus.types import AnyRun, DiskChoppers
-from .types import TimeOfFlightLookupTable
+from .types import TofLookupTable
 
 
 @dataclass
@@ -230,7 +230,7 @@ def make_tof_lookup_table(
     pulse_period: PulsePeriod,
     pulse_stride: PulseStride,
     error_threshold: LookupTableRelativeErrorThreshold,
-) -> TimeOfFlightLookupTable:
+) -> TofLookupTable:
     """
     Compute a lookup table for time-of-flight as a function of distance and
     time-of-arrival.
@@ -372,7 +372,7 @@ def make_tof_lookup_table(
     # In-place masking for better performance
     _mask_large_uncertainty(table, error_threshold)
 
-    return TimeOfFlightLookupTable(
+    return TofLookupTable(
         array=table,
         pulse_period=pulse_period,
         pulse_stride=pulse_stride,
@@ -398,13 +398,13 @@ def simulate_chopper_cascade_using_tof(
 ) -> SimulationResults:
     """
     Simulate a pulse of neutrons propagating through a chopper cascade using the
-    ``tof`` package (https://tof.readthedocs.io).
+    ``tof`` package (https://scipp.github.io/tof).
 
     Parameters
     ----------
     choppers:
         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
+        https://scipp.github.io/scippneutron/user-guide/chopper/processing-nexus-choppers.html
         for more information.
     source_position:
         A scalar variable with ``dtype=vector3`` that defines the source position.

ess/reduce/time_of_flight/types.py

@@ -10,12 +10,15 @@ import scipp as sc
 
 from ..nexus.types import MonitorType, RunType
 
-TimeOfFlightLookupTableFilename = NewType("TimeOfFlightLookupTableFilename", str)
+TofLookupTableFilename = NewType("TofLookupTableFilename", str)
 """Filename of the time-of-flight lookup table."""
 
+TimeOfFlightLookupTableFilename = TofLookupTableFilename
+"""Filename of the time-of-flight lookup table (alias)."""
+
 
 @dataclass
-class TimeOfFlightLookupTable:
+class TofLookupTable:
     """
     Lookup table giving time-of-flight as a function of distance and time of arrival.
     """
@@ -47,6 +50,10 @@ class TimeOfFlightLookupTable:
         return self.array.plot(*args, **kwargs)
 
 
+TimeOfFlightLookupTable = TofLookupTable
+"""Lookup table giving time-of-flight as a function of distance and time of arrival
+(alias)."""
+
 PulseStrideOffset = NewType("PulseStrideOffset", int | None)
 """
 When pulse-skipping, the offset of the first pulse in the stride. This is typically

ess/reduce/time_of_flight/workflow.py

@@ -9,14 +9,14 @@ from ..nexus import GenericNeXusWorkflow
 from . import eto_to_tof
 from .types import (
     PulseStrideOffset,
-    TimeOfFlightLookupTable,
-    TimeOfFlightLookupTableFilename,
+    TofLookupTable,
+    TofLookupTableFilename,
 )
 
 
 def load_tof_lookup_table(
-    filename: TimeOfFlightLookupTableFilename,
-) -> TimeOfFlightLookupTable:
+    filename: TofLookupTableFilename,
+) -> TofLookupTable:
     """Load a time-of-flight lookup table from an HDF5 file."""
     table = sc.io.load_hdf5(filename)
 
@@ -40,7 +40,7 @@ def load_tof_lookup_table(
             "error_threshold": table.coords["error_threshold"].value,
         }
 
-    return TimeOfFlightLookupTable(**table)
+    return TofLookupTable(**table)
 
 
 def GenericTofWorkflow(

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: essreduce
-Version: 25.12.0
+Version: 26.1.0
 Summary: Common data reduction tools for the ESS facility
 Author: Scipp contributors
 License-Expression: BSD-3-Clause

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

@@ -1,6 +1,6 @@
 ess/reduce/__init__.py,sha256=9iqQ57K3stwyujDzOk30hj7WqZt1Ycnb9AVDDDmk3K0,451
 ess/reduce/logging.py,sha256=6n8Czq4LZ3OK9ENlKsWSI1M3KvKv6_HSoUiV4__IUlU,357
-ess/reduce/normalization.py,sha256=B4O5W3CV_ti-zeU7tyQEAXk5pCUebZ0BG30YN2I3TyY,7844
+ess/reduce/normalization.py,sha256=r8H6SZgT94a1HE9qZ6Bx3N6c3VG3FzlJPzoCVMNI5-0,13081
 ess/reduce/parameter.py,sha256=4sCfoKOI2HuO_Q7JLH_jAXnEOFANSn5P3NdaOBzhJxc,4635
 ess/reduce/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ess/reduce/streaming.py,sha256=zbqxQz5dASDq4ZVyx-TdbapBXMyBttImCYz_6WOj4pg,17978
@@ -18,17 +18,17 @@ ess/reduce/nexus/_nexus_loader.py,sha256=5J26y_t-kabj0ik0jf3OLSYda3lDLDQhvPd2_ro
 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=g5oBBEYPH7urF1tDP0tqXtixhQN8JDpe8vmiKrPiUW0,9320
-ess/reduce/nexus/workflow.py,sha256=KRzG_flkAGNCkwDGwhTjX3h3Hi4GexMEz84trMw7HIg,24944
+ess/reduce/nexus/workflow.py,sha256=bVRnVZ6HTEdIFwZv61JuvFUeTt9efUwe1MR65gBhyw8,24995
 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=Zh7jxah1hwHY7_O9XNmYD3IfJz6mYUKo5vtr74NWUUQ,18236
+ess/reduce/time_of_flight/__init__.py,sha256=bNxhK0uePltQpCW2sdNTpPdzXL6dt1IT1ri_cJ5VTL8,1561
+ess/reduce/time_of_flight/eto_to_tof.py,sha256=imKuN7IARMqBjmi8kjAcsseTFg6OD8ORas9X1FolgFY,18777
 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=lle3Kl4AV0Z9-nxT3XwfhZS2DzHYYn0KRpUvNDlNuOk,18812
+ess/reduce/time_of_flight/lut.py,sha256=8AupwtfB2983DoyzFgnRjWP3J3s_oPghi3XlXaaxxow,18768
 ess/reduce/time_of_flight/resample.py,sha256=Opmi-JA4zNH725l9VB99U4O9UlM37f5ACTCGtwBcows,3718
-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/time_of_flight/types.py,sha256=FsSueM6OjJdF80uJHj-TNuyVAci8ixFvMuRMt9oHKDQ,3310
+ess/reduce/time_of_flight/workflow.py,sha256=2jUxeSmP0KweQTctAzIFJLm7Odf_e7kZzAc8MAMKBEs,3084
 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.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,,
+essreduce-26.1.0.dist-info/licenses/LICENSE,sha256=nVEiume4Qj6jMYfSRjHTM2jtJ4FGu0g-5Sdh7osfEYw,1553
+essreduce-26.1.0.dist-info/METADATA,sha256=WTZ9G8OVIHDjHsgeW9zgv-XJBv6mzYc5HAlxBY-5uXQ,1987
+essreduce-26.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+essreduce-26.1.0.dist-info/entry_points.txt,sha256=PMZOIYzCifHMTe4pK3HbhxUwxjFaZizYlLD0td4Isb0,66
+essreduce-26.1.0.dist-info/top_level.txt,sha256=0JxTCgMKPLKtp14wb1-RKisQPQWX7i96innZNvHBr-s,4
+essreduce-26.1.0.dist-info/RECORD,,