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

ess/reduce/data.py

@@ -40,6 +40,15 @@ _bifrost_registry = Registry(
 )
 
 
+_dream_registry = Registry(
+    instrument='dream',
+    files={
+        "TEST_977695_00068064.hdf": "md5:9e6ee9ec70d7c5e8c0c93b9e07e8949f",
+    },
+    version='2',
+)
+
+
 _loki_registry = Registry(
     instrument='loki',
     files={
@@ -94,3 +103,11 @@ def loki_tutorial_background_run_60393() -> str:
 def loki_tutorial_sample_transmission_run() -> str:
     """Sample transmission run (sample + sample holder/can + transmission monitor)."""
     return _loki_registry.get_path('60394-2022-02-28_2215.nxs')
+
+
+def dream_coda_test_file() -> str:
+    """CODA file for DREAM where most pulses have been removed.
+
+    See ``tools/shrink_nexus.py``.
+    """
+    return _dream_registry.get_path('TEST_977695_00068064.hdf')

ess/reduce/nexus/types.py

@@ -8,6 +8,7 @@ import sciline
 import scipp as sc
 import scippnexus as snx
 from scippneutron import metadata as scn_meta
+from scippneutron.chopper import DiskChopper
 
 FilePath = NewType('FilePath', Path)
 """Full path to a NeXus file on disk."""
@@ -69,19 +70,13 @@ class TransmissionRun(Generic[ScatteringRunType]):
     """
 
 
-RunType = TypeVar(
-    'RunType',
-    BackgroundRun,
-    EmptyBeamRun,
-    SampleRun,
-    # Note that mypy does not seem to like this nesting, may need to find a workaround
-    TransmissionRun[SampleRun],
-    TransmissionRun[BackgroundRun],
-    VanadiumRun,
-)
+RunType = TypeVar('RunType')
 """TypeVar for specifying what run some data belongs to.
 
-Possible values:
+This type must be constrained when used in a Sciline pipeline.
+E.g., by passing ``run_types`` to :class:`ess.reduce.nexus.GenericNeXusWorkflow`.
+
+ESSreduce provides the following but custom types can be used:
 
 - :class:`BackgroundRun`
 - :class:`EmptyBeamRun`
@@ -92,58 +87,28 @@ Possible values:
 
 
 # 1.2  Monitor types
-Monitor1 = NewType('Monitor1', int)
-"""Identifier for an arbitrary monitor"""
-Monitor2 = NewType('Monitor2', int)
-"""Identifier for an arbitrary monitor"""
-Monitor3 = NewType('Monitor3', int)
-"""Identifier for an arbitrary monitor"""
-Monitor4 = NewType('Monitor4', int)
-"""Identifier for an arbitrary monitor"""
-Monitor5 = NewType('Monitor5', int)
-"""Identifier for an arbitrary monitor"""
-Monitor6 = NewType('Monitor6', int)
-"""Identifier for an arbitrary monitor"""
 IncidentMonitor = NewType('IncidentMonitor', int)
 """Incident monitor"""
 TransmissionMonitor = NewType('TransmissionMonitor', int)
 """Transmission monitor"""
-FrameMonitor0 = NewType('FrameMonitor', int)
+FrameMonitor0 = NewType('FrameMonitor0', int)
 """Frame monitor number 0"""
-FrameMonitor1 = NewType('FrameMonitor', int)
+FrameMonitor1 = NewType('FrameMonitor1', int)
 """Frame monitor number 1"""
-FrameMonitor2 = NewType('FrameMonitor', int)
+FrameMonitor2 = NewType('FrameMonitor2', int)
 """Frame monitor number 2"""
-FrameMonitor3 = NewType('FrameMonitor', int)
+FrameMonitor3 = NewType('FrameMonitor3', int)
 """Frame monitor number 3"""
 CaveMonitor = NewType('CaveMonitor', int)
 """A monitor located in the instrument cave"""
-MonitorType = TypeVar(
-    'MonitorType',
-    Monitor1,
-    Monitor2,
-    Monitor3,
-    Monitor4,
-    Monitor5,
-    Monitor6,
-    IncidentMonitor,
-    TransmissionMonitor,
-    FrameMonitor0,
-    FrameMonitor1,
-    FrameMonitor2,
-    FrameMonitor3,
-    CaveMonitor,
-)
+MonitorType = TypeVar('MonitorType')
 """TypeVar for specifying what monitor some data belongs to.
 
-Possible values:
+This type must be constrained when used in a Sciline pipeline.
+E.g., by passing ``monitor_types`` to :class:`ess.reduce.nexus.GenericNeXusWorkflow`.
+
+ESSreduce provides the following but custom types can be used:
 
-- :class:`Monitor1`
-- :class:`Monitor2`
-- :class:`Monitor3`
-- :class:`Monitor4`
-- :class:`Monitor5`
-- :class:`Monitor6`
 - :class:`IncidentMonitor`
 - :class:`TransmissionMonitor`
 - :class:`FrameMonitor0`
@@ -154,27 +119,20 @@ Possible values:
 """
 
 
-Component = TypeVar(
-    'Component',
+Component = TypeVar('Component')
+"""A beamline component in a neXus file."""
+COMPONENT_CONSTRAINTS = (
     snx.NXdetector,
     snx.NXsample,
     snx.NXsource,
     snx.NXdisk_chopper,
     snx.NXcrystal,
-    Monitor1,
-    Monitor2,
-    Monitor3,
-    Monitor4,
-    Monitor5,
-    Monitor6,
-    IncidentMonitor,
-    TransmissionMonitor,
-    FrameMonitor0,
-    FrameMonitor1,
-    FrameMonitor2,
-    FrameMonitor3,
-    CaveMonitor,
 )
+"""Base constraints for the Component type variable.
+
+This list will be supplemented with monitor types when creating a pipeline.
+"""
+
 UniqueComponent = TypeVar('UniqueComponent', snx.NXsample, snx.NXsource)
 """Components that can be identified by their type as there will only be one."""
 
@@ -336,8 +294,15 @@ class NeXusTransformation(Generic[Component, RunType]):
         return NeXusTransformation(value=transform)
 
 
-class Choppers(
+class RawChoppers(
     sciline.Scope[RunType, sc.DataGroup[sc.DataGroup[Any]]],
     sc.DataGroup[sc.DataGroup[Any]],
 ):
     """All choppers in a NeXus file."""
+
+
+class DiskChoppers(
+    sciline.Scope[RunType, sc.DataGroup[DiskChopper]],
+    sc.DataGroup[DiskChopper],
+):
+    """All disk choppers parsed from a NeXus file."""

ess/reduce/nexus/workflow.py

@@ -5,7 +5,7 @@
 
 from collections.abc import Iterable
 from copy import deepcopy
-from typing import Any
+from typing import Any, TypeVar
 
 import sciline
 import sciline.typing
@@ -15,15 +15,14 @@ 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 (
+    COMPONENT_CONSTRAINTS,
     AllNeXusComponents,
     Beamline,
     CalibratedBeamline,
     CalibratedDetector,
     CalibratedMonitor,
-    Choppers,
     Component,
     DetectorBankSizes,
     DetectorData,
@@ -46,6 +45,7 @@ from .types import (
     NeXusTransformationChain,
     Position,
     PreopenNeXusFile,
+    RawChoppers,
     RunType,
     SampleRun,
     TimeInterval,
@@ -513,9 +513,18 @@ def assemble_monitor_data(
 
 def parse_disk_choppers(
     choppers: AllNeXusComponents[snx.NXdisk_chopper, RunType],
-) -> Choppers[RunType]:
-    """Convert the NeXus representation of a chopper to ours."""
-    return Choppers[RunType](
+) -> RawChoppers[RunType]:
+    """Convert the NeXus representation of a chopper to ours.
+
+    Returns
+    -------
+    :
+        A nested data group containing the loaded choppers.
+        The elements may be time-dependent arrays that first need to be processed
+        before they can be passed to other functions as
+        :class:`ess.reduce.nexus.types.DiskChoppers`.
+    """
+    return RawChoppers[RunType](
         choppers.apply(
             lambda chopper: extract_chopper_from_nexus(
                 nexus.compute_component_position(chopper)
@@ -551,10 +560,10 @@ class _StrippedDetector(snx.NXdetector):
 class _DummyField:
     """Dummy field that can replace snx.Field in NXmonitor."""
 
-    def __init__(self):
+    def __init__(self, dim: str):
         self.attrs = {}
-        self.sizes = {'event_time_zero': 0}
-        self.dims = ('event_time_zero',)
+        self.sizes = {dim: 0}
+        self.dims = (dim,)
         self.shape = (0,)
 
     def __getitem__(self, key: Any) -> sc.Variable:
@@ -564,14 +573,17 @@ class _DummyField:
 class _StrippedMonitor(snx.NXmonitor):
     """Monitor definition without event data for ScippNexus.
 
-    Drops NXevent_data group, data is replaced by a dummy field.
+    Drops NXevent_data and NXdata groups, data is replaced by a dummy field.
     """
 
     def __init__(
         self, attrs: dict[str, Any], children: dict[str, snx.Field | snx.Group]
     ):
-        children = _drop(children, (snx.NXevent_data,))
-        children['data'] = _DummyField()
+        is_dense = snx.NXdata in (
+            getattr(child, 'nx_class', None) for child in children
+        )
+        children = _drop(children, (snx.NXevent_data, snx.NXdata))
+        children['data'] = _DummyField(dim='time' if is_dense else 'event_time_zero')
         super().__init__(attrs=attrs, children=children)
 
 
@@ -579,11 +591,21 @@ def _add_variances(da: sc.DataArray) -> sc.DataArray:
     out = da.copy(deep=False)
     if out.bins is not None:
         content = out.bins.constituents['data']
-        if content.variances is None:
-            content.variances = content.values
+        content.data = _assign_values_as_variances(content.data)
+    elif out.variances is None:
+        out.data = _assign_values_as_variances(out.data)
     return out
 
 
+def _assign_values_as_variances(var: sc.Variable) -> sc.Variable:
+    try:
+        var.variances = var.values
+    except sc.VariancesError:
+        var = var.to(dtype=sc.DType.float64)
+        var.variances = var.values
+    return var
+
+
 def load_beamline_metadata_from_nexus(file_spec: NeXusFileSpec[SampleRun]) -> Beamline:
     """Load beamline metadata from a sample NeXus file."""
     return nexus.load_metadata(file_spec.value, Beamline)
@@ -644,16 +666,34 @@ _metadata_providers = (
 )
 
 
-def LoadMonitorWorkflow() -> sciline.Pipeline:
+def LoadMonitorWorkflow(
+    *,
+    run_types: Iterable[sciline.typing.Key],
+    monitor_types: Iterable[sciline.typing.Key],
+) -> sciline.Pipeline:
     """Generic workflow for loading monitor data from a NeXus file."""
-    wf = sciline.Pipeline((*_common_providers, *_monitor_providers))
+    wf = sciline.Pipeline(
+        (*_common_providers, *_monitor_providers),
+        constraints=_gather_constraints(
+            run_types=run_types, monitor_types=monitor_types
+        ),
+    )
     wf[PreopenNeXusFile] = PreopenNeXusFile(False)
     return wf
 
 
-def LoadDetectorWorkflow() -> sciline.Pipeline:
+def LoadDetectorWorkflow(
+    *,
+    run_types: Iterable[sciline.typing.Key],
+    monitor_types: Iterable[sciline.typing.Key],
+) -> sciline.Pipeline:
     """Generic workflow for loading detector data from a NeXus file."""
-    wf = sciline.Pipeline((*_common_providers, *_detector_providers))
+    wf = sciline.Pipeline(
+        (*_common_providers, *_detector_providers),
+        constraints=_gather_constraints(
+            run_types=run_types, monitor_types=monitor_types
+        ),
+    )
     wf[DetectorBankSizes] = DetectorBankSizes({})
     wf[PreopenNeXusFile] = PreopenNeXusFile(False)
     return wf
@@ -661,8 +701,8 @@ def LoadDetectorWorkflow() -> sciline.Pipeline:
 
 def GenericNeXusWorkflow(
     *,
-    run_types: Iterable[sciline.typing.Key] | None = None,
-    monitor_types: Iterable[sciline.typing.Key] | None = None,
+    run_types: Iterable[sciline.typing.Key],
+    monitor_types: Iterable[sciline.typing.Key],
 ) -> sciline.Pipeline:
     """
     Generic workflow for loading detector and monitor data from a NeXus file.
@@ -681,13 +721,12 @@ def GenericNeXusWorkflow(
     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`.
+        List of run types to include in the workflow.
+        Constrains the possible values 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`.
+        List of monitor types to include in the workflow.
+        Constrains the possible values of :class:`ess.reduce.nexus.types.MonitorType`
+        and :class:`ess.reduce.nexus.types.Component`.
 
     Returns
     -------
@@ -701,12 +740,26 @@ def GenericNeXusWorkflow(
             *_detector_providers,
             *_chopper_providers,
             *_metadata_providers,
-        )
+        ),
+        constraints=_gather_constraints(
+            run_types=run_types, monitor_types=monitor_types
+        ),
     )
     wf[DetectorBankSizes] = DetectorBankSizes({})
     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)
-
     return wf
+
+
+def _gather_constraints(
+    *,
+    run_types: Iterable[sciline.typing.Key],
+    monitor_types: Iterable[sciline.typing.Key],
+) -> dict[TypeVar, Iterable[type]]:
+    mon = tuple(iter(monitor_types))
+    constraints = {
+        RunType: run_types,
+        MonitorType: mon,
+        Component: (*COMPONENT_CONSTRAINTS, *mon),
+    }
+    return constraints

ess/reduce/streaming.py

@@ -138,6 +138,30 @@ class EternalAccumulator(Accumulator[T]):
         self._value = None
 
 
+class MeanAccumulator(EternalAccumulator[T]):
+    """
+    Accumulator that computes the mean of pushed values.
+
+    Does not support event data.
+    """
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self._count = 0
+
+    def _do_push(self, value: T) -> None:
+        super()._do_push(value)
+        self._count += 1
+
+    def _get_value(self) -> T:
+        return super()._get_value() / self._count
+
+    def clear(self) -> None:
+        """Clear the accumulated value and count."""
+        super().clear()
+        self._count = 0
+
+
 class RollingAccumulator(Accumulator[T]):
     """
     Accumulator that adds pushed values to a rolling window.

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/simulation.py

@@ -6,7 +6,7 @@ import scipp as sc
 import scippnexus as snx
 from scippneutron.chopper import DiskChopper
 
-from ..nexus.types import Choppers, Position, SampleRun
+from ..nexus.types import DiskChoppers, Position, SampleRun
 from .types import NumberOfSimulatedNeutrons, SimulationResults
 
 
@@ -87,7 +87,7 @@ def simulate_beamline(
 
 
 def simulate_chopper_cascade_using_tof(
-    choppers: Choppers[SampleRun],
+    choppers: DiskChoppers[SampleRun],
     neutrons: NumberOfSimulatedNeutrons,
     source_position: Position[snx.NXsource, SampleRun],
 ) -> SimulationResults:

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

@@ -7,7 +7,6 @@ import sciline
 import scipp as sc
 
 from ..nexus import GenericNeXusWorkflow
-from ..utils import prune_type_vars
 from . import eto_to_tof, simulation
 from .types import TimeOfFlightLookupTable, TimeOfFlightLookupTableFilename
 
@@ -28,13 +27,14 @@ def load_tof_lookup_table(
 
 def GenericTofWorkflow(
     *,
-    run_types: Iterable[sciline.typing.Key] | None = None,
-    monitor_types: Iterable[sciline.typing.Key] | None = None,
+    run_types: Iterable[sciline.typing.Key],
+    monitor_types: Iterable[sciline.typing.Key],
     tof_lut_provider: TofLutProvider = TofLutProvider.FILE,
 ) -> 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.
@@ -53,13 +53,12 @@ def GenericTofWorkflow(
     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`.
+        List of run types to include in the workflow.
+        Constrains the possible values 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`.
+        List of monitor types to include in the workflow.
+        Constrains the possible values of :class:`ess.reduce.nexus.types.MonitorType`
+        and :class:`ess.reduce.nexus.types.Component`.
     tof_lut_provider:
         Specifies how the time-of-flight lookup table is provided:
         - FILE: Read from a file
@@ -88,7 +87,4 @@ def GenericTofWorkflow(
     for key, value in eto_to_tof.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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: essreduce
-Version: 25.5.1
+Version: 25.5.3
 Summary: Common data reduction tools for the ESS facility
 Author: Scipp contributors
 License: BSD 3-Clause License
@@ -51,7 +51,7 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: sciline>=25.04.1
+Requires-Dist: sciline>=25.05.1
 Requires-Dist: scipp>=25.01.0
 Requires-Dist: scippneutron>=25.02.0
 Requires-Dist: scippnexus>=24.11.0

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

@@ -1,12 +1,11 @@
 ess/reduce/__init__.py,sha256=o1pWRP9YGwTukM_k-qlG6KcoXOpMb0PDVH59vod12lw,419
-ess/reduce/data.py,sha256=vaoeAJ6EpK1YghOiAALLdWiW17TgUnnnt0H-RGiGzXk,3756
+ess/reduce/data.py,sha256=0N7iq1363tO16ntMztTNjxkQDFst-Gnp9awpgUOBVdY,4133
 ess/reduce/logging.py,sha256=6n8Czq4LZ3OK9ENlKsWSI1M3KvKv6_HSoUiV4__IUlU,357
 ess/reduce/parameter.py,sha256=4sCfoKOI2HuO_Q7JLH_jAXnEOFANSn5P3NdaOBzhJxc,4635
 ess/reduce/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ess/reduce/streaming.py,sha256=TBttQV5WdSpUKh38J0pdv53seMWtUFswxd6-ltaZb_M,17403
+ess/reduce/streaming.py,sha256=zbqxQz5dASDq4ZVyx-TdbapBXMyBttImCYz_6WOj4pg,17978
 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=738-lcdgsORYfQ4A0UTk2IgnbVxC3jBdpscpaOFIpdc,3114
 ess/reduce/live/__init__.py,sha256=jPQVhihRVNtEDrE20PoKkclKV2aBF1lS7cCHootgFgI,204
 ess/reduce/live/raw.py,sha256=66qV0G2rP8gK5tXuk-syTlDLE2jT3ehfmSnET7Xzfd0,24392
@@ -16,18 +15,18 @@ ess/reduce/nexus/__init__.py,sha256=59bxKkNYg8DYcSykNvH6nCa5SYchJC4SbgZEKhkNdYc,
 ess/reduce/nexus/_nexus_loader.py,sha256=5N48AMJx1AaFZb6WZPPbVKUlXyFMVVtZrn7Bae57O3A,19842
 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=-pj8PpHu7QJrjrOOQ-VD9QhYh1L92onkX4xtmY3mgXE,9645
-ess/reduce/nexus/workflow.py,sha256=hqK58dsr8KtQn065-PS4Eiyir90qnZ3GQNyNDupOg4I,23084
+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/simulation.py,sha256=nJe-pkVvG9V6VdfB0_HyVYQoOSNJSMo_QydCHHW1dqM,3624
-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=ooSVwbL0hPBBVCfuTsAVaGEENs9P4kDN-FlH42NVzJQ,3427
+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/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
@@ -40,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.1.dist-info/licenses/LICENSE,sha256=nVEiume4Qj6jMYfSRjHTM2jtJ4FGu0g-5Sdh7osfEYw,1553
-essreduce-25.5.1.dist-info/METADATA,sha256=8VVFEjGw_n02K81UZs5IexKEOuN4IyNfaQybrzKn4j0,3768
-essreduce-25.5.1.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
-essreduce-25.5.1.dist-info/entry_points.txt,sha256=PMZOIYzCifHMTe4pK3HbhxUwxjFaZizYlLD0td4Isb0,66
-essreduce-25.5.1.dist-info/top_level.txt,sha256=0JxTCgMKPLKtp14wb1-RKisQPQWX7i96innZNvHBr-s,4
-essreduce-25.5.1.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,,

{essreduce-25.5.1.dist-info → essreduce-25.5.3.dist-info}/WHEEL

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

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()})

ess/reduce/utils.py

@@ -1,36 +0,0 @@
-# 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)