essreduce 26.1.0__tar.gz → 26.1.1__tar.gz

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

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

{essreduce-26.1.0 → 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-26.1.0 → essreduce-26.1.1}/src/ess/reduce/time_of_flight/lut.py

@@ -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)
 """
@@ -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.
@@ -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-26.1.0 → essreduce-26.1.1}/src/essreduce.egg-info/PKG-INFO

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

{essreduce-26.1.0 → 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))