essreduce 25.2.2__tar.gz → 25.2.3__tar.gz

{essreduce-25.2.2/src/essreduce.egg-info → essreduce-25.2.3}/PKG-INFO

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

{essreduce-25.2.2 → essreduce-25.2.3}/docs/user-guide/tof/dream.ipynb

@@ -290,6 +290,7 @@
     "    time_of_flight.providers(), params=time_of_flight.default_parameters()\n",
     ")\n",
     "workflow[time_of_flight.RawData] = raw_data\n",
+    "workflow[time_of_flight.Ltotal] = Ltotal\n",
     "workflow[time_of_flight.LtotalRange] = (\n",
     "    sc.scalar(75.5, unit=\"m\"),\n",
     "    sc.scalar(78.0, unit=\"m\"),\n",
@@ -565,6 +566,7 @@
    "source": [
     "# Update workflow\n",
     "workflow[time_of_flight.RawData] = raw_data\n",
+    "workflow[time_of_flight.Ltotal] = Ltotal\n",
     "\n",
     "# Compute tofs and wavelengths\n",
     "tofs = workflow.compute(time_of_flight.TofData)\n",
@@ -663,6 +665,7 @@
     "    choppers=disk_choppers, neutrons=2_000_000\n",
     ")\n",
     "workflow[time_of_flight.RawData] = ess_beamline.get_monitor(\"detector\")[0]\n",
+    "workflow[time_of_flight.Ltotal] = Ltotal\n",
     "\n",
     "sim = workflow.compute(time_of_flight.SimulationResults)\n",
     "\n",

{essreduce-25.2.2 → essreduce-25.2.3}/docs/user-guide/tof/frame-unwrapping.ipynb

@@ -164,6 +164,7 @@
     ")\n",
     "\n",
     "workflow[time_of_flight.RawData] = nxevent_data\n",
+    "workflow[time_of_flight.Ltotal] = nxevent_data.coords[\"Ltotal\"]\n",
     "workflow[time_of_flight.LtotalRange] = detectors[0].distance, detectors[-1].distance\n",
     "workflow[time_of_flight.SimulationResults] = time_of_flight.simulate_beamline(\n",
     "    choppers={\n",
@@ -345,7 +346,7 @@
     "\n",
     "model = tof.Model(source=source, choppers=choppers, detectors=detectors)\n",
     "results = model.run()\n",
-    "results.plot(cmap=\"viridis_r\", blocked_rays=5000)"
+    "results.plot(blocked_rays=5000)"
    ]
   },
   {
@@ -372,8 +373,11 @@
     "    time_of_flight.providers(), params=time_of_flight.default_parameters()\n",
     ")\n",
     "\n",
+    "nxevent_data = results.to_nxevent_data()\n",
+    "\n",
     "workflow[time_of_flight.PulseStride] = 2\n",
-    "workflow[time_of_flight.RawData] = results.to_nxevent_data()\n",
+    "workflow[time_of_flight.RawData] = nxevent_data\n",
+    "workflow[time_of_flight.Ltotal] = nxevent_data.coords[\"Ltotal\"]\n",
     "workflow[time_of_flight.LtotalRange] = detectors[0].distance, detectors[-1].distance\n",
     "workflow[time_of_flight.SimulationResults] = time_of_flight.simulate_beamline(\n",
     "    choppers={\n",
@@ -391,7 +395,6 @@
     "        )\n",
     "        for ch in choppers\n",
     "    },\n",
-    "    neutrons=500_000,\n",
     ")\n",
     "\n",
     "workflow[time_of_flight.DistanceResolution] = sc.scalar(0.5, unit=\"m\")\n",

{essreduce-25.2.2 → essreduce-25.2.3}/docs/user-guide/tof/wfm.ipynb

@@ -310,6 +310,7 @@
     "    time_of_flight.providers(), params=time_of_flight.default_parameters()\n",
     ")\n",
     "workflow[time_of_flight.RawData] = raw_data\n",
+    "workflow[time_of_flight.Ltotal] = Ltotal\n",
     "workflow[time_of_flight.LtotalRange] = Ltotal, Ltotal\n",
     "workflow[time_of_flight.LookupTableRelativeErrorThreshold] = 0.1\n",
     "\n",

{essreduce-25.2.2 → essreduce-25.2.3}/src/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')
 
 

{essreduce-25.2.2 → essreduce-25.2.3}/src/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)
 

essreduce-25.2.3/src/ess/reduce/time_of_flight/fakes.py

@@ -0,0 +1,119 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright (c) 2025 Scipp contributors (https://github.com/scipp)
+"""
+A fake time-of-flight neutron beamline for documentation and testing.
+
+This provides detector event data in a structure as typically provided in a NeXus file,
+with event_time_offset and event_time_zero information.
+"""
+
+from collections.abc import Callable
+
+import numpy as np
+import scipp as sc
+from scippneutron.chopper import DiskChopper
+
+
+class FakeBeamline:
+    def __init__(
+        self,
+        choppers: dict[str, DiskChopper],
+        monitors: dict[str, sc.Variable],
+        run_length: sc.Variable,
+        events_per_pulse: int = 200000,
+        seed: int | None = None,
+        source: Callable | None = None,
+    ):
+        import math
+
+        import tof as tof_pkg
+        from tof.facilities.ess_pulse import pulse
+
+        self.frequency = pulse.frequency
+        self.npulses = math.ceil((run_length * self.frequency).to(unit="").value)
+        self.events_per_pulse = events_per_pulse
+
+        # Create a source
+        if source is None:
+            self.source = tof_pkg.Source(
+                facility="ess",
+                neutrons=self.events_per_pulse,
+                pulses=self.npulses,
+                seed=seed,
+            )
+        else:
+            self.source = source(pulses=self.npulses)
+
+        # Convert the choppers to tof.Chopper
+        self.choppers = [
+            tof_pkg.Chopper(
+                frequency=abs(ch.frequency),
+                direction=tof_pkg.AntiClockwise
+                if (ch.frequency.value > 0.0)
+                else tof_pkg.Clockwise,
+                open=ch.slit_begin,
+                close=ch.slit_end,
+                phase=abs(ch.phase),
+                distance=ch.axle_position.fields.z,
+                name=name,
+            )
+            for name, ch in choppers.items()
+        ]
+
+        # Add detectors
+        self.monitors = [
+            tof_pkg.Detector(distance=distance, name=key)
+            for key, distance in monitors.items()
+        ]
+
+        #  Propagate the neutrons
+        self.model = tof_pkg.Model(
+            source=self.source, choppers=self.choppers, detectors=self.monitors
+        )
+        self.model_result = self.model.run()
+
+    def get_monitor(self, name: str) -> sc.DataGroup:
+        nx_event_data = self.model_result.to_nxevent_data(name)
+        raw_data = self.model_result.detectors[name].data.flatten(to="event")
+        raw_data = raw_data[~raw_data.masks["blocked_by_others"]].copy()
+        return nx_event_data, raw_data
+
+
+def psc_choppers():
+    return {
+        "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"),
+        )
+    }
+
+
+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"),
+        ),
+        "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"),
+        ),
+    }

{essreduce-25.2.2 → essreduce-25.2.3}/src/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)

{essreduce-25.2.2 → essreduce-25.2.3}/src/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 → essreduce-25.2.3/src/essreduce.egg-info}/PKG-INFO

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

{essreduce-25.2.2 → essreduce-25.2.3}/tests/streaming_test.py

@@ -96,9 +96,11 @@ def test_rolling_accumulator_does_not_modify_pushed_values() -> None:
 
 DynamicA = NewType('DynamicA', float)
 DynamicB = NewType('DynamicB', float)
+DynamicC = NewType('DynamicC', float)
 StaticA = NewType('StaticA', float)
 AccumA = NewType('AccumA', float)
 AccumB = NewType('AccumB', float)
+AccumC = NewType('AccumC', float)
 Target = NewType('Target', float)
 
 
@@ -118,6 +120,10 @@ def make_accum_b(value: DynamicB) -> AccumB:
     return AccumB(value)
 
 
+def make_accum_c(value: DynamicC) -> AccumC:
+    return AccumC(value)
+
+
 def make_target(accum_a: AccumA, accum_b: AccumB) -> Target:
     return Target(accum_a / accum_b)
 
@@ -322,3 +328,103 @@ def test_StreamProcessor_calls_providers_after_accumulators_only_when_finalizing
     assert sc.identical(result[Target], sc.scalar(2 * 6.0 / 15.0))
     # Outputs are not cached.
     assert _make_target.call_count == 3
+
+
+def test_StreamProcessor_does_not_reuse_dynamic_keys() -> None:
+    base_workflow = sciline.Pipeline(
+        (make_accum_a, make_accum_b, make_target), params={StaticA: 2.0}
+    )
+    orig_workflow = base_workflow.copy()
+
+    streaming_wf = streaming.StreamProcessor(
+        base_workflow=base_workflow,
+        dynamic_keys=(DynamicA, DynamicB),
+        target_keys=(Target,),
+        accumulators=(AccumA, AccumB),
+    )
+    result = streaming_wf.add_chunk({DynamicA: sc.scalar(1), DynamicB: sc.scalar(4)})
+    assert sc.identical(result[Target], sc.scalar(2 * 1.0 / 4.0))
+    result = streaming_wf.add_chunk({DynamicA: sc.scalar(2)})  # Only A
+    assert not sc.identical(result[Target], sc.scalar(2 * 3.0 / 8.0))
+    assert sc.identical(result[Target], sc.scalar(2 * 3.0 / 4.0))
+    result = streaming_wf.add_chunk({DynamicB: sc.scalar(5)})  # Only B
+    assert sc.identical(result[Target], sc.scalar(2 * 3.0 / 9.0))
+    result = streaming_wf.add_chunk({DynamicA: sc.scalar(3), DynamicB: sc.scalar(6)})
+    assert sc.identical(result[Target], sc.scalar(2 * 6.0 / 15.0))
+
+    # Consistency check: Run the original workflow with the same inputs, all at once
+    orig_workflow[DynamicA] = sc.scalar(1 + 2 + 3)
+    orig_workflow[DynamicB] = sc.scalar(4 + 5 + 6)
+    expected = orig_workflow.compute(Target)
+    assert sc.identical(expected, result[Target])
+
+
+def test_StreamProcessor_raises_given_partial_update_for_accumulator() -> None:
+    base_workflow = sciline.Pipeline(
+        (make_accum_a, make_accum_b, make_accum_c, make_target), params={StaticA: 2.0}
+    )
+    streaming_wf = streaming.StreamProcessor(
+        base_workflow=base_workflow,
+        dynamic_keys=(DynamicA, DynamicB, DynamicC),
+        target_keys=(Target, AccumC),
+        accumulators=(Target, AccumC),  # Target depends on both A and B
+    )
+    # We can update either (A, B) and/or C...
+    result = streaming_wf.add_chunk({DynamicA: sc.scalar(1), DynamicB: sc.scalar(4)})
+    assert sc.identical(result[Target], sc.scalar(2 * 1.0 / 4.0))
+    assert result[AccumC] is None
+    result = streaming_wf.add_chunk({DynamicC: sc.scalar(11)})
+    assert sc.identical(result[Target], sc.scalar(2 * 1.0 / 4.0))
+    assert sc.identical(result[AccumC], sc.scalar(11))
+    result = streaming_wf.add_chunk({DynamicA: sc.scalar(2), DynamicB: sc.scalar(5)})
+    assert sc.identical(result[Target], sc.scalar(2 * (1.0 / 4.0 + 2.0 / 5.0)))
+    assert sc.identical(result[AccumC], sc.scalar(11))
+    result = streaming_wf.add_chunk({DynamicC: sc.scalar(12)})
+    assert sc.identical(result[Target], sc.scalar(2 * (1.0 / 4.0 + 2.0 / 5.0)))
+    assert sc.identical(result[AccumC], sc.scalar(23))
+    # ... but not just A or B
+    with pytest.raises(
+        ValueError,
+        match=r'{tests.streaming_test.DynamicB} not provided in the current chunk',
+    ):
+        result = streaming_wf.add_chunk({DynamicA: sc.scalar(2)})  # Only A
+    with pytest.raises(
+        ValueError,
+        match=r'{tests.streaming_test.DynamicA} not provided in the current chunk',
+    ):
+        result = streaming_wf.add_chunk({DynamicB: sc.scalar(5)})  # Only B
+
+
+def test_StreamProcessor_raises_when_trying_to_update_non_dynamic_key() -> None:
+    base_workflow = sciline.Pipeline(
+        (make_static_a, make_accum_a, make_accum_b, make_target)
+    )
+    streaming_wf = streaming.StreamProcessor(
+        base_workflow=base_workflow,
+        dynamic_keys=(DynamicA, DynamicB),
+        target_keys=(Target,),
+        accumulators=(AccumA, AccumB),
+    )
+
+    # Regular update ok
+    result = streaming_wf.add_chunk({DynamicA: sc.scalar(1), DynamicB: sc.scalar(4)})
+    assert sc.identical(result[Target], sc.scalar(2 * 1.0 / 4.0))
+
+    # Non-dynamic input key
+    with pytest.raises(
+        ValueError,
+        match=r'Got non-dynamic keys: {tests.streaming_test.StaticA}',
+    ):
+        result = streaming_wf.add_chunk({StaticA: sc.scalar(2)})
+    # Intermediate key depending on dynamic key
+    with pytest.raises(
+        ValueError,
+        match=r'Got non-dynamic keys: {tests.streaming_test.AccumA}',
+    ):
+        result = streaming_wf.add_chunk({AccumA: sc.scalar(2)})
+    # Target key depending on dynamic key
+    with pytest.raises(
+        ValueError,
+        match=r'Got non-dynamic keys: {tests.streaming_test.Target}',
+    ):
+        result = streaming_wf.add_chunk({Target: sc.scalar(2)})