essreduce 25.5.2__py3-none-any.whl → 25.5.3__py3-none-any.whl

ess/reduce/time_of_flight/__init__.py

@@ -6,14 +6,8 @@ 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_detector_time_of_flight_data,
-    resample_monitor_time_of_flight_data,
-)
+from .eto_to_tof import default_parameters, providers
 from .simulation import simulate_beamline
-from .to_events import to_events
 from .types import (
     DetectorLtotal,
     DetectorTofData,
@@ -25,8 +19,6 @@ from .types import (
     PulsePeriod,
     PulseStride,
     PulseStrideOffset,
-    ResampledDetectorTofData,
-    ResampledMonitorTofData,
     SimulationResults,
     TimeOfFlightLookupTable,
     TimeOfFlightLookupTableFilename,
@@ -37,17 +29,17 @@ from .workflow import GenericTofWorkflow, TofLutProvider
 __all__ = [
     "DetectorLtotal",
     "DetectorTofData",
+    "DetectorTofData",
     "DistanceResolution",
     "GenericTofWorkflow",
     "LookupTableRelativeErrorThreshold",
     "LtotalRange",
     "MonitorLtotal",
     "MonitorTofData",
+    "MonitorTofData",
     "PulsePeriod",
     "PulseStride",
     "PulseStrideOffset",
-    "ResampledDetectorTofData",
-    "ResampledMonitorTofData",
     "SimulationResults",
     "TimeOfFlightLookupTable",
     "TimeOfFlightLookupTableFilename",
@@ -55,8 +47,5 @@ __all__ = [
     "TofLutProvider",
     "default_parameters",
     "providers",
-    "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

@@ -27,7 +27,7 @@ from ..nexus.types import (
     MonitorType,
     RunType,
 )
-from .to_events import to_events
+from .resample import rebin_strictly_increasing
 from .types import (
     DetectorLtotal,
     DetectorTofData,
@@ -39,8 +39,6 @@ from .types import (
     PulsePeriod,
     PulseStride,
     PulseStrideOffset,
-    ResampledDetectorTofData,
-    ResampledMonitorTofData,
     SimulationResults,
     TimeOfFlightLookupTable,
     TimeResolution,
@@ -586,7 +584,8 @@ def _compute_tof_data(
     pulse_stride_offset: int,
 ) -> sc.DataArray:
     if da.bins is None:
-        return _time_of_flight_data_histogram(da=da, lookup=lookup, ltotal=ltotal)
+        data = _time_of_flight_data_histogram(da=da, lookup=lookup, ltotal=ltotal)
+        return rebin_strictly_increasing(data, dim='tof')
     else:
         return _time_of_flight_data_events(
             da=da,
@@ -664,62 +663,6 @@ def monitor_time_of_flight_data(
     )
 
 
-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
-    overlap between subframes).
-    This function re-histograms 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.
-
-    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.
-    As such, this function is not part of the default set of providers, and needs to be
-    inserted manually into the workflow.
-
-    Parameters
-    ----------
-    da:
-        Histogrammed data with the time-of-flight coordinate.
-    """
-    dim = next(iter(set(da.dims) & {"time_of_flight", "tof"}))
-    data = da.rename_dims({dim: "tof"}).drop_coords(
-        [name for name in da.coords if name != "tof"]
-    )
-    events = to_events(data, "event")
-
-    # Define a new bin width, close to the original bin width.
-    # TODO: this could be a workflow parameter
-    coord = da.coords["tof"]
-    bin_width = (coord[dim, 1:] - coord[dim, :-1]).nanmedian()
-    rehist = events.hist(tof=bin_width)
-    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.

ess/reduce/time_of_flight/resample.py

@@ -0,0 +1,97 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright (c) 2025 Scipp contributors (https://github.com/scipp)
+
+
+import numpy as np
+import scipp as sc
+
+
+def find_strictly_increasing_sections(var: sc.Variable) -> list[slice]:
+    """
+    Find strictly increasing sections in a coordinate dimension (minimum length 2).
+
+    Parameters
+    ----------
+    var:
+        The variable to analyze, which should be one-dimensional.
+
+    Returns
+    -------
+    sections:
+        Slice objects that can be used extract strictly increasing sections.
+    """
+    values = var.values
+    finite = np.isfinite(values)
+    increasing = (np.sign(np.diff(values)) > 0) & finite[:-1] & finite[1:]
+    # 1 marks the start of an increasing section, -1 marks the end
+    transitions = np.diff(np.concatenate(([False], increasing, [False])).astype(int))
+    section_starts = np.where(transitions == 1)[0]
+    section_ends = np.where(transitions == -1)[0] + np.array(1)
+    return [
+        slice(start, end)
+        for start, end in zip(section_starts, section_ends, strict=True)
+        if end - start >= 2  # Ensure section has at least 2 points
+    ]
+
+
+def get_min_max(
+    var: sc.Variable, *, dim: str, slices: list[slice]
+) -> tuple[sc.Variable, sc.Variable]:
+    if not slices:
+        raise ValueError("No strictly increasing sections found.")
+    combined = sc.concat([var[dim, slice] for slice in slices], dim)
+    return combined.min(), combined.max()
+
+
+def make_regular_grid(
+    var: sc.Variable, *, dim: str, slices: list[slice]
+) -> sc.Variable:
+    """
+    Create a regular grid variable based on the min and max of the slices.
+
+    The grid is constructed such that it includes the minimum and maximum values
+    of the strictly increasing sections, with a step size equal to the difference
+    between the first two values of the section with the minimum start value (which is
+    not necessarily the first section).
+    """
+    min_val, max_val = get_min_max(var, dim=dim, slices=slices)
+    first: sc.Variable | None = None
+    for s in slices:
+        first = var[dim, s]
+        if sc.identical(first[0], min_val):
+            break
+    if first is None:
+        # This should not happen if slices are correctly identified and passed from
+        # find_strictly_increasing_sections.
+        raise ValueError("Section is not strictly increasing.")
+    step = first[1] - first[0]
+    return sc.arange(
+        dim=dim,
+        start=min_val.value,
+        stop=max_val.value + step.value,  # Ensure the last bin edge is included
+        step=step.value,
+        unit=step.unit,
+        dtype=step.dtype,
+    )
+
+
+def rebin_strictly_increasing(da: sc.DataArray, dim: str) -> sc.DataArray:
+    """
+    Find strictly monotonic sections in a coordinate dimension and rebin the data array
+    into a regular grid based on these sections.
+    """
+    # Ensure the dimension is named like the coordinate.
+    da = da.rename_dims({da.coords[dim].dim: dim})
+    slices = find_strictly_increasing_sections(da.coords[dim])
+    if len(slices) == 1:
+        return da[dim, slices[0]]
+    if not slices:
+        raise ValueError("No strictly increasing sections found.")
+    if da.coords[dim].dtype not in (sc.DType.float64, sc.DType.float32):
+        # rebin does not like integer coords.
+        da = da.assign_coords({dim: da.coords[dim].to(dtype='float64')})
+    # Slices refer to the indices in the coord, which are bin edges. For slicing data
+    # we need to stop at the last index minus one.
+    sections = [da[dim, section.start : section.stop - 1] for section in slices]
+    edges = make_regular_grid(da.coords[dim], dim=dim, slices=slices)
+    return sc.reduce([sc.rebin(section, {dim: edges}) for section in sections]).sum()

ess/reduce/time_of_flight/types.py

@@ -130,43 +130,3 @@ class DetectorTofData(sl.Scope[RunType, sc.DataArray], sc.DataArray):
 
 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

@@ -34,6 +34,7 @@ def GenericTofWorkflow(
     """
     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.

{essreduce-25.5.2.dist-info → essreduce-25.5.3.dist-info}/METADATA

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

{essreduce-25.5.2.dist-info → essreduce-25.5.3.dist-info}/RECORD

@@ -18,15 +18,15 @@ ess/reduce/nexus/json_nexus.py,sha256=QrVc0p424nZ5dHX9gebAJppTw6lGZq9404P_OFl1gi
 ess/reduce/nexus/types.py,sha256=DE82JnbgpTlQnt7UN2a2Gur2N9QupV3CDL9j4Iy4lsE,9178
 ess/reduce/nexus/workflow.py,sha256=Ytt80-muk5EiXmip890ahb_m5DQqlTGRQUyaTVXRNzo,24568
 ess/reduce/scripts/grow_nexus.py,sha256=hET3h06M0xlJd62E3palNLFvJMyNax2kK4XyJcOhl-I,3387
-ess/reduce/time_of_flight/__init__.py,sha256=UxMvY4aFkhZQmIbGSo4FBpBGRD2wDJbczLMVqcEhCSg,1583
-ess/reduce/time_of_flight/eto_to_tof.py,sha256=JCu7C3AmJnB7GDJrL76oPjgxGesp67nct9xXRp3O8E4,28204
+ess/reduce/time_of_flight/__init__.py,sha256=jbvLcVgODURuweuicrsDqEYqiL_GNJa_t4c5ik344Ro,1269
+ess/reduce/time_of_flight/eto_to_tof.py,sha256=FYujFQSqDoxOLiVbNId4YcpuhKmNdvtBMUr9nK5poIk,26070
 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/resample.py,sha256=Opmi-JA4zNH725l9VB99U4O9UlM37f5ACTCGtwBcows,3718
 ess/reduce/time_of_flight/simulation.py,sha256=vo-zjG6t-PLetv2_nj4dhMSTEyTQ1MsrhlM2XkhOtf8,3632
-ess/reduce/time_of_flight/to_events.py,sha256=w9mHpnWd3vwN2ouob-GK_1NPrTjCaOzPuC2QuEey-m0,4342
-ess/reduce/time_of_flight/types.py,sha256=OQeMYNN7QinXs_HDcoE6kkh_xNcyD0dEJWtnHQy5-uA,6675
-ess/reduce/time_of_flight/workflow.py,sha256=mwNEXwvOnm-M8n4G9Cau1Vuyqzo4qMrhCbZ-S5vszW4,3181
+ess/reduce/time_of_flight/types.py,sha256=LJlK_5u5yeFj2TLnz-LI3eApkp8vEg5q8OncHkmHjj8,4844
+ess/reduce/time_of_flight/workflow.py,sha256=BAIMeA1bSJlS6JSG7r2srVdtBsAK6VD0DuOiYZuQvNg,3182
 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
@@ -39,9 +39,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.5.2.dist-info/licenses/LICENSE,sha256=nVEiume4Qj6jMYfSRjHTM2jtJ4FGu0g-5Sdh7osfEYw,1553
-essreduce-25.5.2.dist-info/METADATA,sha256=LNEHFWDdswQNdu6s_5_eVHlmkVz35siN2fvirZ0KhFI,3768
-essreduce-25.5.2.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
-essreduce-25.5.2.dist-info/entry_points.txt,sha256=PMZOIYzCifHMTe4pK3HbhxUwxjFaZizYlLD0td4Isb0,66
-essreduce-25.5.2.dist-info/top_level.txt,sha256=0JxTCgMKPLKtp14wb1-RKisQPQWX7i96innZNvHBr-s,4
-essreduce-25.5.2.dist-info/RECORD,,
+essreduce-25.5.3.dist-info/licenses/LICENSE,sha256=nVEiume4Qj6jMYfSRjHTM2jtJ4FGu0g-5Sdh7osfEYw,1553
+essreduce-25.5.3.dist-info/METADATA,sha256=WNGTtuRJz8G7G3mFV0sWWQy5ByR1uzJ3iDQi7hVyYps,3768
+essreduce-25.5.3.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+essreduce-25.5.3.dist-info/entry_points.txt,sha256=PMZOIYzCifHMTe4pK3HbhxUwxjFaZizYlLD0td4Isb0,66
+essreduce-25.5.3.dist-info/top_level.txt,sha256=0JxTCgMKPLKtp14wb1-RKisQPQWX7i96innZNvHBr-s,4
+essreduce-25.5.3.dist-info/RECORD,,

ess/reduce/time_of_flight/to_events.py

@@ -1,111 +0,0 @@
-# SPDX-License-Identifier: BSD-3-Clause
-# Copyright (c) 2025 Scipp contributors (https://github.com/scipp)
-
-from functools import reduce
-
-import numpy as np
-import scipp as sc
-
-
-def to_events(
-    da: sc.DataArray, event_dim: str, events_per_bin: int = 500
-) -> sc.DataArray:
-    """
-    Convert a histogrammed data array to an event list.
-    The generated events have a uniform distribution within each bin.
-    Each dimension with a bin-edge coordinate is converted to an event coordinate.
-    The contract is that if we re-histogram the event list with the same bin edges,
-    we should get the original counts back.
-    Masks on non-bin-edge dimensions are preserved.
-    If there are masks on bin-edge dimensions, the masked values are zeroed out in the
-    original data before the conversion to events.
-
-    Parameters
-    ----------
-    da:
-        DataArray to convert to events.
-    event_dim:
-        Name of the new event dimension.
-    events_per_bin:
-        Number of events to generate per bin.
-    """
-    if da.bins is not None:
-        raise ValueError("Cannot convert a binned DataArray to events.")
-    rng = np.random.default_rng()
-    event_coords = {}
-    edge_dims = []
-    midp_dims = set(da.dims)
-    midp_coord_names = []
-    # Separate bin-edge and midpoints coords
-    for name in da.coords:
-        dims = da.coords[name].dims
-        is_edges = False if not dims else da.coords.is_edges(name)
-        if is_edges:
-            if name in dims:
-                edge_dims.append(name)
-                midp_dims -= {name}
-        else:
-            midp_coord_names.append(name)
-
-    edge_sizes = {dim: da.sizes[da.coords[dim].dim] for dim in edge_dims}
-    for dim in edge_dims:
-        coord = da.coords[dim]
-        left = sc.broadcast(coord[dim, :-1], sizes=edge_sizes).values
-        right = sc.broadcast(coord[dim, 1:], sizes=edge_sizes).values
-
-        # The numpy.random.uniform function below does not support NaNs, so we need to
-        # replace them with zeros, and then replace them back after the random numbers
-        # have been generated.
-        nans = np.isnan(left) | np.isnan(right)
-        left = np.where(nans, 0.0, left)
-        right = np.where(nans, 0.0, right)
-        # Ensure left <= right
-        left, right = np.minimum(left, right), np.maximum(left, right)
-
-        # In each bin, we generate a number of events with a uniform distribution.
-        events = rng.uniform(
-            left, right, size=(events_per_bin, *list(edge_sizes.values()))
-        )
-        events[..., nans] = np.nan
-        event_coords[dim] = sc.array(
-            dims=[event_dim, *edge_dims], values=events, unit=coord.unit
-        )
-
-    # Find and apply masks that are on a bin-edge dimension
-    event_masks = {}
-    other_masks = {}
-    edge_dims_set = set(edge_dims)
-    for key, mask in da.masks.items():
-        if set(mask.dims) & edge_dims_set:
-            event_masks[key] = mask
-        else:
-            other_masks[key] = mask
-
-    data = da.data
-    if event_masks:
-        inv_mask = (~reduce(lambda a, b: a | b, event_masks.values())).to(dtype=int)
-        inv_mask.unit = ""
-        data = data * inv_mask
-
-    # Create the data counts, which are the original counts divided by the number of
-    # events per bin
-    sizes = {event_dim: events_per_bin} | da.sizes
-    val = sc.broadcast(sc.values(data) / float(events_per_bin), sizes=sizes)
-    kwargs = {"dims": sizes.keys(), "values": val.values, "unit": data.unit}
-    if data.variances is not None:
-        # Note here that all the events are correlated.
-        # If we later histogram the events with different edges than the original
-        # histogram, then neighboring bins will be correlated, and the error obtained
-        # will be too small. It is however not clear what can be done to improve this.
-        kwargs["variances"] = sc.broadcast(
-            sc.variances(data) / float(events_per_bin), sizes=sizes
-        ).values
-    new_data = sc.array(**kwargs)
-
-    new = sc.DataArray(data=new_data, coords=event_coords)
-    new = new.transpose((*midp_dims, *edge_dims, event_dim)).flatten(
-        dims=[*edge_dims, event_dim], to=event_dim
-    )
-    return new.assign_coords(
-        {dim: da.coords[dim].copy() for dim in midp_coord_names}
-    ).assign_masks({key: mask.copy() for key, mask in other_masks.items()})