essreduce 25.2.2__py3-none-any.whl → 25.2.4__py3-none-any.whl

ess/reduce/live/raw.py

@@ -639,7 +639,7 @@ def position_with_noisy_replicas(
     # "Paint" the short array of noise on top of the (replicated) position data.
     noise = sc.concat(
         [position_noise] * ceil(size / position_noise.size), dim=noise_dim
-    )[:size].fold(dim=noise_dim, sizes={'replica': replicas, position.dim: -1})
+    )[:size].fold(dim=noise_dim, sizes={'replica': replicas, **position.sizes})
     return sc.concat([position, noise + position], dim='replica')
 
 

ess/reduce/nexus/_nexus_loader.py

@@ -8,14 +8,16 @@ from collections.abc import Generator, Mapping
 from contextlib import AbstractContextManager, contextmanager, nullcontext
 from dataclasses import dataclass
 from math import prod
-from typing import cast
+from typing import TypeVar, cast
 
 import scipp as sc
 import scippnexus as snx
 
 from ..logging import get_logger
 from .types import (
+    Beamline,
     FilePath,
+    Measurement,
     NeXusAllLocationSpec,
     NeXusEntryName,
     NeXusFile,
@@ -27,6 +29,8 @@ from .types import (
 class NoNewDefinitionsType: ...
 
 
+_Model = TypeVar('_Model', Beamline, Measurement)
+
 NoNewDefinitions = NoNewDefinitionsType()
 
 
@@ -74,6 +78,18 @@ def load_all_components(
     return components
 
 
+def load_metadata(
+    file_path: FilePath | NeXusFile | NeXusGroup,
+    model: type[_Model],
+    *,
+    entry_name: NeXusEntryName | None = None,
+    definitions: Mapping | NoNewDefinitionsType = NoNewDefinitions,
+) -> _Model:
+    with _open_nexus_file(file_path, definitions=definitions) as f:
+        entry = _unique_child_group(f, snx.NXentry, entry_name)
+        return model.from_nexus_entry(entry)
+
+
 def compute_component_position(dg: sc.DataGroup) -> sc.DataGroup:
     # In some downstream packages we use some of the Nexus components which attempt
     # to compute positions without having actual Nexus data defining depends_on chains.

ess/reduce/nexus/types.py

@@ -7,6 +7,7 @@ from typing import Any, BinaryIO, Generic, NewType, TypeVar
 import sciline
 import scipp as sc
 import scippnexus as snx
+from scippneutron import metadata as scn_meta
 
 FilePath = NewType('FilePath', Path)
 """Full path to a NeXus file on disk."""
@@ -177,6 +178,13 @@ Component = TypeVar(
 UniqueComponent = TypeVar('UniqueComponent', snx.NXsample, snx.NXsource)
 """Components that can be identified by their type as there will only be one."""
 
+Beamline = scn_meta.Beamline
+"""Beamline metadata."""
+Measurement = scn_meta.Measurement
+"""measurement metadata."""
+Source = scn_meta.Source
+"""Neutron source metadata."""
+
 
 class NeXusName(sciline.Scope[Component, str], str):
     """Name of a component in a NeXus file."""

ess/reduce/nexus/workflow.py

@@ -19,6 +19,7 @@ from . import _nexus_loader as nexus
 from .types import (
     AllNeXusComponents,
     Analyzers,
+    Beamline,
     CalibratedBeamline,
     CalibratedDetector,
     CalibratedMonitor,
@@ -29,6 +30,7 @@ from .types import (
     DetectorPositionOffset,
     Filename,
     GravityVector,
+    Measurement,
     MonitorData,
     MonitorPositionOffset,
     MonitorType,
@@ -45,6 +47,7 @@ from .types import (
     Position,
     PreopenNeXusFile,
     RunType,
+    SampleRun,
     TimeInterval,
     UniqueComponent,
 )
@@ -586,6 +589,18 @@ def _add_variances(da: sc.DataArray) -> sc.DataArray:
     return out
 
 
+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)
+
+
+def load_measurement_metadata_from_nexus(
+    file_spec: NeXusFileSpec[SampleRun],
+) -> Measurement:
+    """Load measurement metadata from a sample NeXus file."""
+    return nexus.load_metadata(file_spec.value, Measurement)
+
+
 definitions = snx.base_definitions()
 definitions["NXdetector"] = _StrippedDetector
 definitions["NXmonitor"] = _StrippedMonitor
@@ -631,6 +646,11 @@ _chopper_providers = (parse_disk_choppers,)
 
 _analyzer_providers = (parse_analyzers,)
 
+_metadata_providers = (
+    load_beamline_metadata_from_nexus,
+    load_measurement_metadata_from_nexus,
+)
+
 
 def LoadMonitorWorkflow() -> sciline.Pipeline:
     """Generic workflow for loading monitor data from a NeXus file."""
@@ -689,6 +709,7 @@ def GenericNeXusWorkflow(
             *_detector_providers,
             *_chopper_providers,
             *_analyzer_providers,
+            *_metadata_providers,
         )
     )
     wf[DetectorBankSizes] = DetectorBankSizes({})

ess/reduce/streaming.py

@@ -147,7 +147,7 @@ class StreamProcessor:
         *,
         dynamic_keys: tuple[sciline.typing.Key, ...],
         target_keys: tuple[sciline.typing.Key, ...],
-        accumulators: dict[sciline.typing.Key, Accumulator, Callable[..., Accumulator]]
+        accumulators: dict[sciline.typing.Key, Accumulator | Callable[..., Accumulator]]
         | tuple[sciline.typing.Key, ...],
         allow_bypass: bool = False,
     ) -> None:
@@ -180,6 +180,8 @@ class StreamProcessor:
         for key in dynamic_keys:
             workflow[key] = None  # hack to prune branches
 
+        self._dynamic_keys = set(dynamic_keys)
+
         # Find and pre-compute static nodes as far down the graph as possible
         # See also https://github.com/scipp/sciline/issues/148.
         nodes = _find_descendants(workflow, dynamic_keys)
@@ -194,12 +196,19 @@ class StreamProcessor:
             if isinstance(accumulators, dict)
             else {key: EternalAccumulator() for key in accumulators}
         )
+
+        # Map each accumulator to its dependent dynamic keys
+        graph = workflow.underlying_graph
+        self._accumulator_dependencies = {
+            acc_key: nx.ancestors(graph, acc_key) & self._dynamic_keys
+            for acc_key in self._accumulators
+            if acc_key in graph
+        }
+
         # Depending on the target_keys, some accumulators can be unused and should not
         # be computed when adding a chunk.
         self._accumulators = {
-            key: value
-            for key, value in self._accumulators.items()
-            if key in self._process_chunk_workflow.underlying_graph
+            key: value for key, value in self._accumulators.items() if key in graph
         }
         # Create accumulators unless instances were passed. This allows for initializing
         # accumulators with arguments that depend on the workflow such as bin edges,
@@ -242,7 +251,30 @@ class StreamProcessor:
         ----------
         chunks:
             Chunks to be processed.
+
+        Raises
+        ------
+        ValueError
+            If non-dynamic keys are provided in chunks.
+            If accumulator computation requires dynamic keys not provided in chunks.
         """
+        non_dynamic = set(chunks) - self._dynamic_keys
+        if non_dynamic:
+            raise ValueError(
+                f"Can only update dynamic keys. Got non-dynamic keys: {non_dynamic}"
+            )
+
+        accumulators_to_update = []
+        for acc_key, deps in self._accumulator_dependencies.items():
+            if deps.isdisjoint(chunks.keys()):
+                continue
+            if not deps.issubset(chunks.keys()):
+                raise ValueError(
+                    f"Accumulator '{acc_key}' requires dynamic keys "
+                    f"{deps - chunks.keys()} not provided in the current chunk."
+                )
+            accumulators_to_update.append(acc_key)
+
         for key, value in chunks.items():
             self._process_chunk_workflow[key] = value
             # There can be dynamic keys that do not "terminate" in any accumulator. In
@@ -250,7 +282,7 @@ class StreamProcessor:
             # the target keys.
             if self._allow_bypass:
                 self._finalize_workflow[key] = value
-        to_accumulate = self._process_chunk_workflow.compute(self._accumulators)
+        to_accumulate = self._process_chunk_workflow.compute(accumulators_to_update)
         for key, processed in to_accumulate.items():
             self._accumulators[key].push(processed)
 

ess/reduce/time_of_flight/fakes.py

@@ -79,144 +79,41 @@ class FakeBeamline:
         return nx_event_data, raw_data
 
 
-wfm1_chopper = DiskChopper(
-    frequency=sc.scalar(-70.0, unit="Hz"),
-    beam_position=sc.scalar(0.0, unit="deg"),
-    phase=sc.scalar(-47.10, unit="deg"),
-    axle_position=sc.vector(value=[0, 0, 6.6], unit="m"),
-    slit_begin=sc.array(
-        dims=["cutout"],
-        values=np.array([83.71, 140.49, 193.26, 242.32, 287.91, 330.3]) + 15.0,
-        unit="deg",
-    ),
-    slit_end=sc.array(
-        dims=["cutout"],
-        values=np.array([94.7, 155.79, 212.56, 265.33, 314.37, 360.0]) + 15.0,
-        unit="deg",
-    ),
-    slit_height=sc.scalar(10.0, unit="cm"),
-    radius=sc.scalar(30.0, unit="cm"),
-)
-
-wfm2_chopper = DiskChopper(
-    frequency=sc.scalar(-70.0, unit="Hz"),
-    beam_position=sc.scalar(0.0, unit="deg"),
-    phase=sc.scalar(-76.76, unit="deg"),
-    axle_position=sc.vector(value=[0, 0, 7.1], unit="m"),
-    slit_begin=sc.array(
-        dims=["cutout"],
-        values=np.array([65.04, 126.1, 182.88, 235.67, 284.73, 330.32]) + 15.0,
-        unit="deg",
-    ),
-    slit_end=sc.array(
-        dims=["cutout"],
-        values=np.array([76.03, 141.4, 202.18, 254.97, 307.74, 360.0]) + 15.0,
-        unit="deg",
-    ),
-    slit_height=sc.scalar(10.0, unit="cm"),
-    radius=sc.scalar(30.0, unit="cm"),
-)
-
-foc1_chopper = DiskChopper(
-    frequency=sc.scalar(-56.0, unit="Hz"),
-    beam_position=sc.scalar(0.0, unit="deg"),
-    phase=sc.scalar(-62.40, unit="deg"),
-    axle_position=sc.vector(value=[0, 0, 8.8], unit="m"),
-    slit_begin=sc.array(
-        dims=["cutout"],
-        values=np.array([74.6, 139.6, 194.3, 245.3, 294.8, 347.2]),
-        unit="deg",
-    ),
-    slit_end=sc.array(
-        dims=["cutout"],
-        values=np.array([95.2, 162.8, 216.1, 263.1, 310.5, 371.6]),
-        unit="deg",
-    ),
-    slit_height=sc.scalar(10.0, unit="cm"),
-    radius=sc.scalar(30.0, unit="cm"),
-)
-
-foc2_chopper = DiskChopper(
-    frequency=sc.scalar(-28.0, unit="Hz"),
-    beam_position=sc.scalar(0.0, unit="deg"),
-    phase=sc.scalar(-12.27, unit="deg"),
-    axle_position=sc.vector(value=[0, 0, 15.9], unit="m"),
-    slit_begin=sc.array(
-        dims=["cutout"],
-        values=np.array([98.0, 154.0, 206.8, 255.0, 299.0, 344.65]),
-        unit="deg",
-    ),
-    slit_end=sc.array(
-        dims=["cutout"],
-        values=np.array([134.6, 190.06, 237.01, 280.88, 323.56, 373.76]),
-        unit="deg",
-    ),
-    slit_height=sc.scalar(10.0, unit="cm"),
-    radius=sc.scalar(30.0, unit="cm"),
-)
-
-pol_chopper = DiskChopper(
-    frequency=sc.scalar(-14.0, unit="Hz"),
-    beam_position=sc.scalar(0.0, unit="deg"),
-    phase=sc.scalar(0.0, unit="deg"),
-    axle_position=sc.vector(value=[0, 0, 17.0], unit="m"),
-    slit_begin=sc.array(
-        dims=["cutout"],
-        values=np.array([40.0]),
-        unit="deg",
-    ),
-    slit_end=sc.array(
-        dims=["cutout"],
-        values=np.array([240.0]),
-        unit="deg",
-    ),
-    slit_height=sc.scalar(10.0, unit="cm"),
-    radius=sc.scalar(30.0, unit="cm"),
-)
-
-
-def wfm_choppers():
-    return {
-        "wfm1": wfm1_chopper,
-        "wfm2": wfm2_chopper,
-        "foc1": foc1_chopper,
-        "foc2": foc2_chopper,
-        "pol": pol_chopper,
-    }
-
-
 def psc_choppers():
     return {
-        name: DiskChopper(
-            frequency=ch.frequency,
-            beam_position=ch.beam_position,
-            phase=ch.phase,
-            axle_position=ch.axle_position,
-            slit_begin=ch.slit_begin[0:1],
-            slit_end=ch.slit_end[0:1],
-            slit_height=ch.slit_height[0:1],
-            radius=ch.radius,
+        "chopper": DiskChopper(
+            frequency=sc.scalar(-14.0, unit="Hz"),
+            beam_position=sc.scalar(0.0, unit="deg"),
+            phase=sc.scalar(-85.0, unit="deg"),
+            axle_position=sc.vector(value=[0, 0, 8.0], unit="m"),
+            slit_begin=sc.array(dims=["cutout"], values=[0.0], unit="deg"),
+            slit_end=sc.array(dims=["cutout"], values=[3.0], unit="deg"),
+            slit_height=sc.scalar(10.0, unit="cm"),
+            radius=sc.scalar(30.0, unit="cm"),
         )
-        for name, ch in wfm_choppers().items()
     }
 
 
-def pulse_skipping_chopper():
-    return DiskChopper(
-        frequency=sc.scalar(-7.0, unit="Hz"),
-        beam_position=sc.scalar(0.0, unit="deg"),
-        phase=sc.scalar(0.0, unit="deg"),
-        axle_position=sc.vector(value=[0, 0, 30.0], unit="m"),
-        slit_begin=sc.array(
-            dims=["cutout"],
-            values=np.array([40.0]),
-            unit="deg",
+def pulse_skipping_choppers():
+    return {
+        "chopper": DiskChopper(
+            frequency=sc.scalar(-14.0, unit="Hz"),
+            beam_position=sc.scalar(0.0, unit="deg"),
+            phase=sc.scalar(-35.0, unit="deg"),
+            axle_position=sc.vector(value=[0, 0, 8.0], unit="m"),
+            slit_begin=sc.array(dims=["cutout"], values=np.array([0.0]), unit="deg"),
+            slit_end=sc.array(dims=["cutout"], values=np.array([33.0]), unit="deg"),
+            slit_height=sc.scalar(10.0, unit="cm"),
+            radius=sc.scalar(30.0, unit="cm"),
         ),
-        slit_end=sc.array(
-            dims=["cutout"],
-            values=np.array([140.0]),
-            unit="deg",
+        "pulse_skipping": DiskChopper(
+            frequency=sc.scalar(-7.0, unit="Hz"),
+            beam_position=sc.scalar(0.0, unit="deg"),
+            phase=sc.scalar(-10.0, unit="deg"),
+            axle_position=sc.vector(value=[0, 0, 15.0], unit="m"),
+            slit_begin=sc.array(dims=["cutout"], values=np.array([0.0]), unit="deg"),
+            slit_end=sc.array(dims=["cutout"], values=np.array([120.0]), unit="deg"),
+            slit_height=sc.scalar(10.0, unit="cm"),
+            radius=sc.scalar(30.0, unit="cm"),
         ),
-        slit_height=sc.scalar(10.0, unit="cm"),
-        radius=sc.scalar(30.0, unit="cm"),
-    )
+    }

ess/reduce/time_of_flight/toa_to_tof.py

@@ -32,20 +32,6 @@ from .types import (
 )
 
 
-def extract_ltotal(da: RawData) -> Ltotal:
-    """
-    Extract the total length of the flight path from the source to the detector from the
-    detector data.
-
-    Parameters
-    ----------
-    da:
-        Raw detector data loaded from a NeXus file, e.g., NXdetector containing
-        NXevent_data.
-    """
-    return Ltotal(da.coords["Ltotal"])
-
-
 def _mask_large_uncertainty(table: sc.DataArray, error_threshold: float):
     """
     Mask regions with large uncertainty with NaNs.
@@ -389,6 +375,56 @@ def _time_of_flight_data_histogram(
     return rebinned.assign_coords(tof=tofs)
 
 
+def _guess_pulse_stride_offset(
+    pulse_index: sc.Variable,
+    ltotal: sc.Variable,
+    event_time_offset: sc.Variable,
+    pulse_stride: int,
+    interp: Callable,
+) -> int:
+    """
+    Using the minimum ``event_time_zero`` to calculate a reference time when computing
+    the time-of-flight for the neutron events makes the workflow depend on when the
+    first event was recorded. There is no straightforward way to know if we started
+    recording at the beginning of a frame, or half-way through a frame, without looking
+    at the chopper logs. This can be manually corrected using the pulse_stride_offset
+    parameter, but this makes automatic reduction of the data difficult.
+    See https://github.com/scipp/essreduce/issues/184.
+
+    Here, we perform a simple guess for the ``pulse_stride_offset`` if it is not
+    provided.
+    We choose a few random events, compute the time-of-flight for every possible value
+    of pulse_stride_offset, and return the value that yields the least number of NaNs
+    in the computed time-of-flight.
+
+    Parameters
+    ----------
+    pulse_index:
+        Pulse index for every event.
+    ltotal:
+        Total length of the flight path from the source to the detector for each event.
+    event_time_offset:
+        Time of arrival of the neutron at the detector for each event.
+    pulse_stride:
+        Stride of used pulses.
+    interp:
+        2D interpolator for the lookup table.
+    """
+    tofs = {}
+    # Choose a few random events to compute the time-of-flight
+    inds = np.random.choice(
+        len(event_time_offset), min(5000, len(event_time_offset)), replace=False
+    )
+    pulse_index_values = pulse_index.values[inds]
+    ltotal_values = ltotal.values[inds]
+    etos_values = event_time_offset.values[inds]
+    for i in range(pulse_stride):
+        pulse_inds = (pulse_index_values + i) % pulse_stride
+        tofs[i] = interp((pulse_inds, ltotal_values, etos_values))
+    # Find the entry in the list with the least number of nan values
+    return sorted(tofs, key=lambda x: np.isnan(tofs[x]).sum())[0]
+
+
 def _time_of_flight_data_events(
     da: sc.DataArray,
     lookup: sc.DataArray,
@@ -399,28 +435,6 @@ def _time_of_flight_data_events(
 ) -> sc.DataArray:
     etos = da.bins.coords["event_time_offset"]
     eto_unit = elem_unit(etos)
-    pulse_period = pulse_period.to(unit=eto_unit)
-    frame_period = pulse_period * pulse_stride
-
-    # TODO: Finding the `tmin` below will not work in the case were data is processed
-    # in chunks, as taking the minimum time in each chunk will lead to inconsistent
-    # pulse indices (this will be the case in live data, or when using the
-    # StreamProcessor). We could instead read it from the first chunk and store it?
-
-    # Compute a pulse index for every event: it is the index of the pulse within a
-    # frame period. When there is no pulse skipping, those are all zero. When there is
-    # pulse skipping, the index ranges from zero to pulse_stride - 1.
-    tmin = da.bins.coords['event_time_zero'].min()
-    pulse_index = (
-        (
-            (da.bins.coords['event_time_zero'] - tmin).to(unit=eto_unit)
-            + 0.5 * pulse_period
-        )
-        % frame_period
-    ) // pulse_period
-    # Apply the pulse_stride_offset
-    pulse_index += pulse_stride_offset
-    pulse_index %= pulse_stride
 
     # Create 2D interpolator
     interp = _make_tof_interpolator(
@@ -430,7 +444,51 @@ def _time_of_flight_data_events(
     # Operate on events (broadcast distances to all events)
     ltotal = sc.bins_like(etos, ltotal).bins.constituents["data"]
     etos = etos.bins.constituents["data"]
-    pulse_index = pulse_index.bins.constituents["data"]
+
+    # Compute a pulse index for every event: it is the index of the pulse within a
+    # frame period. When there is no pulse skipping, those are all zero. When there is
+    # pulse skipping, the index ranges from zero to pulse_stride - 1.
+    if pulse_stride == 1:
+        pulse_index = sc.zeros(sizes=etos.sizes)
+    else:
+        etz_unit = 'ns'
+        etz = (
+            da.bins.coords["event_time_zero"]
+            .bins.constituents["data"]
+            .to(unit=etz_unit, copy=False)
+        )
+        pulse_period = pulse_period.to(unit=etz_unit, dtype=int)
+        frame_period = pulse_period * pulse_stride
+        # Define a common reference time using epoch as a base, but making sure that it
+        # is aligned with the pulse_period and the frame_period.
+        # We need to use a global reference time instead of simply taking the minimum
+        # event_time_zero because the events may arrive in chunks, and the first event
+        # may not be the first event of the first pulse for all chunks. This would lead
+        # to inconsistent pulse indices.
+        epoch = sc.datetime(0, unit=etz_unit)
+        diff_to_epoch = (etz.min() - epoch) % pulse_period
+        # Here we offset the reference by half a pulse period to avoid errors from
+        # fluctuations in the event_time_zeros in the data. They are triggered by the
+        # neutron source, and may not always be exactly separated by the pulse period.
+        # While fluctuations will exist, they will be small, and offsetting the times
+        # by half a pulse period is a simple enough fix.
+        reference = epoch + diff_to_epoch - (pulse_period // 2)
+        # Use in-place operations to avoid large allocations
+        pulse_index = etz - reference
+        pulse_index %= frame_period
+        pulse_index //= pulse_period
+
+        # Apply the pulse_stride_offset
+        if pulse_stride_offset is None:
+            pulse_stride_offset = _guess_pulse_stride_offset(
+                pulse_index=pulse_index,
+                ltotal=ltotal,
+                event_time_offset=etos,
+                pulse_stride=pulse_stride,
+                interp=interp,
+            )
+        pulse_index += pulse_stride_offset
+        pulse_index %= pulse_stride
 
     # Compute time-of-flight for all neutrons using the interpolator
     tofs = sc.array(
@@ -535,7 +593,7 @@ def default_parameters() -> dict:
     return {
         PulsePeriod: 1.0 / sc.scalar(14.0, unit="Hz"),
         PulseStride: 1,
-        PulseStrideOffset: 0,
+        PulseStrideOffset: None,
         DistanceResolution: sc.scalar(0.1, unit="m"),
         TimeResolution: sc.scalar(250.0, unit='us'),
         LookupTableRelativeErrorThreshold: 0.1,
@@ -546,4 +604,4 @@ def providers() -> tuple[Callable]:
     """
     Providers of the time-of-flight workflow.
     """
-    return (compute_tof_lookup_table, extract_ltotal, time_of_flight_data)
+    return (compute_tof_lookup_table, time_of_flight_data)

ess/reduce/time_of_flight/types.py

@@ -101,10 +101,10 @@ PulseStride = NewType("PulseStride", int)
 Stride of used pulses. Usually 1, but may be a small integer when pulse-skipping.
 """
 
-PulseStrideOffset = NewType("PulseStrideOffset", int)
+PulseStrideOffset = NewType("PulseStrideOffset", int | None)
 """
 When pulse-skipping, the offset of the first pulse in the stride. This is typically
-zero but can be a small integer < pulse_stride.
+zero but can be a small integer < pulse_stride. If None, a guess is made.
 """
 
 RawData = NewType("RawData", sc.DataArray)

{essreduce-25.2.2.dist-info → essreduce-25.2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: essreduce
-Version: 25.2.2
+Version: 25.2.4
 Summary: Common data reduction tools for the ESS facility
 Author: Scipp contributors
 License: BSD 3-Clause License
@@ -53,7 +53,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: sciline>=24.06.2
 Requires-Dist: scipp>=25.01.0
-Requires-Dist: scippneutron>=24.11.0
+Requires-Dist: scippneutron>=25.02.0
 Requires-Dist: scippnexus>=24.11.0
 Provides-Extra: test
 Requires-Dist: ipywidgets; extra == "test"

{essreduce-25.2.2.dist-info → essreduce-25.2.4.dist-info}/RECORD

@@ -3,27 +3,27 @@ ess/reduce/data.py,sha256=vaoeAJ6EpK1YghOiAALLdWiW17TgUnnnt0H-RGiGzXk,3756
 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=-ffg5pq0ShVPatLzHqKfWU-qpYmuYZjOrwoKd8J4aJU,9129
+ess/reduce/streaming.py,sha256=ffFiWpq9AK1GOfRG-rlvT_Gz7HMBnE4FD0qPZiej4Gg,10306
 ess/reduce/ui.py,sha256=zmorAbDwX1cU3ygDT--OP58o0qU7OBcmJz03jPeYSLA,10884
 ess/reduce/uncertainty.py,sha256=LR4O6ApB6Z-W9gC_XW0ajupl8yFG-du0eee1AX_R-gk,6990
 ess/reduce/workflow.py,sha256=sL34T_2Cjl_8iFlegujxI9VyOUwo6erVC8pOXnfWgYw,3060
 ess/reduce/live/__init__.py,sha256=jPQVhihRVNtEDrE20PoKkclKV2aBF1lS7cCHootgFgI,204
-ess/reduce/live/raw.py,sha256=W7AxwFApqBzYki-Y_pIt9jZqzcvJnRMsdt1Hu1He4v0,25262
+ess/reduce/live/raw.py,sha256=pzXsPZQERtUm5tabTXjxd-XHH4WDDP13TTBG0lGPcqg,25262
 ess/reduce/live/roi.py,sha256=Hs-pW98k41WU6Kl3UQ41kQawk80c2QNOQ_WNctLzDPE,3795
 ess/reduce/live/workflow.py,sha256=bsbwvTqPhRO6mC__3b7MgU7DWwAnOvGvG-t2n22EKq8,4285
 ess/reduce/nexus/__init__.py,sha256=59bxKkNYg8DYcSykNvH6nCa5SYchJC4SbgZEKhkNdYc,967
-ess/reduce/nexus/_nexus_loader.py,sha256=NbKIepTxv-UirVlViImh8Ozm16k-ZIiF6AQ9-oKuDHU,19222
+ess/reduce/nexus/_nexus_loader.py,sha256=Y8ILMFEP9KxVfyEMGSFKoZZS79DIs0niRqI2Lq2TqZk,19720
 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=Az_pZtaTIlEAA4Po_YOLabez8w4HeHcr0asY3rS6BXg,9676
-ess/reduce/nexus/workflow.py,sha256=jzdh0ubp9Mmb98a04KIeM8Xo9bpAqpnsfwFWz2VllnQ,23676
+ess/reduce/nexus/types.py,sha256=15XcHbNbOfnAYjWXzzKyYDVNyNixRnP0hJ-Q2duwMWE,9896
+ess/reduce/nexus/workflow.py,sha256=ABVc9E1Qcos0wLcDE8bGDAOz3aPpHrj4TJyfHsQbx7I,24297
 ess/reduce/scripts/grow_nexus.py,sha256=hET3h06M0xlJd62E3palNLFvJMyNax2kK4XyJcOhl-I,3387
 ess/reduce/time_of_flight/__init__.py,sha256=92w88NpGIBysuqCPSvdZ_XgBd7cFAk9qaO9zflpUbfM,1097
-ess/reduce/time_of_flight/fakes.py,sha256=UyYxvtnb8QDdCgwaOhe0guRGCKP1DFr0wPXUPO3RNYU,6730
+ess/reduce/time_of_flight/fakes.py,sha256=rlBgceFVbHIhP_xPyUzYVf-2wEu--G8hA-kxPzAnPbM,4236
 ess/reduce/time_of_flight/simulation.py,sha256=CireE9m9kFbUXhGUeY2L3SoMy7kpqopxKj__h4tSKzo,2614
 ess/reduce/time_of_flight/to_events.py,sha256=_5CcUOWvguDcK8uo2pPZWzXnWoiZhC1w-zF8xysaIvU,4339
-ess/reduce/time_of_flight/toa_to_tof.py,sha256=crvNe6GIwHLrSUE_C3omDfroIujoH1rphwWhX8Dj25U,20601
-ess/reduce/time_of_flight/types.py,sha256=fIgnLKv6QolevXwrY5hD2-eC_7wtNlVJ-k6CvaeRJQk,5014
+ess/reduce/time_of_flight/toa_to_tof.py,sha256=bt28z6wixS4AegBxsl1uYBREP08TyAs8Y9Z738YcXE4,23476
+ess/reduce/time_of_flight/types.py,sha256=Iv1XGLbrZ9bD4CPAVhsIPkAaB46YC7l7yf5XweljLqk,5047
 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
@@ -36,9 +36,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.2.2.dist-info/LICENSE,sha256=nVEiume4Qj6jMYfSRjHTM2jtJ4FGu0g-5Sdh7osfEYw,1553
-essreduce-25.2.2.dist-info/METADATA,sha256=l7vAVarbV9x-4mXfgstnKGyX0w4Yzcan8JCtwEPQbJM,3708
-essreduce-25.2.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-essreduce-25.2.2.dist-info/entry_points.txt,sha256=PMZOIYzCifHMTe4pK3HbhxUwxjFaZizYlLD0td4Isb0,66
-essreduce-25.2.2.dist-info/top_level.txt,sha256=0JxTCgMKPLKtp14wb1-RKisQPQWX7i96innZNvHBr-s,4
-essreduce-25.2.2.dist-info/RECORD,,
+essreduce-25.2.4.dist-info/LICENSE,sha256=nVEiume4Qj6jMYfSRjHTM2jtJ4FGu0g-5Sdh7osfEYw,1553
+essreduce-25.2.4.dist-info/METADATA,sha256=4esgkOAUN-XvPn_1HnmisKvJvG5RA0UGFUrmVQPyg50,3708
+essreduce-25.2.4.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+essreduce-25.2.4.dist-info/entry_points.txt,sha256=PMZOIYzCifHMTe4pK3HbhxUwxjFaZizYlLD0td4Isb0,66
+essreduce-25.2.4.dist-info/top_level.txt,sha256=0JxTCgMKPLKtp14wb1-RKisQPQWX7i96innZNvHBr-s,4
+essreduce-25.2.4.dist-info/RECORD,,