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

ess/reduce/nexus/workflow.py

@@ -15,6 +15,7 @@ from scipp.constants import g
 from scipp.core import label_based_index_to_positional_index
 from scippneutron.chopper import extract_chopper_from_nexus
 
+from ..utils import prune_type_vars
 from . import _nexus_loader as nexus
 from .types import (
     AllNeXusComponents,
@@ -718,33 +719,6 @@ def GenericNeXusWorkflow(
     wf[PreopenNeXusFile] = PreopenNeXusFile(False)
 
     if run_types is not None or monitor_types is not None:
-        _prune_type_vars(wf, run_types=run_types, monitor_types=monitor_types)
+        prune_type_vars(wf, run_types=run_types, monitor_types=monitor_types)
 
     return wf
-
-
-def _prune_type_vars(
-    workflow: sciline.Pipeline,
-    *,
-    run_types: Iterable[sciline.typing.Key] | None,
-    monitor_types: Iterable[sciline.typing.Key] | None,
-) -> None:
-    # Remove all nodes that use a run type or monitor types that is
-    # not listed in the function arguments.
-    excluded_run_types = _excluded_type_args(RunType, run_types)
-    excluded_monitor_types = _excluded_type_args(MonitorType, monitor_types)
-    excluded_types = excluded_run_types | excluded_monitor_types
-
-    graph = workflow.underlying_graph
-    to_remove = [
-        node for node in graph if excluded_types & set(getattr(node, "__args__", set()))
-    ]
-    graph.remove_nodes_from(to_remove)
-
-
-def _excluded_type_args(
-    type_var: Any, keep: Iterable[sciline.typing.Key] | None
-) -> set[sciline.typing.Key]:
-    if keep is None:
-        return set()
-    return set(type_var.__constraints__) - set(keep)

ess/reduce/time_of_flight/__init__.py

@@ -6,42 +6,54 @@ Utilities for computing real neutron time-of-flight from chopper settings and
 neutron time-of-arrival at the detectors.
 """
 
-from .eto_to_tof import default_parameters, providers, resample_tof_data
+from .eto_to_tof import (
+    default_parameters,
+    providers,
+    resample_detector_time_of_flight_data,
+    resample_monitor_time_of_flight_data,
+)
 from .simulation import simulate_beamline
 from .to_events import to_events
 from .types import (
+    DetectorLtotal,
+    DetectorTofData,
     DistanceResolution,
     LookupTableRelativeErrorThreshold,
-    Ltotal,
     LtotalRange,
+    MonitorLtotal,
+    MonitorTofData,
     PulsePeriod,
     PulseStride,
     PulseStrideOffset,
-    RawData,
-    ResampledTofData,
+    ResampledDetectorTofData,
+    ResampledMonitorTofData,
     SimulationResults,
     TimeOfFlightLookupTable,
     TimeResolution,
-    TofData,
 )
+from .workflow import GenericTofWorkflow
 
 __all__ = [
+    "DetectorLtotal",
+    "DetectorTofData",
     "DistanceResolution",
+    "GenericTofWorkflow",
     "LookupTableRelativeErrorThreshold",
-    "Ltotal",
     "LtotalRange",
+    "MonitorLtotal",
+    "MonitorTofData",
     "PulsePeriod",
     "PulseStride",
     "PulseStrideOffset",
-    "RawData",
-    "ResampledTofData",
+    "ResampledDetectorTofData",
+    "ResampledMonitorTofData",
     "SimulationResults",
     "TimeOfFlightLookupTable",
     "TimeResolution",
-    "TofData",
     "default_parameters",
     "providers",
-    "resample_tof_data",
+    "resample_detector_time_of_flight_data",
+    "resample_monitor_time_of_flight_data",
     "simulate_beamline",
     "to_events",
 ]

ess/reduce/time_of_flight/eto_to_tof.py

@@ -11,6 +11,7 @@ from collections.abc import Callable
 
 import numpy as np
 import scipp as sc
+import scippneutron as scn
 from scipp._scipp.core import _bins_no_validate
 from scippneutron._utils import elem_unit
 
@@ -18,21 +19,32 @@ try:
     from .interpolator_numba import Interpolator as InterpolatorImpl
 except ImportError:
     from .interpolator_scipy import Interpolator as InterpolatorImpl
+
+from ..nexus.types import (
+    CalibratedBeamline,
+    CalibratedMonitor,
+    DetectorData,
+    MonitorData,
+    MonitorType,
+    RunType,
+)
 from .to_events import to_events
 from .types import (
+    DetectorLtotal,
+    DetectorTofData,
     DistanceResolution,
     LookupTableRelativeErrorThreshold,
-    Ltotal,
     LtotalRange,
+    MonitorLtotal,
+    MonitorTofData,
     PulsePeriod,
     PulseStride,
     PulseStrideOffset,
-    RawData,
-    ResampledTofData,
+    ResampledDetectorTofData,
+    ResampledMonitorTofData,
     SimulationResults,
     TimeOfFlightLookupTable,
     TimeResolution,
-    TofData,
 )
 
 
@@ -84,7 +96,7 @@ def _compute_mean_tof_in_distance_range(
     frame_period:
         Period of the source pulses, i.e., time between consecutive pulse starts.
     time_bins_half_width:
-        Half the width of the time bins.
+        Half width of the time bins in the event_time_offset axis.
     """
     simulation_distance = simulation.distance.to(unit=distance_unit)
     distances = sc.midpoints(distance_bins)
@@ -104,8 +116,7 @@ def _compute_mean_tof_in_distance_range(
         },
     ).flatten(to="event")
 
-    # Add the event_time_offset coordinate to the data. We first operate on the
-    # frame period. The table will later be folded to the pulse period.
+    # Add the event_time_offset coordinate, wrapped to the frame_period
     data.coords['event_time_offset'] = data.coords['toa'] % frame_period
 
     # Because we staggered the mesh by half a bin width, we want the values above
@@ -134,51 +145,6 @@ def _compute_mean_tof_in_distance_range(
     return mean_tof
 
 
-def _fold_table_to_pulse_period(
-    table: sc.DataArray, pulse_period: sc.Variable, pulse_stride: int
-) -> sc.DataArray:
-    """
-    Fold the lookup table to the pulse period. We make sure the left and right edges of
-    the table wrap around the ``event_time_offset`` dimension.
-
-    Parameters
-    ----------
-    table:
-        Lookup table with time-of-flight as a function of distance and time-of-arrival.
-    pulse_period:
-        Period of the source pulses, i.e., time between consecutive pulse starts.
-    pulse_stride:
-        Stride of used pulses. Usually 1, but may be a small integer when
-        pulse-skipping.
-    """
-    size = table.sizes['event_time_offset']
-    if (size % pulse_stride) != 0:
-        raise ValueError(
-            "TimeOfFlightLookupTable: the number of time bins must be a multiple of "
-            f"the pulse stride, but got {size} time bins and a pulse stride of "
-            f"{pulse_stride}."
-        )
-
-    size = size // pulse_stride
-    out = sc.concat([table, table['event_time_offset', 0]], dim='event_time_offset')
-    out = sc.concat(
-        [
-            out['event_time_offset', (i * size) : (i + 1) * size + 1]
-            for i in range(pulse_stride)
-        ],
-        dim='pulse',
-    )
-    return out.assign_coords(
-        event_time_offset=sc.concat(
-            [
-                table.coords['event_time_offset']['event_time_offset', :size],
-                pulse_period,
-            ],
-            'event_time_offset',
-        )
-    )
-
-
 def compute_tof_lookup_table(
     simulation: SimulationResults,
     ltotal_range: LtotalRange,
@@ -212,6 +178,43 @@ def compute_tof_lookup_table(
     error_threshold:
         Threshold for the relative standard deviation (coefficient of variation) of the
         projected time-of-flight above which values are masked.
+
+    Notes
+    -----
+
+    Below are some details about the binning and wrapping around frame period in the
+    time dimension.
+
+    We have some simulated ``toa`` (events) from a Tof/McStas simulation.
+    Those are absolute ``toa``, unwrapped.
+    First we compute the usual ``event_time_offset = toa % frame_period``.
+
+    Now, we want to ensure periodic boundaries. If we make a bin centered around 0,
+    and a bin centered around 71ms: the first bin will use events between 0 and
+    ``0.5 * dt`` (where ``dt`` is the bin width).
+    The last bin will use events between ``frame_period - 0.5*dt`` and
+    ``frame_period + 0.5 * dt``. So when we compute the mean inside those two bins,
+    they will not yield the same results.
+    It is as if the first bin is missing the events it should have between
+    ``-0.5 * dt`` and 0 (because of the modulo we computed above).
+
+    To fix this, we do not make a last bin around 71ms (the bins stop at
+    ``frame_period - 0.5*dt``). Instead, we compute modulo a second time,
+    but this time using ``event_time_offset %= (frame_period - 0.5*dt)``.
+    (we cannot directly do ``event_time_offset = toa % (frame_period - 0.5*dt)`` in a
+    single step because it would introduce a gradual shift,
+    as the pulse number increases).
+
+    This second modulo effectively takes all the events that would have gone in the
+    last bin (between ``frame_period - 0.5*dt`` and ``frame_period``) and puts them in
+    the first bin. Instead of placing them between ``-0.5*dt`` and 0,
+    it places them between 0 and ``0.5*dt``, but this does not really matter,
+    because we then take the mean inside the first bin.
+    Whether the events are on the left or right side of zero does not matter.
+
+    Finally, we make a copy of the left edge, and append it to the right of the table,
+    thus ensuring that the values on the right edge are strictly the same as on the
+    left edge.
     """
     distance_unit = "m"
     time_unit = simulation.time_of_arrival.unit
@@ -276,16 +279,31 @@ def compute_tof_lookup_table(
     table.coords["distance"] = sc.midpoints(table.coords["distance"])
     table.coords["event_time_offset"] = sc.midpoints(table.coords["event_time_offset"])
 
-    table = _fold_table_to_pulse_period(
-        table=table, pulse_period=pulse_period, pulse_stride=pulse_stride
+    # Copy the left edge to the right to create periodic boundary conditions
+    table = sc.DataArray(
+        data=sc.concat(
+            [table.data, table.data['event_time_offset', 0]], dim='event_time_offset'
+        ),
+        coords={
+            "distance": table.coords["distance"],
+            "event_time_offset": sc.concat(
+                [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.transpose(('pulse', 'distance', 'event_time_offset'))
-    )
+    return TimeOfFlightLookupTable(table)
 
 
 class TofInterpolator:
@@ -293,22 +311,6 @@ class TofInterpolator:
         self._distance_unit = distance_unit
         self._time_unit = time_unit
 
-        # In the pulse dimension, it could be that for a given event_time_offset and
-        # distance, a tof value is finite in one pulse and NaN in the other.
-        # When using the bilinear interpolation, even if the value of the requested
-        # point is exactly 0 or 1 (in the case of pulse_stride=2), the interpolator
-        # will still use all 4 corners surrounding the point. This means that if one of
-        # the corners is NaN, the result will be NaN.
-        # Here, we use a trick where we duplicate the lookup values in the 'pulse'
-        # dimension so that the interpolator has values on bin edges for that dimension.
-        # The interpolator raises an error if axes coordinates are not strictly
-        # 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._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)
@@ -321,23 +323,16 @@ class TofInterpolator:
         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
-            ),
+            values=lookup.data.to(unit=self._time_unit, copy=False).values,
         )
 
     def __call__(
         self,
-        pulse_index: sc.Variable,
         ltotal: sc.Variable,
         event_time_offset: sc.Variable,
+        pulse_period: sc.Variable,
+        pulse_index: sc.Variable | None = None,
     ) -> sc.Variable:
-        if pulse_index.unit not in ("", None):
-            raise sc.UnitError(
-                "pulse_index must have unit dimensionless or None, "
-                f"but got unit: {pulse_index.unit}."
-            )
         if ltotal.unit != self._distance_unit:
             raise sc.UnitError(
                 f"ltotal must have unit: {self._distance_unit}, "
@@ -349,31 +344,30 @@ class TofInterpolator:
                 f"but got unit: {event_time_offset.unit}."
             )
         out_dims = event_time_offset.dims
-        pulse_index = pulse_index.values
         ltotal = ltotal.values
         event_time_offset = event_time_offset.values
 
         return sc.array(
             dims=out_dims,
             values=self._interpolator(
-                times=event_time_offset, distances=ltotal, pulse_indices=pulse_index
+                times=event_time_offset,
+                distances=ltotal,
+                pulse_index=pulse_index.values if pulse_index is not None else None,
+                pulse_period=pulse_period.value,
             ),
             unit=self._time_unit,
         )
 
 
 def _time_of_flight_data_histogram(
-    da: sc.DataArray,
-    lookup: sc.DataArray,
-    ltotal: sc.Variable,
-    pulse_period: sc.Variable,
+    da: sc.DataArray, lookup: sc.DataArray, 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'.
     key = next(iter(set(da.coords.keys()) & {"time_of_flight", "tof"}))
     raw_eto = da.coords[key].to(dtype=float, copy=False)
     eto_unit = raw_eto.unit
-    pulse_period = pulse_period.to(unit=eto_unit)
+    pulse_period = lookup.coords["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
@@ -386,31 +380,14 @@ def _time_of_flight_data_histogram(
     rebinned = da.rebin({key: new_bins})
     etos = rebinned.coords[key]
 
-    # In histogram mode, the lookup table cannot have a pulse dimension because we
-    # cannot know in the histogrammed data which pulse the events belong to.
-    # So we merge the pulse dimension in the lookup table. A quick way to do this
-    # is to take the mean of the data along the pulse dimension (there should
-    # only be regions that are NaN in one pulse and finite in the other).
-    merged = lookup.data.nanmean('pulse')
-    dim = merged.dims[0]
-    lookup = sc.DataArray(
-        data=merged.fold(dim=dim, sizes={'pulse': 1, dim: merged.sizes[dim]}),
-        coords={
-            'pulse': sc.arange('pulse', 1.0),
-            'distance': lookup.coords['distance'],
-            'event_time_offset': lookup.coords['event_time_offset'],
-        },
-    )
-    pulse_index = sc.zeros(sizes=etos.sizes)
-
     # Create linear interpolator
     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.broadcast(sizes=etos.sizes),
         event_time_offset=etos,
+        pulse_period=pulse_period,
     )
 
     return rebinned.assign_coords(tof=tofs)
@@ -420,6 +397,7 @@ def _guess_pulse_stride_offset(
     pulse_index: sc.Variable,
     ltotal: sc.Variable,
     event_time_offset: sc.Variable,
+    pulse_period: sc.Variable,
     pulse_stride: int,
     interp: TofInterpolator,
 ) -> int:
@@ -446,6 +424,8 @@ def _guess_pulse_stride_offset(
         Total length of the flight path from the source to the detector for each event.
     event_time_offset:
         Time of arrival of the neutron at the detector for each event.
+    pulse_period:
+        Period of the source pulses, i.e., time between consecutive pulse starts.
     pulse_stride:
         Stride of used pulses.
     interp:
@@ -469,7 +449,12 @@ def _guess_pulse_stride_offset(
     )
     for i in range(pulse_stride):
         pulse_inds = (pulse_index + i) % pulse_stride
-        tofs[i] = interp(pulse_index=pulse_inds, ltotal=ltotal, event_time_offset=etos)
+        tofs[i] = interp(
+            ltotal=ltotal,
+            event_time_offset=etos,
+            pulse_index=pulse_inds,
+            pulse_period=pulse_period,
+        )
     # Find the entry in the list with the least number of nan values
     return sorted(tofs, key=lambda x: sc.isnan(tofs[x]).sum())[0]
 
@@ -478,8 +463,6 @@ def _time_of_flight_data_events(
     da: sc.DataArray,
     lookup: sc.DataArray,
     ltotal: sc.Variable,
-    pulse_period: sc.Variable,
-    pulse_stride: int,
     pulse_stride_offset: int,
 ) -> sc.DataArray:
     etos = da.bins.coords["event_time_offset"].to(dtype=float, copy=False)
@@ -492,20 +475,21 @@ def _time_of_flight_data_events(
     ltotal = sc.bins_like(etos, ltotal).bins.constituents["data"]
     etos = etos.bins.constituents["data"]
 
-    # Compute a pulse index for every event: it is the index of the pulse within a
-    # frame period. When there is no pulse skipping, those are all zero. When there is
-    # pulse skipping, the index ranges from zero to pulse_stride - 1.
-    if pulse_stride == 1:
-        pulse_index = sc.zeros(sizes=etos.sizes)
-    else:
+    pulse_index = None
+    pulse_period = lookup.coords["pulse_period"].to(unit=eto_unit)
+    pulse_stride = lookup.coords["pulse_stride"].value
+
+    if pulse_stride > 1:
+        # Compute a pulse index for every event: it is the index of the pulse within a
+        # frame period. The index ranges from zero to pulse_stride - 1.
         etz_unit = 'ns'
         etz = (
             da.bins.coords["event_time_zero"]
             .bins.constituents["data"]
             .to(unit=etz_unit, copy=False)
         )
-        pulse_period = pulse_period.to(unit=etz_unit, dtype=int)
-        frame_period = pulse_period * pulse_stride
+        pulse_period_ns = pulse_period.to(unit=etz_unit, dtype=int)
+        frame_period = pulse_period_ns * pulse_stride
         # Define a common reference time using epoch as a base, but making sure that it
         # is aligned with the pulse_period and the frame_period.
         # We need to use a global reference time instead of simply taking the minimum
@@ -513,17 +497,17 @@ def _time_of_flight_data_events(
         # may not be the first event of the first pulse for all chunks. This would lead
         # to inconsistent pulse indices.
         epoch = sc.datetime(0, unit=etz_unit)
-        diff_to_epoch = (etz.min() - epoch) % pulse_period
+        diff_to_epoch = (etz.min() - epoch) % pulse_period_ns
         # Here we offset the reference by half a pulse period to avoid errors from
         # fluctuations in the event_time_zeros in the data. They are triggered by the
         # neutron source, and may not always be exactly separated by the pulse period.
         # While fluctuations will exist, they will be small, and offsetting the times
         # by half a pulse period is a simple enough fix.
-        reference = epoch + diff_to_epoch - (pulse_period // 2)
+        reference = epoch + diff_to_epoch - (pulse_period_ns // 2)
         # Use in-place operations to avoid large allocations
         pulse_index = etz - reference
         pulse_index %= frame_period
-        pulse_index //= pulse_period
+        pulse_index //= pulse_period_ns
 
         # Apply the pulse_stride_offset
         if pulse_stride_offset is None:
@@ -531,6 +515,7 @@ def _time_of_flight_data_events(
                 pulse_index=pulse_index,
                 ltotal=ltotal,
                 event_time_offset=etos,
+                pulse_period=pulse_period,
                 pulse_stride=pulse_stride,
                 interp=interp,
             )
@@ -538,21 +523,86 @@ def _time_of_flight_data_events(
         pulse_index %= pulse_stride
 
     # Compute time-of-flight for all neutrons using the interpolator
-    tofs = interp(pulse_index=pulse_index, ltotal=ltotal, event_time_offset=etos)
+    tofs = interp(
+        ltotal=ltotal,
+        event_time_offset=etos,
+        pulse_index=pulse_index,
+        pulse_period=pulse_period,
+    )
 
     parts = da.bins.constituents
     parts["data"] = tofs
     return da.bins.assign_coords(tof=_bins_no_validate(**parts))
 
 
-def time_of_flight_data(
-    da: RawData,
+def detector_ltotal_from_straight_line_approximation(
+    detector_beamline: CalibratedBeamline[RunType],
+) -> DetectorLtotal[RunType]:
+    """
+    Compute Ltotal for the detector pixels.
+    This is a naive straight-line approximation to Ltotal based on basic component
+    positions.
+
+    Parameters
+    ----------
+    detector_beamline:
+        Beamline data for the detector that contains the positions necessary to compute
+        the straight-line approximation to Ltotal (source, sample, and detector
+        positions).
+    """
+    graph = scn.conversion.graph.beamline.beamline(scatter=True)
+    return DetectorLtotal[RunType](
+        detector_beamline.transform_coords(
+            "Ltotal", graph=graph, keep_intermediate=False
+        ).coords["Ltotal"]
+    )
+
+
+def monitor_ltotal_from_straight_line_approximation(
+    monitor_beamline: CalibratedMonitor[RunType, MonitorType],
+) -> MonitorLtotal[RunType, MonitorType]:
+    """
+    Compute Ltotal for the monitor.
+    This is a naive straight-line approximation to Ltotal based on basic component
+    positions.
+
+    Parameters
+    ----------
+    monitor_beamline:
+        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)
+    return MonitorLtotal[RunType, MonitorType](
+        monitor_beamline.transform_coords(
+            "Ltotal", graph=graph, keep_intermediate=False
+        ).coords["Ltotal"]
+    )
+
+
+def _compute_tof_data(
+    da: sc.DataArray,
+    lookup: sc.DataArray,
+    ltotal: sc.Variable,
+    pulse_stride_offset: int,
+) -> sc.DataArray:
+    if da.bins is None:
+        return _time_of_flight_data_histogram(da=da, lookup=lookup, ltotal=ltotal)
+    else:
+        return _time_of_flight_data_events(
+            da=da,
+            lookup=lookup,
+            ltotal=ltotal,
+            pulse_stride_offset=pulse_stride_offset,
+        )
+
+
+def detector_time_of_flight_data(
+    detector_data: DetectorData[RunType],
     lookup: TimeOfFlightLookupTable,
-    ltotal: Ltotal,
-    pulse_period: PulsePeriod,
-    pulse_stride: PulseStride,
+    ltotal: DetectorLtotal[RunType],
     pulse_stride_offset: PulseStrideOffset,
-) -> TofData:
+) -> DetectorTofData[RunType]:
     """
     Convert the time-of-arrival data to time-of-flight data using a lookup table.
     The output data will have a time-of-flight coordinate.
@@ -567,33 +617,55 @@ def time_of_flight_data(
         arrival.
     ltotal:
         Total length of the flight path from the source to the detector.
-    pulse_period:
-        Period of the source pulses, i.e., time between consecutive pulse starts.
-    pulse_stride:
-        Stride of used pulses. Usually 1, but may be a small integer when
-        pulse-skipping.
     pulse_stride_offset:
         When pulse-skipping, the offset of the first pulse in the stride. This is
         typically zero but can be a small integer < pulse_stride.
     """
-
-    if da.bins is None:
-        out = _time_of_flight_data_histogram(
-            da=da, lookup=lookup, ltotal=ltotal, pulse_period=pulse_period
+    return DetectorTofData[RunType](
+        _compute_tof_data(
+            da=detector_data,
+            lookup=lookup,
+            ltotal=ltotal,
+            pulse_stride_offset=pulse_stride_offset,
         )
-    else:
-        out = _time_of_flight_data_events(
-            da=da,
+    )
+
+
+def monitor_time_of_flight_data(
+    monitor_data: MonitorData[RunType, MonitorType],
+    lookup: TimeOfFlightLookupTable,
+    ltotal: MonitorLtotal[RunType, MonitorType],
+    pulse_stride_offset: PulseStrideOffset,
+) -> MonitorTofData[RunType, MonitorType]:
+    """
+    Convert the time-of-arrival data to time-of-flight data using a lookup table.
+    The output data will have a time-of-flight coordinate.
+
+    Parameters
+    ----------
+    da:
+        Raw monitor data loaded from a NeXus file, e.g., NXmonitor containing
+        NXevent_data.
+    lookup:
+        Lookup table giving time-of-flight as a function of distance and time of
+        arrival.
+    ltotal:
+        Total length of the flight path from the source to the monitor.
+    pulse_stride_offset:
+        When pulse-skipping, the offset of the first pulse in the stride. This is
+        typically zero but can be a small integer < pulse_stride.
+    """
+    return MonitorTofData[RunType, MonitorType](
+        _compute_tof_data(
+            da=monitor_data,
             lookup=lookup,
             ltotal=ltotal,
-            pulse_period=pulse_period,
-            pulse_stride=pulse_stride,
             pulse_stride_offset=pulse_stride_offset,
         )
-    return TofData(out)
+    )
 
 
-def resample_tof_data(da: TofData) -> ResampledTofData:
+def _resample_tof_data(da: sc.DataArray) -> sc.DataArray:
     """
     Histogrammed data that has been converted to `tof` will typically have
     unsorted bin edges (due to either wrapping of `time_of_flight` or wavelength
@@ -626,13 +698,29 @@ def resample_tof_data(da: TofData) -> ResampledTofData:
     coord = da.coords["tof"]
     bin_width = (coord[dim, 1:] - coord[dim, :-1]).nanmedian()
     rehist = events.hist(tof=bin_width)
-    return ResampledTofData(
-        rehist.assign_coords(
-            {key: var for key, var in da.coords.items() if dim not in var.dims}
-        )
+    return rehist.assign_coords(
+        {key: var for key, var in da.coords.items() if dim not in var.dims}
     )
 
 
+def resample_detector_time_of_flight_data(
+    da: DetectorTofData[RunType],
+) -> ResampledDetectorTofData[RunType]:
+    """
+    Resample the detector time-of-flight data to ensure that the bin edges are sorted.
+    """
+    return ResampledDetectorTofData(_resample_tof_data(da))
+
+
+def resample_monitor_time_of_flight_data(
+    da: MonitorTofData[RunType, MonitorType],
+) -> ResampledMonitorTofData[RunType, MonitorType]:
+    """
+    Resample the monitor time-of-flight data to ensure that the bin edges are sorted.
+    """
+    return ResampledMonitorTofData(_resample_tof_data(da))
+
+
 def default_parameters() -> dict:
     """
     Default parameters of the time-of-flight workflow.
@@ -651,4 +739,10 @@ def providers() -> tuple[Callable]:
     """
     Providers of the time-of-flight workflow.
     """
-    return (compute_tof_lookup_table, time_of_flight_data)
+    return (
+        compute_tof_lookup_table,
+        detector_time_of_flight_data,
+        monitor_time_of_flight_data,
+        detector_ltotal_from_straight_line_approximation,
+        monitor_ltotal_from_straight_line_approximation,
+    )

ess/reduce/time_of_flight/fakes.py

@@ -28,9 +28,9 @@ class FakeBeamline:
         import math
 
         import tof as tof_pkg
-        from tof.facilities.ess_pulse import pulse
+        from tof.facilities.ess_pulse import frequency as ess_frequency
 
-        self.frequency = pulse.frequency
+        self.frequency = ess_frequency
         self.npulses = math.ceil((run_length * self.frequency).to(unit="").value)
         self.events_per_pulse = events_per_pulse
         if source_position is None:

ess/reduce/time_of_flight/interpolator_numba.py

@@ -8,111 +8,82 @@ from numba import njit, prange
 def interpolate(
     x: np.ndarray,
     y: np.ndarray,
-    z: np.ndarray,
     values: np.ndarray,
     xp: np.ndarray,
     yp: np.ndarray,
-    zp: np.ndarray,
+    xoffset: np.ndarray | None,
+    deltax: float,
     fill_value: float,
     out: np.ndarray,
 ):
     """
-    Linear interpolation of data on a 3D regular grid.
+    Linear interpolation of data on a 2D regular grid.
 
     Parameters
     ----------
     x:
-        1D array of grid edges along the x-axis. They must be linspaced.
+        1D array of grid edges along the x-axis (size nx). 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.
+        1D array of grid edges along the y-axis (size ny). They must be linspaced.
     values:
-        3D array of values on the grid. The shape must be (nz, ny, nx).
+        2D array of values on the grid. The shape must be (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).
+    xoffset:
+        1D array of integer offsets to apply to the x-coordinates (size N).
+    deltax:
+        Multiplier to apply to the integer offsets (i.e. the step size).
     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)):
+    if not (len(xp) == len(yp) == 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
+    norm = one_over_dx * one_over_dy
 
     for i in prange(npoints):
-        xx = xp[i]
+        xx = xp[i] + (xoffset[i] * deltax if xoffset is not None else 0.0)
         yy = yp[i]
-        zz = zp[i]
-
-        if (
-            (xx < xmin)
-            or (xx > xmax)
-            or (yy < ymin)
-            or (yy > ymax)
-            or (zz < zmin)
-            or (zz > zmax)
-        ):
+
+        if (xx < xmin) or (xx > xmax) or (yy < ymin) or (yy > ymax):
             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]
+
+            a11 = values[iy, ix]
+            a21 = values[iy, ix + 1]
+            a12 = values[iy + 1, ix]
+            a22 = values[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)
-                )
+                (y2 - yy) * (x2mxx * a11 + xxmx1 * a21)
+                + (yy - y1) * (x2mxx * a12 + xxmx1 * a22)
             ) * norm
 
 
@@ -121,12 +92,11 @@ class Interpolator:
         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).
+        Interpolator for 2D regular grid data (Numba implementation).
 
         Parameters
         ----------
@@ -134,31 +104,32 @@ class Interpolator:
             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).
+            2D array of values on the grid. The shape must be (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
+        self,
+        times: np.ndarray,
+        distances: np.ndarray,
+        pulse_period: float = 0.0,
+        pulse_index: np.ndarray | None = None,
     ) -> 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,
+            xoffset=pulse_index,
+            deltax=pulse_period,
             fill_value=self.fill_value,
             out=out,
         )

ess/reduce/time_of_flight/interpolator_scipy.py

@@ -9,7 +9,6 @@ class Interpolator:
         self,
         time_edges: np.ndarray,
         distance_edges: np.ndarray,
-        pulse_edges: np.ndarray,
         values: np.ndarray,
         method: str = "linear",
         bounds_error: bool = False,
@@ -17,18 +16,16 @@ class Interpolator:
         **kwargs,
     ):
         """
-        Interpolator for 3D regular grid data (SciPy implementation).
+        Interpolator for 2D regular grid data (SciPy implementation).
 
         Parameters
         ----------
         time_edges:
-            1D array of time edges.
+            1D array of time edges (length N_time).
         distance_edges:
-            1D array of distance edges.
-        pulse_edges:
-            1D array of pulse edges.
+            1D array of distance edges (length N_dist).
         values:
-            3D array of values on the grid. The shape must be (nz, ny, nx).
+            2D array of values on the grid. The shape must be (N_dist, N_time).
         method:
             Method of interpolation. Default is "linear".
         bounds_error:
@@ -42,11 +39,7 @@ class Interpolator:
         from scipy.interpolate import RegularGridInterpolator
 
         self._interp = RegularGridInterpolator(
-            (
-                pulse_edges,
-                distance_edges,
-                time_edges,
-            ),
+            (distance_edges, time_edges),
             values,
             method=method,
             bounds_error=bounds_error,
@@ -55,6 +48,12 @@ class Interpolator:
         )
 
     def __call__(
-        self, times: np.ndarray, distances: np.ndarray, pulse_indices: np.ndarray
+        self,
+        times: np.ndarray,
+        distances: np.ndarray,
+        pulse_period: float = 0.0,
+        pulse_index: np.ndarray | None = None,
     ) -> np.ndarray:
-        return self._interp((pulse_indices, distances, times))
+        if pulse_index is not None:
+            times = times + (pulse_index * pulse_period)
+        return self._interp((distances, times))

ess/reduce/time_of_flight/types.py

@@ -4,12 +4,10 @@
 from dataclasses import dataclass
 from typing import NewType
 
+import sciline as sl
 import scipp as sc
 
-Ltotal = NewType("Ltotal", sc.Variable)
-"""
-Total length of the flight path from the source to the detector.
-"""
+from ..nexus.types import MonitorType, RunType
 
 
 @dataclass
@@ -107,30 +105,58 @@ When pulse-skipping, the offset of the first pulse in the stride. This is typica
 zero but can be a small integer < pulse_stride. If None, a guess is made.
 """
 
-RawData = NewType("RawData", sc.DataArray)
-"""
-Raw detector data loaded from a NeXus file, e.g., NXdetector containing NXevent_data.
-"""
 
-TofData = NewType("TofData", sc.DataArray)
-"""
-Detector data with time-of-flight coordinate.
-"""
+class DetectorLtotal(sl.Scope[RunType, sc.Variable], sc.Variable):
+    """Total path length of neutrons from source to detector (L1 + L2)."""
 
-ResampledTofData = NewType("ResampledTofData", sc.DataArray)
-"""
-Histogrammed detector data with time-of-flight coordinate, that has been resampled.
 
-Histogrammed data that has been converted to `tof` will typically have
-unsorted bin edges (due to either wrapping of `time_of_flight` or wavelength
-overlap between subframes).
-We thus resample the data to ensure that the bin edges are sorted.
-It makes use of the ``to_events`` helper which generates a number of events in each
-bin with a uniform distribution. The new events are then histogrammed using a set of
-sorted bin edges to yield a new histogram with sorted bin edges.
+class MonitorLtotal(sl.Scope[RunType, MonitorType, sc.Variable], sc.Variable):
+    """Total path length of neutrons from source to monitor."""
 
-WARNING:
-This function is highly experimental, has limitations and should be used with
-caution. It is a workaround to the issue that rebinning data with unsorted bin
-edges is not supported in scipp.
-"""
+
+class DetectorTofData(sl.Scope[RunType, sc.DataArray], sc.DataArray):
+    """Detector data with time-of-flight coordinate."""
+
+
+class MonitorTofData(sl.Scope[RunType, MonitorType, sc.DataArray], sc.DataArray):
+    """Monitor data with time-of-flight coordinate."""
+
+
+class ResampledDetectorTofData(sl.Scope[RunType, sc.DataArray], sc.DataArray):
+    """
+    Histogrammed detector data with time-of-flight coordinate, that has been resampled.
+
+    Histogrammed data that has been converted to `tof` will typically have
+    unsorted bin edges (due to either wrapping of `time_of_flight` or wavelength
+    overlap between subframes).
+    We thus resample the data to ensure that the bin edges are sorted.
+    It makes use of the ``to_events`` helper which generates a number of events in each
+    bin with a uniform distribution. The new events are then histogrammed using a set of
+    sorted bin edges to yield a new histogram with sorted bin edges.
+
+    WARNING:
+    This function is highly experimental, has limitations and should be used with
+    caution. It is a workaround to the issue that rebinning data with unsorted bin
+    edges is not supported in scipp.
+    """
+
+
+class ResampledMonitorTofData(
+    sl.Scope[RunType, MonitorType, sc.DataArray], sc.DataArray
+):
+    """
+    Histogrammed monitor data with time-of-flight coordinate, that has been resampled.
+
+    Histogrammed data that has been converted to `tof` will typically have
+    unsorted bin edges (due to either wrapping of `time_of_flight` or wavelength
+    overlap between subframes).
+    We thus resample the data to ensure that the bin edges are sorted.
+    It makes use of the ``to_events`` helper which generates a number of events in each
+    bin with a uniform distribution. The new events are then histogrammed using a set of
+    sorted bin edges to yield a new histogram with sorted bin edges.
+
+    WARNING:
+    This function is highly experimental, has limitations and should be used with
+    caution. It is a workaround to the issue that rebinning data with unsorted bin
+    edges is not supported in scipp.
+    """

ess/reduce/time_of_flight/workflow.py

@@ -0,0 +1,61 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright (c) 2025 Scipp contributors (https://github.com/scipp)
+from collections.abc import Iterable
+
+import sciline
+
+from ..nexus import GenericNeXusWorkflow
+from ..utils import prune_type_vars
+from .eto_to_tof import default_parameters, providers
+
+
+def GenericTofWorkflow(
+    *,
+    run_types: Iterable[sciline.typing.Key] | None = None,
+    monitor_types: Iterable[sciline.typing.Key] | None = None,
+) -> sciline.Pipeline:
+    """
+    Generic workflow for computing the neutron time-of-flight for detector and monitor
+    data.
+    This workflow builds on the ``GenericNeXusWorkflow`` and computes time-of-flight
+    from a lookup table that is created from the chopper settings, detector Ltotal and
+    the neutron time-of-arrival.
+
+    It is possible to limit which run types and monitor types
+    are supported by the returned workflow.
+    This is useful to reduce the size of the workflow and make it easier to inspect.
+    Make sure to add *all* required run types and monitor types when using this feature.
+
+    Attention
+    ---------
+    Filtering by run type and monitor type does not work with nested type vars.
+    E.g., if you have a type like ``Outer[Inner[RunType]]``, this type and its
+    provider will be removed.
+
+    Parameters
+    ----------
+    run_types:
+        List of run types to include in the workflow. If not provided, all run types
+        are included.
+        Must be a possible value of :class:`ess.reduce.nexus.types.RunType`.
+    monitor_types:
+        List of monitor types to include in the workflow. If not provided, all monitor
+        types are included.
+        Must be a possible value of :class:`ess.reduce.nexus.types.MonitorType`.
+
+    Returns
+    -------
+    :
+        The workflow.
+    """
+    wf = GenericNeXusWorkflow(run_types=run_types, monitor_types=monitor_types)
+
+    for provider in providers():
+        wf.insert(provider)
+    for key, value in default_parameters().items():
+        wf[key] = value
+
+    if run_types is not None or monitor_types is not None:
+        prune_type_vars(wf, run_types=run_types, monitor_types=monitor_types)
+
+    return wf

ess/reduce/utils.py

@@ -0,0 +1,36 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright (c) 2025 Scipp contributors (https://github.com/scipp)
+
+from collections.abc import Iterable
+from typing import Any
+
+import sciline
+
+from .nexus.types import MonitorType, RunType
+
+
+def prune_type_vars(
+    workflow: sciline.Pipeline,
+    *,
+    run_types: Iterable[sciline.typing.Key] | None,
+    monitor_types: Iterable[sciline.typing.Key] | None,
+) -> None:
+    # Remove all nodes that use a run type or monitor types that is
+    # not listed in the function arguments.
+    excluded_run_types = excluded_type_args(RunType, run_types)
+    excluded_monitor_types = excluded_type_args(MonitorType, monitor_types)
+    excluded_types = excluded_run_types | excluded_monitor_types
+
+    graph = workflow.underlying_graph
+    to_remove = [
+        node for node in graph if excluded_types & set(getattr(node, "__args__", set()))
+    ]
+    graph.remove_nodes_from(to_remove)
+
+
+def excluded_type_args(
+    type_var: Any, keep: Iterable[sciline.typing.Key] | None
+) -> set[sciline.typing.Key]:
+    if keep is None:
+        return set()
+    return set(type_var.__constraints__) - set(keep)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: essreduce
-Version: 25.4.1
+Version: 25.5.0
 Summary: Common data reduction tools for the ESS facility
 Author: Scipp contributors
 License: BSD 3-Clause License
@@ -61,7 +61,7 @@ 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"
+Requires-Dist: tof>=25.05.0; extra == "test"
 Dynamic: license-file
 
 [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg)](CODE_OF_CONDUCT.md)

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

@@ -6,6 +6,7 @@ ess/reduce/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ess/reduce/streaming.py,sha256=TBttQV5WdSpUKh38J0pdv53seMWtUFswxd6-ltaZb_M,17403
 ess/reduce/ui.py,sha256=zmorAbDwX1cU3ygDT--OP58o0qU7OBcmJz03jPeYSLA,10884
 ess/reduce/uncertainty.py,sha256=LR4O6ApB6Z-W9gC_XW0ajupl8yFG-du0eee1AX_R-gk,6990
+ess/reduce/utils.py,sha256=RBAfJRNil6JjVF-jPaxeL0ssEEfPBBQEZ3ObEorpDLo,1132
 ess/reduce/workflow.py,sha256=sL34T_2Cjl_8iFlegujxI9VyOUwo6erVC8pOXnfWgYw,3060
 ess/reduce/live/__init__.py,sha256=jPQVhihRVNtEDrE20PoKkclKV2aBF1lS7cCHootgFgI,204
 ess/reduce/live/raw.py,sha256=66qV0G2rP8gK5tXuk-syTlDLE2jT3ehfmSnET7Xzfd0,24392
@@ -16,16 +17,17 @@ ess/reduce/nexus/_nexus_loader.py,sha256=5N48AMJx1AaFZb6WZPPbVKUlXyFMVVtZrn7Bae5
 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=vTQD4oQ5JKBHAYy9LWFICSo-dhVi3wX5IinMgjRDtF8,9806
-ess/reduce/nexus/workflow.py,sha256=EiD6-58eGwoN5fbo47UTZy_oYFitCbwlIH-xqDOSp4c,24326
+ess/reduce/nexus/workflow.py,sha256=zrBQGNLUxmvqXewe9uNUg9aP43_glfFD6nh5VGAtBK4,23456
 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=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/__init__.py,sha256=v86c3zNTMMqZoR9eHaK0Q-JnzsbOI6XsBGI3mgy2CiU,1469
+ess/reduce/time_of_flight/eto_to_tof.py,sha256=ckXoSrltXdciYwipyUkF-DVtbsz2_XSLZvX2qJ_d8Bs,28238
+ess/reduce/time_of_flight/fakes.py,sha256=0gtbSX3ZQilaM4ZP5dMr3fqbnhpyoVsZX2YEb8GgREE,4489
+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/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/time_of_flight/types.py,sha256=xhziZQaCB4XAxvVopHHp2DZSBj7PUt-xgPzEDpni05g,6321
+ess/reduce/time_of_flight/workflow.py,sha256=-g9IyAz7sNrgL-5RZLUTlfjTb2YFej1Xig6GiC7c1bI,2156
 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
@@ -38,9 +40,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.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.5.0.dist-info/licenses/LICENSE,sha256=nVEiume4Qj6jMYfSRjHTM2jtJ4FGu0g-5Sdh7osfEYw,1553
+essreduce-25.5.0.dist-info/METADATA,sha256=yfoZMb19ayIQyCRk5_WPEuvrWGAYApWIs4Wr-69nwO8,3768
+essreduce-25.5.0.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+essreduce-25.5.0.dist-info/entry_points.txt,sha256=PMZOIYzCifHMTe4pK3HbhxUwxjFaZizYlLD0td4Isb0,66
+essreduce-25.5.0.dist-info/top_level.txt,sha256=0JxTCgMKPLKtp14wb1-RKisQPQWX7i96innZNvHBr-s,4
+essreduce-25.5.0.dist-info/RECORD,,

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

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