essreduce 25.11.6__py3-none-any.whl → 25.12.1__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/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/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:
@@ -313,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(
@@ -353,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.
@@ -365,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
@@ -375,7 +395,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 +523,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.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: essreduce
-Version: 25.11.6
+Version: 25.12.1
 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.1.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
@@ -10,25 +10,25 @@ 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
 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=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=WkCmp8aDpnFTSbPnWosjb17oY5TnCnPDbL66ZeCHo_E,18849
+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.1.dist-info/licenses/LICENSE,sha256=nVEiume4Qj6jMYfSRjHTM2jtJ4FGu0g-5Sdh7osfEYw,1553
+essreduce-25.12.1.dist-info/METADATA,sha256=ALXVOH9hCHFE8rKM8p14XLErG_3gk24HyvWwhX1FzKc,1988
+essreduce-25.12.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+essreduce-25.12.1.dist-info/entry_points.txt,sha256=PMZOIYzCifHMTe4pK3HbhxUwxjFaZizYlLD0td4Isb0,66
+essreduce-25.12.1.dist-info/top_level.txt,sha256=0JxTCgMKPLKtp14wb1-RKisQPQWX7i96innZNvHBr-s,4
+essreduce-25.12.1.dist-info/RECORD,,