essreduce 25.12.1__tar.gz → 26.1.1__tar.gz

{essreduce-25.12.1 → essreduce-26.1.1}/PKG-INFO

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

{essreduce-25.12.1 → essreduce-26.1.1}/docs/user-guide/tof/dream.ipynb

@@ -311,7 +311,7 @@
    "id": "21",
    "metadata": {},
    "source": [
-    "By default, the workflow tries to load a `TimeOfFlightLookupTable` from a file.\n",
+    "By default, the workflow tries to load a `TofLookupTable` from a file.\n",
     "\n",
     "In this notebook, instead of using such a pre-made file,\n",
     "we will build our own lookup table from the chopper information and apply it to the workflow."
@@ -346,7 +346,7 @@
     "    sc.scalar(75.5, unit=\"m\"),\n",
     "    sc.scalar(78.0, unit=\"m\"),\n",
     ")\n",
-    "lut_wf.visualize(TimeOfFlightLookupTable)"
+    "lut_wf.visualize(TofLookupTable)"
    ]
   },
   {
@@ -411,7 +411,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "table = lut_wf.compute(TimeOfFlightLookupTable)\n",
+    "table = lut_wf.compute(TofLookupTable)\n",
     "\n",
     "# Overlay mean on the figure above\n",
     "table.array[\"distance\", 13].plot(ax=fig2.ax, color=\"C1\", ls=\"-\", marker=None)"
@@ -453,7 +453,7 @@
    "outputs": [],
    "source": [
     "# Set the computed lookup table onto the original workflow\n",
-    "wf[TimeOfFlightLookupTable] = table\n",
+    "wf[TofLookupTable] = table\n",
     "\n",
     "# Compute time-of-flight of neutron events\n",
     "tofs = wf.compute(TofDetector[SampleRun])\n",
@@ -743,7 +743,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "table = lut_wf.compute(TimeOfFlightLookupTable).array\n",
+    "table = lut_wf.compute(TofLookupTable).array\n",
     "table.plot() / (sc.stddevs(table) / sc.values(table)).plot(norm=\"log\")"
    ]
   },
@@ -769,7 +769,7 @@
    "source": [
     "lut_wf[LookupTableRelativeErrorThreshold] = 0.01\n",
     "\n",
-    "table = lut_wf.compute(TimeOfFlightLookupTable)\n",
+    "table = lut_wf.compute(TofLookupTable)\n",
     "table.plot()"
    ]
   },
@@ -797,7 +797,7 @@
     "wf[RawDetector[SampleRun]] = ess_beamline.get_monitor(\"detector\")[0]\n",
     "wf[DetectorLtotal[SampleRun]] = Ltotal\n",
     "\n",
-    "wf[TimeOfFlightLookupTable] = table\n",
+    "wf[TofLookupTable] = table\n",
     "\n",
     "# Compute time-of-flight\n",
     "tofs = wf.compute(TofDetector[SampleRun])\n",

{essreduce-25.12.1 → essreduce-26.1.1}/docs/user-guide/tof/frame-unwrapping.ipynb

@@ -171,7 +171,7 @@
    "id": "9",
    "metadata": {},
    "source": [
-    "By default, the workflow tries to load a `TimeOfFlightLookupTable` from a file.\n",
+    "By default, the workflow tries to load a `TofLookupTable` from a file.\n",
     "\n",
     "In this notebook, instead of using such a pre-made file,\n",
     "we will build our own lookup table from the chopper information and apply it to the workflow.\n",
@@ -227,7 +227,7 @@
     "}\n",
     "lut_wf[SourcePosition] = sc.vector([0, 0, 0], unit=\"m\")\n",
     "\n",
-    "lut_wf.visualize(TimeOfFlightLookupTable)"
+    "lut_wf.visualize(TofLookupTable)"
    ]
   },
   {
@@ -245,7 +245,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "table = lut_wf.compute(TimeOfFlightLookupTable)\n",
+    "table = lut_wf.compute(TofLookupTable)\n",
     "table.plot()"
    ]
   },
@@ -267,7 +267,7 @@
    "outputs": [],
    "source": [
     "# Set the computed lookup table on the original workflow\n",
-    "wf[TimeOfFlightLookupTable] = table\n",
+    "wf[TofLookupTable] = table\n",
     "\n",
     "# Compute neutron tofs\n",
     "tofs = wf.compute(TofDetector[SampleRun])\n",
@@ -432,7 +432,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "table = lut_wf.compute(TimeOfFlightLookupTable)\n",
+    "table = lut_wf.compute(TofLookupTable)\n",
     "\n",
     "table.plot(figsize=(9, 4))"
    ]
@@ -457,7 +457,7 @@
     "nxevent_data = results.to_nxevent_data()\n",
     "wf[RawDetector[SampleRun]] = nxevent_data\n",
     "wf[DetectorLtotal[SampleRun]] = nxevent_data.coords[\"Ltotal\"]\n",
-    "wf[TimeOfFlightLookupTable] = table\n",
+    "wf[TofLookupTable] = table\n",
     "\n",
     "tofs = wf.compute(TofDetector[SampleRun])\n",
     "\n",

{essreduce-25.12.1 → essreduce-26.1.1}/docs/user-guide/tof/wfm.ipynb

@@ -332,7 +332,7 @@
    "id": "20",
    "metadata": {},
    "source": [
-    "By default, the workflow tries to load a `TimeOfFlightLookupTable` from a file.\n",
+    "By default, the workflow tries to load a `TofLookupTable` from a file.\n",
     "\n",
     "In this notebook, instead of using such a pre-made file,\n",
     "we will build our own lookup table from the chopper information and apply it to the workflow."
@@ -365,7 +365,7 @@
     "lut_wf[SourcePosition] = source_position\n",
     "lut_wf[LtotalRange] = Ltotal, Ltotal\n",
     "lut_wf[LookupTableRelativeErrorThreshold] = 0.1\n",
-    "lut_wf.visualize(TimeOfFlightLookupTable)"
+    "lut_wf.visualize(TofLookupTable)"
    ]
   },
   {
@@ -430,7 +430,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "table = lut_wf.compute(TimeOfFlightLookupTable)\n",
+    "table = lut_wf.compute(TofLookupTable)\n",
     "\n",
     "# Overlay mean on the figure above\n",
     "table.array[\"distance\", 1].plot(ax=fig2.ax, color=\"C1\", ls=\"-\", marker=None)\n",
@@ -463,7 +463,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "wf[TimeOfFlightLookupTable] = table\n",
+    "wf[TofLookupTable] = table\n",
     "\n",
     "tofs = wf.compute(TofDetector[SampleRun])\n",
     "tofs"

{essreduce-25.12.1 → essreduce-26.1.1}/requirements/base.txt

@@ -67,7 +67,7 @@ python-dateutil==2.9.0.post0
     #   scippneutron
 sciline==25.11.1
     # via -r base.in
-scipp==25.11.0
+scipp==25.12.0
     # via
     #   -r base.in
     #   scippneutron

{essreduce-25.12.1 → essreduce-26.1.1}/requirements/basetest.txt

@@ -99,7 +99,7 @@ python-dateutil==2.9.0.post0
     # via matplotlib
 requests==2.32.5
     # via pooch
-scipp==25.11.0
+scipp==25.12.0
     # via tof
 scipy==1.16.3
     # via -r basetest.in

{essreduce-25.12.1 → essreduce-26.1.1}/src/ess/reduce/streaming.py

@@ -108,6 +108,14 @@ class Accumulator(ABC, Generic[T]):
         Clear the accumulator, resetting it to its initial state.
         """
 
+    def on_finalize(self) -> None:
+        """
+        Called after finalize retrieves value.
+
+        Override this method to perform custom cleanup after each finalize cycle.
+        The default implementation does nothing.
+        """
+
 
 class EternalAccumulator(Accumulator[T]):
     """
@@ -422,6 +430,9 @@ class StreamProcessor:
             needs_recompute |= self._context_key_to_cached_context_nodes_map[key]
         for key, value in context.items():
             self._context_workflow[key] = value
+            # Propagate context values to finalize workflow so providers that depend
+            # on context keys receive the updated values during finalize().
+            self._finalize_workflow[key] = value
         results = self._context_workflow.compute(needs_recompute)
         for key, value in results.items():
             if key in self._target_keys:
@@ -505,7 +516,10 @@ class StreamProcessor:
         """
         for key in self._accumulators:
             self._finalize_workflow[key] = self._accumulators[key].value
-        return self._finalize_workflow.compute(self._target_keys)
+        result = self._finalize_workflow.compute(self._target_keys)
+        for acc in self._accumulators.values():
+            acc.on_finalize()
+        return result
 
     def clear(self) -> None:
         """

{essreduce-25.12.1 → essreduce-26.1.1}/src/ess/reduce/time_of_flight/__init__.py

@@ -30,6 +30,8 @@ from .types import (
     TimeOfFlightLookupTableFilename,
     ToaDetector,
     TofDetector,
+    TofLookupTable,
+    TofLookupTableFilename,
     TofMonitor,
 )
 from .workflow import GenericTofWorkflow
@@ -54,6 +56,8 @@ __all__ = [
     "TimeResolution",
     "ToaDetector",
     "TofDetector",
+    "TofLookupTable",
+    "TofLookupTableFilename",
     "TofLookupTableWorkflow",
     "TofMonitor",
     "providers",

{essreduce-25.12.1 → essreduce-26.1.1}/src/ess/reduce/time_of_flight/eto_to_tof.py

@@ -35,9 +35,9 @@ from .types import (
     DetectorLtotal,
     MonitorLtotal,
     PulseStrideOffset,
-    TimeOfFlightLookupTable,
     ToaDetector,
     TofDetector,
+    TofLookupTable,
     TofMonitor,
 )
 
@@ -96,7 +96,7 @@ class TofInterpolator:
 
 
 def _time_of_flight_data_histogram(
-    da: sc.DataArray, lookup: TimeOfFlightLookupTable, ltotal: sc.Variable
+    da: sc.DataArray, lookup: TofLookupTable, 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'.
@@ -201,7 +201,7 @@ def _guess_pulse_stride_offset(
 
 def _prepare_tof_interpolation_inputs(
     da: sc.DataArray,
-    lookup: TimeOfFlightLookupTable,
+    lookup: TofLookupTable,
     ltotal: sc.Variable,
     pulse_stride_offset: int | None,
 ) -> dict:
@@ -295,7 +295,7 @@ def _prepare_tof_interpolation_inputs(
 
 def _time_of_flight_data_events(
     da: sc.DataArray,
-    lookup: TimeOfFlightLookupTable,
+    lookup: TofLookupTable,
     ltotal: sc.Variable,
     pulse_stride_offset: int | None,
 ) -> sc.DataArray:
@@ -395,7 +395,7 @@ def monitor_ltotal_from_straight_line_approximation(
 
 def _compute_tof_data(
     da: sc.DataArray,
-    lookup: TimeOfFlightLookupTable,
+    lookup: TofLookupTable,
     ltotal: sc.Variable,
     pulse_stride_offset: int,
 ) -> sc.DataArray:
@@ -413,7 +413,7 @@ def _compute_tof_data(
 
 def detector_time_of_flight_data(
     detector_data: RawDetector[RunType],
-    lookup: TimeOfFlightLookupTable,
+    lookup: TofLookupTable,
     ltotal: DetectorLtotal[RunType],
     pulse_stride_offset: PulseStrideOffset,
 ) -> TofDetector[RunType]:
@@ -447,7 +447,7 @@ def detector_time_of_flight_data(
 
 def monitor_time_of_flight_data(
     monitor_data: RawMonitor[RunType, MonitorType],
-    lookup: TimeOfFlightLookupTable,
+    lookup: TofLookupTable,
     ltotal: MonitorLtotal[RunType, MonitorType],
     pulse_stride_offset: PulseStrideOffset,
 ) -> TofMonitor[RunType, MonitorType]:
@@ -481,7 +481,7 @@ def monitor_time_of_flight_data(
 
 def detector_time_of_arrival_data(
     detector_data: RawDetector[RunType],
-    lookup: TimeOfFlightLookupTable,
+    lookup: TofLookupTable,
     ltotal: DetectorLtotal[RunType],
     pulse_stride_offset: PulseStrideOffset,
 ) -> ToaDetector[RunType]:

{essreduce-25.12.1 → essreduce-26.1.1}/src/ess/reduce/time_of_flight/lut.py

@@ -13,7 +13,7 @@ import sciline as sl
 import scipp as sc
 
 from ..nexus.types import AnyRun, DiskChoppers
-from .types import TimeOfFlightLookupTable
+from .types import TofLookupTable
 
 
 @dataclass
@@ -30,9 +30,6 @@ class SimulationResults:
     time_of_arrival:
         Time of arrival of the neutrons at the position where the events were recorded
         (1d array of size N).
-    speed:
-        Speed of the neutrons, typically derived from the wavelength of the neutrons
-        (1d array of size N).
     wavelength:
         Wavelength of the neutrons (1d array of size N).
     weight:
@@ -48,12 +45,14 @@ class SimulationResults:
     """
 
     time_of_arrival: sc.Variable
-    speed: sc.Variable
     wavelength: sc.Variable
     weight: sc.Variable
     distance: sc.Variable
     choppers: DiskChoppers[AnyRun] | None = None
 
+    def __post_init__(self):
+        self.speed = (sc.constants.h / sc.constants.m_n) / self.wavelength
+
 
 NumberOfSimulatedNeutrons = NewType("NumberOfSimulatedNeutrons", int)
 """
@@ -230,7 +229,7 @@ def make_tof_lookup_table(
     pulse_period: PulsePeriod,
     pulse_stride: PulseStride,
     error_threshold: LookupTableRelativeErrorThreshold,
-) -> TimeOfFlightLookupTable:
+) -> TofLookupTable:
     """
     Compute a lookup table for time-of-flight as a function of distance and
     time-of-arrival.
@@ -239,7 +238,7 @@ def make_tof_lookup_table(
     ----------
     simulation:
         Results of a time-of-flight simulation used to create a lookup table.
-        The results should be a flat table with columns for time-of-arrival, speed,
+        The results should be a flat table with columns for time-of-arrival,
         wavelength, and weight.
     ltotal_range:
         Range of total flight path lengths from the source to the detector.
@@ -372,7 +371,7 @@ def make_tof_lookup_table(
     # In-place masking for better performance
     _mask_large_uncertainty(table, error_threshold)
 
-    return TimeOfFlightLookupTable(
+    return TofLookupTable(
         array=table,
         pulse_period=pulse_period,
         pulse_stride=pulse_stride,
@@ -398,13 +397,13 @@ def simulate_chopper_cascade_using_tof(
 ) -> SimulationResults:
     """
     Simulate a pulse of neutrons propagating through a chopper cascade using the
-    ``tof`` package (https://tof.readthedocs.io).
+    ``tof`` package (https://scipp.github.io/tof).
 
     Parameters
     ----------
     choppers:
         A dict of DiskChopper objects representing the choppers in the beamline. See
-        https://scipp.github.io/scippneutron/user-guide/chopper/processing-nexus-choppers.html#Build-DiskChopper
+        https://scipp.github.io/scippneutron/user-guide/chopper/processing-nexus-choppers.html
         for more information.
     source_position:
         A scalar variable with ``dtype=vector3`` that defines the source position.
@@ -436,7 +435,6 @@ def simulate_chopper_cascade_using_tof(
         events = source.data.squeeze().flatten(to='event')
         return SimulationResults(
             time_of_arrival=events.coords["birth_time"],
-            speed=events.coords["speed"],
             wavelength=events.coords["wavelength"],
             weight=events.data,
             distance=0.0 * sc.units.m,
@@ -451,7 +449,6 @@ def simulate_chopper_cascade_using_tof(
     ]
     return SimulationResults(
         time_of_arrival=events.coords["toa"],
-        speed=events.coords["speed"],
         wavelength=events.coords["wavelength"],
         weight=events.data,
         distance=furthest_chopper.distance,

{essreduce-25.12.1 → essreduce-26.1.1}/src/ess/reduce/time_of_flight/types.py

@@ -10,12 +10,15 @@ import scipp as sc
 
 from ..nexus.types import MonitorType, RunType
 
-TimeOfFlightLookupTableFilename = NewType("TimeOfFlightLookupTableFilename", str)
+TofLookupTableFilename = NewType("TofLookupTableFilename", str)
 """Filename of the time-of-flight lookup table."""
 
+TimeOfFlightLookupTableFilename = TofLookupTableFilename
+"""Filename of the time-of-flight lookup table (alias)."""
+
 
 @dataclass
-class TimeOfFlightLookupTable:
+class TofLookupTable:
     """
     Lookup table giving time-of-flight as a function of distance and time of arrival.
     """
@@ -47,6 +50,10 @@ class TimeOfFlightLookupTable:
         return self.array.plot(*args, **kwargs)
 
 
+TimeOfFlightLookupTable = TofLookupTable
+"""Lookup table giving time-of-flight as a function of distance and time of arrival
+(alias)."""
+
 PulseStrideOffset = NewType("PulseStrideOffset", int | None)
 """
 When pulse-skipping, the offset of the first pulse in the stride. This is typically

{essreduce-25.12.1 → essreduce-26.1.1}/src/ess/reduce/time_of_flight/workflow.py

@@ -9,14 +9,14 @@ from ..nexus import GenericNeXusWorkflow
 from . import eto_to_tof
 from .types import (
     PulseStrideOffset,
-    TimeOfFlightLookupTable,
-    TimeOfFlightLookupTableFilename,
+    TofLookupTable,
+    TofLookupTableFilename,
 )
 
 
 def load_tof_lookup_table(
-    filename: TimeOfFlightLookupTableFilename,
-) -> TimeOfFlightLookupTable:
+    filename: TofLookupTableFilename,
+) -> TofLookupTable:
     """Load a time-of-flight lookup table from an HDF5 file."""
     table = sc.io.load_hdf5(filename)
 
@@ -40,7 +40,7 @@ def load_tof_lookup_table(
             "error_threshold": table.coords["error_threshold"].value,
         }
 
-    return TimeOfFlightLookupTable(**table)
+    return TofLookupTable(**table)
 
 
 def GenericTofWorkflow(

{essreduce-25.12.1 → essreduce-26.1.1}/src/essreduce.egg-info/PKG-INFO

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

{essreduce-25.12.1 → essreduce-26.1.1}/tests/streaming_test.py

@@ -908,3 +908,132 @@ def test_StreamProcessor_rejects_context_keys_depending_on_dynamic_keys() -> Non
             target_keys=(Output,),
             accumulators=(Output,),
         )
+
+
+def test_StreamProcessor_calls_on_finalize_after_finalize() -> None:
+    """Test that on_finalize hook is called on accumulators after finalize."""
+
+    class TrackingAccumulator(streaming.EternalAccumulator[sc.Variable]):
+        def __init__(self) -> None:
+            super().__init__()
+            self.finalize_count = 0
+
+        def on_finalize(self) -> None:
+            self.finalize_count += 1
+
+    base_workflow = sciline.Pipeline(
+        (make_static_a, make_accum_a, make_accum_b, make_target)
+    )
+
+    accum_a = TrackingAccumulator()
+    accum_b = TrackingAccumulator()
+
+    streaming_wf = streaming.StreamProcessor(
+        base_workflow=base_workflow,
+        dynamic_keys=(DynamicA, DynamicB),
+        target_keys=(Target,),
+        accumulators={AccumA: accum_a, AccumB: accum_b},
+    )
+
+    assert accum_a.finalize_count == 0
+    assert accum_b.finalize_count == 0
+
+    streaming_wf.accumulate({DynamicA: sc.scalar(1), DynamicB: sc.scalar(4)})
+    result = streaming_wf.finalize()
+    assert sc.identical(result[Target], sc.scalar(2 * 1.0 / 4.0))
+
+    assert accum_a.finalize_count == 1
+    assert accum_b.finalize_count == 1
+
+    streaming_wf.accumulate({DynamicA: sc.scalar(2), DynamicB: sc.scalar(5)})
+    result = streaming_wf.finalize()
+    assert sc.identical(result[Target], sc.scalar(2 * 3.0 / 9.0))
+
+    assert accum_a.finalize_count == 2
+    assert accum_b.finalize_count == 2
+
+
+def test_on_finalize_can_clear_accumulator_for_window_behavior() -> None:
+    """Test that on_finalize can be used to create windowed accumulators."""
+
+    class WindowAccumulator(streaming.EternalAccumulator[sc.Variable]):
+        """Accumulator that clears after each finalize cycle."""
+
+        def on_finalize(self) -> None:
+            self.clear()
+
+    base_workflow = sciline.Pipeline(
+        (make_static_a, make_accum_a, make_accum_b, make_target)
+    )
+
+    # Use windowed accumulator for AccumA, eternal for AccumB
+    streaming_wf = streaming.StreamProcessor(
+        base_workflow=base_workflow,
+        dynamic_keys=(DynamicA, DynamicB),
+        target_keys=(Target,),
+        accumulators={
+            AccumA: WindowAccumulator(),
+            AccumB: streaming.EternalAccumulator(),
+        },
+    )
+
+    streaming_wf.accumulate({DynamicA: sc.scalar(1), DynamicB: sc.scalar(4)})
+    result = streaming_wf.finalize()
+    # AccumA = 2*1 = 2, AccumB = 4
+    assert sc.identical(result[Target], sc.scalar(2 * 1.0 / 4.0))
+
+    streaming_wf.accumulate({DynamicA: sc.scalar(2), DynamicB: sc.scalar(5)})
+    result = streaming_wf.finalize()
+    # AccumA was cleared, now 2*2 = 4, AccumB accumulated to 4+5 = 9
+    assert sc.identical(result[Target], sc.scalar(2 * 2.0 / 9.0))
+
+    streaming_wf.accumulate({DynamicA: sc.scalar(3), DynamicB: sc.scalar(6)})
+    result = streaming_wf.finalize()
+    # AccumA was cleared, now 2*3 = 6, AccumB accumulated to 9+6 = 15
+    assert sc.identical(result[Target], sc.scalar(2 * 3.0 / 15.0))
+
+
+def test_StreamProcessor_finalize_provider_uses_context_directly() -> None:
+    """Test that finalize-time providers can access context keys directly.
+
+    This covers the case where a provider that runs during finalize() (i.e., one
+    that depends on accumulated values) also needs access to a context key.
+    The context value must be propagated to the finalize workflow.
+    """
+    Streamed = NewType('Streamed', int)
+    Context = NewType('Context', int)
+    Accumulated = NewType('Accumulated', int)
+    Output = NewType('Output', int)
+
+    def accumulate(streamed: Streamed) -> Accumulated:
+        return Accumulated(streamed)
+
+    def make_output(accumulated: Accumulated, context: Context) -> Output:
+        # This provider runs at finalize time (depends on Accumulated)
+        # and needs direct access to Context
+        return Output(accumulated + context)
+
+    wf = sciline.Pipeline((accumulate, make_output))
+    streaming_wf = streaming.StreamProcessor(
+        base_workflow=wf,
+        dynamic_keys=(Streamed,),
+        context_keys=(Context,),
+        target_keys=(Output,),
+        accumulators=(Accumulated,),
+    )
+
+    streaming_wf.set_context({Context: sc.scalar(100)})
+    streaming_wf.accumulate({Streamed: sc.scalar(1)})
+    streaming_wf.accumulate({Streamed: sc.scalar(2)})
+    result = streaming_wf.finalize()
+
+    # Accumulated = 1 + 2 = 3, Context = 100, Output = 3 + 100 = 103
+    assert sc.identical(result[Output], sc.scalar(103))
+
+    # Update context and verify finalize sees the new value
+    streaming_wf.set_context({Context: sc.scalar(200)})
+    streaming_wf.accumulate({Streamed: sc.scalar(4)})
+    result = streaming_wf.finalize()
+
+    # Accumulated = 3 + 4 = 7, Context = 200, Output = 7 + 200 = 207
+    assert sc.identical(result[Output], sc.scalar(207))

{essreduce-25.12.1 → essreduce-26.1.1}/tests/time_of_flight/lut_test.py

@@ -26,7 +26,7 @@ def test_lut_workflow_computes_table():
     wf[time_of_flight.DistanceResolution] = dres
     wf[time_of_flight.TimeResolution] = tres
 
-    table = wf.compute(time_of_flight.TimeOfFlightLookupTable)
+    table = wf.compute(time_of_flight.TofLookupTable)
 
     assert table.array.coords['distance'].min() < lmin
     assert table.array.coords['distance'].max() > lmax
@@ -56,7 +56,7 @@ def test_lut_workflow_computes_table_in_chunks():
     wf[time_of_flight.DistanceResolution] = dres
     wf[time_of_flight.TimeResolution] = tres
 
-    table = wf.compute(time_of_flight.TimeOfFlightLookupTable)
+    table = wf.compute(time_of_flight.TofLookupTable)
 
     assert table.array.coords['distance'].min() < lmin
     assert table.array.coords['distance'].max() > lmax
@@ -85,7 +85,7 @@ def test_lut_workflow_pulse_skipping():
     wf[time_of_flight.DistanceResolution] = dres
     wf[time_of_flight.TimeResolution] = tres
 
-    table = wf.compute(time_of_flight.TimeOfFlightLookupTable)
+    table = wf.compute(time_of_flight.TofLookupTable)
 
     assert table.array.coords['event_time_offset'].max() == 2 * sc.scalar(
         1 / 14, unit='s'
@@ -108,7 +108,7 @@ def test_lut_workflow_non_exact_distance_range():
     wf[time_of_flight.DistanceResolution] = dres
     wf[time_of_flight.TimeResolution] = tres
 
-    table = wf.compute(time_of_flight.TimeOfFlightLookupTable)
+    table = wf.compute(time_of_flight.TofLookupTable)
 
     assert table.array.coords['distance'].min() < lmin
     assert table.array.coords['distance'].max() > lmax

{essreduce-25.12.1 → essreduce-26.1.1}/tests/time_of_flight/unwrap_test.py

@@ -75,9 +75,7 @@ def _make_workflow_event_mode(
     lut_wf[time_of_flight.LtotalRange] = distance, distance
     lut_wf[time_of_flight.LookupTableRelativeErrorThreshold] = error_threshold
 
-    pl[time_of_flight.TimeOfFlightLookupTable] = lut_wf.compute(
-        time_of_flight.TimeOfFlightLookupTable
-    )
+    pl[time_of_flight.TofLookupTable] = lut_wf.compute(time_of_flight.TofLookupTable)
 
     return pl, ref
 
@@ -104,9 +102,7 @@ def _make_workflow_histogram_mode(dim, distance, choppers, lut_workflow, seed):
     lut_wf = lut_workflow.copy()
     lut_wf[time_of_flight.LtotalRange] = distance, distance
 
-    pl[time_of_flight.TimeOfFlightLookupTable] = lut_wf.compute(
-        time_of_flight.TimeOfFlightLookupTable
-    )
+    pl[time_of_flight.TofLookupTable] = lut_wf.compute(time_of_flight.TofLookupTable)
 
     return pl, ref
 
@@ -340,9 +336,7 @@ def test_pulse_skipping_unwrap_when_first_half_of_first_pulse_is_missing() -> No
     pl[RawDetector[SampleRun]] = a.bins.concat('event_time_zero')
     pl[time_of_flight.DetectorLtotal[SampleRun]] = distance
 
-    pl[time_of_flight.TimeOfFlightLookupTable] = lut_wf.compute(
-        time_of_flight.TimeOfFlightLookupTable
-    )
+    pl[time_of_flight.TofLookupTable] = lut_wf.compute(time_of_flight.TofLookupTable)
     pl[time_of_flight.PulseStrideOffset] = 1  # Start the stride at the second pulse
 
     tofs = pl.compute(time_of_flight.TofDetector[SampleRun])