essreduce 25.3.0__py3-none-any.whl → 25.4.0__py3-none-any.whl

ess/reduce/live/raw.py

@@ -380,7 +380,8 @@ class RollingDetectorView(Detector):
             pixel_noise = sc.scalar(0.0, unit='m')
             noise_replica_count = 0
         else:
-            noise_replica_count = 16
+            # Unclear what a good number is, could be made configurable.
+            noise_replica_count = 4
         wf = GenericNeXusWorkflow(run_types=[SampleRun], monitor_types=[])
         wf[RollingDetectorViewWindow] = window
         if projection == 'cylinder_mantle_z':
@@ -606,9 +607,14 @@ def position_with_noisy_replicas(
     noise_dim = position_noise.dim
     size = position.size * 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.sizes})
+    noise = (
+        sc.broadcast(
+            position_noise,
+            sizes={'dummy': ceil(size / position_noise.size), **position_noise.sizes},
+        )
+        .flatten(to=noise_dim)[:size]
+        .fold(dim=noise_dim, sizes={'replica': replicas, **position.sizes})
+    )
     return sc.concat([position, noise + position], dim='replica')
 
 

ess/reduce/nexus/_nexus_loader.py

@@ -85,7 +85,7 @@ def load_metadata(
     entry_name: NeXusEntryName | None = None,
     definitions: Mapping | NoNewDefinitionsType = NoNewDefinitions,
 ) -> _Model:
-    with _open_nexus_file(file_path, definitions=definitions) as f:
+    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)
 
@@ -113,7 +113,7 @@ def compute_component_position(dg: sc.DataGroup) -> sc.DataGroup:
     )
 
 
-def _open_nexus_file(
+def open_nexus_file(
     file_path: FilePath | NeXusFile | NeXusGroup,
     definitions: Mapping | None | NoNewDefinitionsType = NoNewDefinitions,
     *,
@@ -212,7 +212,7 @@ def _open_component_parent(
     """Locate the parent group of a NeXus component."""
     file_path = location.filename
     entry_name = location.entry_name
-    with _open_nexus_file(file_path, definitions=definitions) as f:
+    with open_nexus_file(file_path, definitions=definitions) as f:
         entry = _unique_child_group(f, snx.NXentry, entry_name)
         if nx_class is snx.NXsample:
             yield entry
@@ -357,7 +357,7 @@ def load_data(
     :
         Data array with events or a histogram.
     """
-    with _open_nexus_file(file_path, definitions=definitions) as f:
+    with open_nexus_file(file_path, definitions=definitions) as f:
         entry = _unique_child_group(f, snx.NXentry, entry_name)
         instrument = _unique_child_group(entry, snx.NXinstrument, None)
         component = instrument[component_name]
@@ -554,7 +554,7 @@ def _parse_monitor(group: snx.Group) -> NeXusMonitorInfo:
 
 def read_nexus_file_info(file_path: FilePath | NeXusFile | NeXusGroup) -> NeXusFileInfo:
     """Opens and inspects a NeXus file, returning a summary of its contents."""
-    with _open_nexus_file(file_path) as f:
+    with open_nexus_file(file_path) as f:
         entry = _unique_child_group(f, snx.NXentry, None)
         instrument = _unique_child_group(entry, snx.NXinstrument, None)
         detectors = {}

ess/reduce/nexus/workflow.py

@@ -62,7 +62,9 @@ def file_path_to_file_spec(
     filename: Filename[RunType], preopen: PreopenNeXusFile
 ) -> NeXusFileSpec[RunType]:
     return NeXusFileSpec[RunType](
-        snx.File(filename, definitions=definitions) if preopen else filename
+        nexus.open_nexus_file(filename, definitions=definitions)
+        if preopen
+        else filename
     )
 
 

ess/reduce/streaming.py

@@ -240,6 +240,22 @@ class StreamProcessor:
     processing based on the input keys. In particular, it is the responsibility of the
     user to ensure that the workflow is "linear" with respect to the dynamic keys up to
     the accumulation keys.
+
+    Similarly, the stream processor cannot determine from the workflow structure whether
+    context updates are compatible with the accumulated data. Accumulators are not
+    cleared automatically. This is best illustrated with an example:
+
+    - If the context is the detector rotation angle, and we accumulate I(Q) (or a
+      prerequisite of I(Q)), then updating the detector angle context is compatible with
+      previous data, assuming Q for each new chunk is computed based on the angle.
+    - If the context is the sample temperature, and we accumulate I(Q), then updating
+      the temperature context is not compatible with previous data. Accumulating I(Q, T)
+      could be compatible in this case.
+
+    Since the correctness cannot be determined from the workflow structure, we recommend
+    implementing processing steps in a way to catch such problems. For example, adding
+    the temperature as a coordinate to the I(Q) data array should allow for
+    automatically raising in the accumulator if the temperature changes.
     """
 
     def __init__(
@@ -247,6 +263,7 @@ class StreamProcessor:
         base_workflow: sciline.Pipeline,
         *,
         dynamic_keys: tuple[sciline.typing.Key, ...],
+        context_keys: tuple[sciline.typing.Key, ...] = (),
         target_keys: tuple[sciline.typing.Key, ...],
         accumulators: dict[sciline.typing.Key, Accumulator | Callable[..., Accumulator]]
         | tuple[sciline.typing.Key, ...],
@@ -260,7 +277,12 @@ class StreamProcessor:
         base_workflow:
             Workflow to be used for processing chunks.
         dynamic_keys:
-            Keys that are expected to be updated with each chunk.
+            Keys that are expected to be updated with each chunk. These keys cannot
+            depend on each other or on context_keys.
+        context_keys:
+            Keys that define context for processing chunks and may change occasionally.
+            These keys cannot overlap with dynamic_keys or depend on each other or on
+            dynamic_keys.
         target_keys:
             Keys to be computed and returned.
         accumulators:
@@ -275,21 +297,59 @@ class StreamProcessor:
             unless the values for these keys are valid for all chunks comprised in the
             final accumulators at the point where :py:meth:`finalize` is called.
         """
+        self._dynamic_keys = set(dynamic_keys)
+        self._context_keys = set(context_keys)
+
+        # Validate that dynamic and context keys do not overlap
+        overlap = self._dynamic_keys & self._context_keys
+        if overlap:
+            raise ValueError(f"Keys cannot be both dynamic and context: {overlap}")
+
+        # Check dynamic/context keys don't depend on other dynamic/context keys
+        graph = base_workflow.underlying_graph
+        special_keys = self._dynamic_keys | self._context_keys
+        for key in special_keys:
+            if key not in graph:
+                continue
+            ancestors = nx.ancestors(graph, key)
+            special_ancestors = ancestors & special_keys
+            downstream = 'Dynamic' if key in self._dynamic_keys else 'Context'
+            if special_ancestors:
+                raise ValueError(
+                    f"{downstream} key '{key}' depends on other dynamic/context keys: "
+                    f"{special_ancestors}. This is not supported."
+                )
+
         workflow = sciline.Pipeline()
         for key in target_keys:
             workflow[key] = base_workflow[key]
         for key in dynamic_keys:
             workflow[key] = None  # hack to prune branches
-
-        self._dynamic_keys = set(dynamic_keys)
+        for key in context_keys:
+            workflow[key] = None
 
         # 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)
-        parents = _find_parents(workflow, nodes) - nodes
-        for key, value in base_workflow.compute(parents).items():
+        nodes = _find_descendants(workflow, dynamic_keys + context_keys)
+        last_static = _find_parents(workflow, nodes) - nodes
+        for key, value in base_workflow.compute(last_static).items():
             workflow[key] = value
 
+        # Nodes that may need updating on context change but should be cached otherwise.
+        dynamic_nodes = _find_descendants(workflow, dynamic_keys)
+        # Nodes as far "down" in the graph as possible, right before the dynamic nodes.
+        # This also includes target keys that are not dynamic but context-dependent.
+        context_to_cache = (
+            (_find_parents(workflow, dynamic_nodes) | set(target_keys)) - dynamic_nodes
+        ) & _find_descendants(workflow, context_keys)
+        graph = workflow.underlying_graph
+        self._context_key_to_cached_context_nodes_map = {
+            context_key: ({context_key} | nx.descendants(graph, context_key))
+            & context_to_cache
+            for context_key in self._context_keys
+            if context_key in graph
+        }
+
+        self._context_workflow = workflow.copy()
         self._process_chunk_workflow = workflow.copy()
         self._finalize_workflow = workflow.copy()
         self._accumulators = (
@@ -299,7 +359,6 @@ class StreamProcessor:
         )
 
         # 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
@@ -323,6 +382,30 @@ class StreamProcessor:
         self._target_keys = target_keys
         self._allow_bypass = allow_bypass
 
+    def set_context(self, context: dict[sciline.typing.Key, Any]) -> None:
+        """
+        Set the context for processing chunks.
+
+        Parameters
+        ----------
+        context:
+            Context to be set.
+        """
+        needs_recompute = set()
+        for key in context:
+            if key not in self._context_keys:
+                raise ValueError(f"Key '{key}' is not a context key")
+            needs_recompute |= self._context_key_to_cached_context_nodes_map[key]
+        for key, value in context.items():
+            self._context_workflow[key] = value
+        results = self._context_workflow.compute(needs_recompute)
+        for key, value in results.items():
+            if key in self._target_keys:
+                # Context-dependent key is direct target, independent of dynamic nodes.
+                self._finalize_workflow[key] = value
+            else:
+                self._process_chunk_workflow[key] = value
+
     def add_chunk(
         self, chunks: dict[sciline.typing.Key, Any]
     ) -> dict[sciline.typing.Key, Any]:

ess/reduce/time_of_flight/__init__.py

@@ -6,9 +6,9 @@ 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_tof_data
 from .simulation import simulate_beamline
 from .to_events import to_events
-from .toa_to_tof import default_parameters, providers, resample_tof_data
 from .types import (
     DistanceResolution,
     LookupTableRelativeErrorThreshold,

ess/reduce/time_of_flight/{toa_to_tof.py → eto_to_tof.py}

@@ -14,6 +14,10 @@ import scipp as sc
 from scipp._scipp.core import _bins_no_validate
 from scippneutron._utils import elem_unit
 
+try:
+    from .interpolator_numba import Interpolator as InterpolatorImpl
+except ImportError:
+    from .interpolator_scipy import Interpolator as InterpolatorImpl
 from .to_events import to_events
 from .types import (
     DistanceResolution,
@@ -284,38 +288,78 @@ def compute_tof_lookup_table(
     )
 
 
-def _make_tof_interpolator(
-    lookup: sc.DataArray, distance_unit: str, time_unit: str
-) -> Callable:
-    from scipy.interpolate import RegularGridInterpolator
-
-    # TODO: to make use of multi-threading, we could write our own interpolator.
-    # This should be simple enough as we are making the bins linspace, so computing
-    # bin indices is fast.
-
-    # In the pulse dimension, it could be that for a given event_time_offset and
-    # distance, a tof value is finite in one pulse and NaN in the other.
-    # When using the bilinear interpolation, even if the value of the requested point is
-    # exactly 0 or 1 (in the case of pulse_stride=2), the interpolator will still
-    # use all 4 corners surrounding the point. This means that if one of the corners
-    # is NaN, the result will be NaN.
-    # Here, we use a trick where we duplicate the lookup values in the 'pulse' dimension
-    # so that the interpolator has values on bin edges for that dimension.
-    # The interpolator raises an error if axes coordinates are not strictly monotonic,
-    # so we cannot use e.g. [-0.5, 0.5, 0.5, 1.5] in the case of pulse_stride=2.
-    # Instead we use [-0.25, 0.25, 0.75, 1.25].
-    base_grid = np.arange(float(lookup.sizes["pulse"]))
-    return RegularGridInterpolator(
-        (
-            np.sort(np.concatenate([base_grid - 0.25, base_grid + 0.25])),
-            lookup.coords["distance"].to(unit=distance_unit, copy=False).values,
-            lookup.coords["event_time_offset"].to(unit=time_unit, copy=False).values,
-        ),
-        np.repeat(lookup.data.to(unit=time_unit, copy=False).values, 2, axis=0),
-        method="linear",
-        bounds_error=False,
-        fill_value=np.nan,
-    )
+class TofInterpolator:
+    def __init__(self, lookup: sc.DataArray, distance_unit: str, time_unit: str):
+        self._distance_unit = distance_unit
+        self._time_unit = time_unit
+
+        # In the pulse dimension, it could be that for a given event_time_offset and
+        # distance, a tof value is finite in one pulse and NaN in the other.
+        # When using the bilinear interpolation, even if the value of the requested
+        # point is exactly 0 or 1 (in the case of pulse_stride=2), the interpolator
+        # will still use all 4 corners surrounding the point. This means that if one of
+        # the corners is NaN, the result will be NaN.
+        # Here, we use a trick where we duplicate the lookup values in the 'pulse'
+        # dimension so that the interpolator has values on bin edges for that dimension.
+        # The interpolator raises an error if axes coordinates are not strictly
+        # monotonic, so we cannot use e.g. [-0.5, 0.5, 0.5, 1.5] in the case of
+        # pulse_stride=2. Instead we use [-0.25, 0.25, 0.75, 1.25].
+        base_grid = np.arange(float(lookup.sizes["pulse"]))
+        self._pulse_edges = np.sort(
+            np.concatenate([base_grid - 0.25, base_grid + 0.25])
+        )
+
+        self._time_edges = (
+            lookup.coords["event_time_offset"]
+            .to(unit=self._time_unit, copy=False)
+            .values
+        )
+        self._distance_edges = (
+            lookup.coords["distance"].to(unit=distance_unit, copy=False).values
+        )
+
+        self._interpolator = InterpolatorImpl(
+            time_edges=self._time_edges,
+            distance_edges=self._distance_edges,
+            pulse_edges=self._pulse_edges,
+            values=np.repeat(
+                lookup.data.to(unit=self._time_unit, copy=False).values, 2, axis=0
+            ),
+        )
+
+    def __call__(
+        self,
+        pulse_index: sc.Variable,
+        ltotal: sc.Variable,
+        event_time_offset: sc.Variable,
+    ) -> sc.Variable:
+        if pulse_index.unit not in ("", None):
+            raise sc.UnitError(
+                "pulse_index must have unit dimensionless or None, "
+                f"but got unit: {pulse_index.unit}."
+            )
+        if ltotal.unit != self._distance_unit:
+            raise sc.UnitError(
+                f"ltotal must have unit: {self._distance_unit}, "
+                f"but got unit: {ltotal.unit}."
+            )
+        if event_time_offset.unit != self._time_unit:
+            raise sc.UnitError(
+                f"event_time_offset must have unit: {self._time_unit}, "
+                f"but got unit: {event_time_offset.unit}."
+            )
+        out_dims = event_time_offset.dims
+        pulse_index = pulse_index.values
+        ltotal = ltotal.values
+        event_time_offset = event_time_offset.values
+
+        return sc.array(
+            dims=out_dims,
+            values=self._interpolator(
+                times=event_time_offset, distances=ltotal, pulse_indices=pulse_index
+            ),
+            unit=self._time_unit,
+        )
 
 
 def _time_of_flight_data_histogram(
@@ -327,7 +371,8 @@ def _time_of_flight_data_histogram(
     # In NeXus, 'time_of_flight' is the canonical name in NXmonitor, but in some files,
     # it may be called 'tof'.
     key = next(iter(set(da.coords.keys()) & {"time_of_flight", "tof"}))
-    eto_unit = da.coords[key].unit
+    raw_eto = da.coords[key].to(dtype=float, copy=False)
+    eto_unit = raw_eto.unit
     pulse_period = pulse_period.to(unit=eto_unit)
 
     # In histogram mode, because there is a wrap around at the end of the pulse, we
@@ -335,9 +380,7 @@ def _time_of_flight_data_histogram(
     # with one finite left edge and a NaN right edge (it becomes NaN as it would be
     # outside the range of the lookup table).
     new_bins = sc.sort(
-        sc.concat(
-            [da.coords[key], sc.scalar(0.0, unit=eto_unit), pulse_period], dim=key
-        ),
+        sc.concat([raw_eto, sc.scalar(0.0, unit=eto_unit), pulse_period], dim=key),
         key=key,
     )
     rebinned = da.rebin({key: new_bins})
@@ -360,16 +403,14 @@ def _time_of_flight_data_histogram(
     )
     pulse_index = sc.zeros(sizes=etos.sizes)
 
-    # Create 2D interpolator
-    interp = _make_tof_interpolator(
-        lookup, distance_unit=ltotal.unit, time_unit=eto_unit
-    )
+    # Create linear interpolator
+    interp = TofInterpolator(lookup, distance_unit=ltotal.unit, time_unit=eto_unit)
 
     # Compute time-of-flight of the bin edges using the interpolator
-    tofs = sc.array(
-        dims=etos.dims,
-        values=interp((pulse_index.values, ltotal.values, etos.values)),
-        unit=eto_unit,
+    tofs = interp(
+        pulse_index=pulse_index,
+        ltotal=ltotal.broadcast(sizes=etos.sizes),
+        event_time_offset=etos,
     )
 
     return rebinned.assign_coords(tof=tofs)
@@ -380,7 +421,7 @@ def _guess_pulse_stride_offset(
     ltotal: sc.Variable,
     event_time_offset: sc.Variable,
     pulse_stride: int,
-    interp: Callable,
+    interp: TofInterpolator,
 ) -> int:
     """
     Using the minimum ``event_time_zero`` to calculate a reference time when computing
@@ -408,21 +449,29 @@ def _guess_pulse_stride_offset(
     pulse_stride:
         Stride of used pulses.
     interp:
-        2D interpolator for the lookup table.
+        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]
+    pulse_index = sc.array(
+        dims=pulse_index.dims,
+        values=pulse_index.values[inds],
+        unit=pulse_index.unit,
+    )
+    ltotal = sc.array(dims=ltotal.dims, values=ltotal.values[inds], unit=ltotal.unit)
+    etos = sc.array(
+        dims=event_time_offset.dims,
+        values=event_time_offset.values[inds],
+        unit=event_time_offset.unit,
+    )
     for i in range(pulse_stride):
-        pulse_inds = (pulse_index_values + i) % pulse_stride
-        tofs[i] = interp((pulse_inds, ltotal_values, etos_values))
+        pulse_inds = (pulse_index + i) % pulse_stride
+        tofs[i] = interp(pulse_index=pulse_inds, ltotal=ltotal, event_time_offset=etos)
     # 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]
+    return sorted(tofs, key=lambda x: sc.isnan(tofs[x]).sum())[0]
 
 
 def _time_of_flight_data_events(
@@ -433,13 +482,11 @@ def _time_of_flight_data_events(
     pulse_stride: int,
     pulse_stride_offset: int,
 ) -> sc.DataArray:
-    etos = da.bins.coords["event_time_offset"]
+    etos = da.bins.coords["event_time_offset"].to(dtype=float, copy=False)
     eto_unit = elem_unit(etos)
 
-    # Create 2D interpolator
-    interp = _make_tof_interpolator(
-        lookup, distance_unit=ltotal.unit, time_unit=eto_unit
-    )
+    # Create linear interpolator
+    interp = TofInterpolator(lookup, distance_unit=ltotal.unit, time_unit=eto_unit)
 
     # Operate on events (broadcast distances to all events)
     ltotal = sc.bins_like(etos, ltotal).bins.constituents["data"]
@@ -491,11 +538,7 @@ def _time_of_flight_data_events(
         pulse_index %= pulse_stride
 
     # Compute time-of-flight for all neutrons using the interpolator
-    tofs = sc.array(
-        dims=etos.dims,
-        values=interp((pulse_index.values, ltotal.values, etos.values)),
-        unit=eto_unit,
-    )
+    tofs = interp(pulse_index=pulse_index, ltotal=ltotal, event_time_offset=etos)
 
     parts = da.bins.constituents
     parts["data"] = tofs
@@ -573,17 +616,21 @@ def resample_tof_data(da: TofData) -> ResampledTofData:
         Histogrammed data with the time-of-flight coordinate.
     """
     dim = next(iter(set(da.dims) & {"time_of_flight", "tof"}))
-    events = to_events(da.rename_dims({dim: "tof"}), "event")
+    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)
-    for key, var in da.coords.items():
-        if dim not in var.dims:
-            rehist.coords[key] = var
-    return ResampledTofData(rehist)
+    return ResampledTofData(
+        rehist.assign_coords(
+            {key: var for key, var in da.coords.items() if dim not in var.dims}
+        )
+    )
 
 
 def default_parameters() -> dict:

ess/reduce/time_of_flight/fakes.py

@@ -23,6 +23,7 @@ class FakeBeamline:
         events_per_pulse: int = 200000,
         seed: int | None = None,
         source: Callable | None = None,
+        source_position: sc.Variable | None = None,
     ):
         import math
 
@@ -32,6 +33,8 @@ class FakeBeamline:
         self.frequency = pulse.frequency
         self.npulses = math.ceil((run_length * self.frequency).to(unit="").value)
         self.events_per_pulse = events_per_pulse
+        if source_position is None:
+            source_position = sc.vector([0, 0, 0], unit='m')
 
         # Create a source
         if source is None:
@@ -54,7 +57,7 @@ class FakeBeamline:
                 open=ch.slit_begin,
                 close=ch.slit_end,
                 phase=abs(ch.phase),
-                distance=ch.axle_position.fields.z,
+                distance=sc.norm(ch.axle_position - source_position),
                 name=name,
             )
             for name, ch in choppers.items()
@@ -117,3 +120,7 @@ def pulse_skipping_choppers():
             radius=sc.scalar(30.0, unit="cm"),
         ),
     }
+
+
+def source_position():
+    return sc.vector([0, 0, 0], unit='m')

ess/reduce/time_of_flight/interpolator_numba.py

@@ -0,0 +1,162 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright (c) 2025 Scipp contributors (https://github.com/scipp)
+import numpy as np
+from numba import njit, prange
+
+
+@njit(boundscheck=False, cache=True, fastmath=False, parallel=True)
+def interpolate(
+    x: np.ndarray,
+    y: np.ndarray,
+    z: np.ndarray,
+    values: np.ndarray,
+    xp: np.ndarray,
+    yp: np.ndarray,
+    zp: np.ndarray,
+    fill_value: float,
+    out: np.ndarray,
+):
+    """
+    Linear interpolation of data on a 3D regular grid.
+
+    Parameters
+    ----------
+    x:
+        1D array of grid edges along the x-axis. They must be linspaced.
+    y:
+        1D array of grid edges along the y-axis. They must be linspaced.
+    z:
+        1D array of grid edges along the z-axis. They must be linspaced.
+    values:
+        3D array of values on the grid. The shape must be (nz, ny, nx).
+    xp:
+        1D array of x-coordinates where to interpolate (size N).
+    yp:
+        1D array of y-coordinates where to interpolate (size N).
+    zp:
+        1D array of z-coordinates where to interpolate (size N).
+    fill_value:
+        Value to use for points outside of the grid.
+    out:
+        1D array where the interpolated values will be stored (size N).
+    """
+    if not (len(xp) == len(yp) == len(zp) == len(out)):
+        raise ValueError("Interpolator: all input arrays must have the same size.")
+
+    npoints = len(xp)
+    xmin = x[0]
+    xmax = x[-1]
+    ymin = y[0]
+    ymax = y[-1]
+    zmin = z[0]
+    zmax = z[-1]
+    dx = x[1] - xmin
+    dy = y[1] - ymin
+    dz = z[1] - zmin
+
+    one_over_dx = 1.0 / dx
+    one_over_dy = 1.0 / dy
+    one_over_dz = 1.0 / dz
+    norm = one_over_dx * one_over_dy * one_over_dz
+
+    for i in prange(npoints):
+        xx = xp[i]
+        yy = yp[i]
+        zz = zp[i]
+
+        if (
+            (xx < xmin)
+            or (xx > xmax)
+            or (yy < ymin)
+            or (yy > ymax)
+            or (zz < zmin)
+            or (zz > zmax)
+        ):
+            out[i] = fill_value
+
+        else:
+            ix = int((xx - xmin) * one_over_dx)
+            iy = int((yy - ymin) * one_over_dy)
+            iz = int((zz - zmin) * one_over_dz)
+
+            y2 = y[iy + 1]
+            y1 = y[iy]
+            x2 = x[ix + 1]
+            x1 = x[ix]
+            z1 = z[iz]
+            z2 = z[iz + 1]
+
+            a111 = values[iz, iy, ix]
+            a211 = values[iz, iy, ix + 1]
+            a121 = values[iz, iy + 1, ix]
+            a221 = values[iz, iy + 1, ix + 1]
+            a112 = values[iz + 1, iy, ix]
+            a212 = values[iz + 1, iy, ix + 1]
+            a122 = values[iz + 1, iy + 1, ix]
+            a222 = values[iz + 1, iy + 1, ix + 1]
+
+            x2mxx = x2 - xx
+            xxmx1 = xx - x1
+            y2myy = y2 - yy
+            yymy1 = yy - y1
+            out[i] = (
+                (z2 - zz)
+                * (
+                    y2myy * (x2mxx * a111 + xxmx1 * a211)
+                    + yymy1 * (x2mxx * a121 + xxmx1 * a221)
+                )
+                + (zz - z1)
+                * (
+                    y2myy * (x2mxx * a112 + xxmx1 * a212)
+                    + yymy1 * (x2mxx * a122 + xxmx1 * a222)
+                )
+            ) * norm
+
+
+class Interpolator:
+    def __init__(
+        self,
+        time_edges: np.ndarray,
+        distance_edges: np.ndarray,
+        pulse_edges: np.ndarray,
+        values: np.ndarray,
+        fill_value: float = np.nan,
+    ):
+        """
+        Interpolator for 3D regular grid data (Numba implementation).
+
+        Parameters
+        ----------
+        time_edges:
+            1D array of time edges.
+        distance_edges:
+            1D array of distance edges.
+        pulse_edges:
+            1D array of pulse edges.
+        values:
+            3D array of values on the grid. The shape must be (nz, ny, nx).
+        fill_value:
+            Value to use for points outside of the grid.
+        """
+        self.time_edges = time_edges
+        self.distance_edges = distance_edges
+        self.pulse_edges = pulse_edges
+        self.values = values
+        self.fill_value = fill_value
+
+    def __call__(
+        self, times: np.ndarray, distances: np.ndarray, pulse_indices: np.ndarray
+    ) -> np.ndarray:
+        out = np.empty_like(times)
+        interpolate(
+            x=self.time_edges,
+            y=self.distance_edges,
+            z=self.pulse_edges,
+            values=self.values,
+            xp=times,
+            yp=distances,
+            zp=pulse_indices,
+            fill_value=self.fill_value,
+            out=out,
+        )
+        return out

ess/reduce/time_of_flight/interpolator_scipy.py

@@ -0,0 +1,60 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright (c) 2025 Scipp contributors (https://github.com/scipp)
+
+import numpy as np
+
+
+class Interpolator:
+    def __init__(
+        self,
+        time_edges: np.ndarray,
+        distance_edges: np.ndarray,
+        pulse_edges: np.ndarray,
+        values: np.ndarray,
+        method: str = "linear",
+        bounds_error: bool = False,
+        fill_value: float = np.nan,
+        **kwargs,
+    ):
+        """
+        Interpolator for 3D regular grid data (SciPy implementation).
+
+        Parameters
+        ----------
+        time_edges:
+            1D array of time edges.
+        distance_edges:
+            1D array of distance edges.
+        pulse_edges:
+            1D array of pulse edges.
+        values:
+            3D array of values on the grid. The shape must be (nz, ny, nx).
+        method:
+            Method of interpolation. Default is "linear".
+        bounds_error:
+            If True, when interpolated values are requested outside of the domain,
+            a ValueError is raised. If False, fill_value is used.
+        fill_value:
+            Value to use for points outside of the grid.
+        kwargs:
+            Additional arguments to pass to scipy.interpolate.RegularGridInterpolator.
+        """
+        from scipy.interpolate import RegularGridInterpolator
+
+        self._interp = RegularGridInterpolator(
+            (
+                pulse_edges,
+                distance_edges,
+                time_edges,
+            ),
+            values,
+            method=method,
+            bounds_error=bounds_error,
+            fill_value=fill_value,
+            **kwargs,
+        )
+
+    def __call__(
+        self, times: np.ndarray, distances: np.ndarray, pulse_indices: np.ndarray
+    ) -> np.ndarray:
+        return self._interp((pulse_indices, distances, times))

ess/reduce/time_of_flight/simulation.py

@@ -9,7 +9,9 @@ from .types import SimulationResults
 
 
 def simulate_beamline(
+    *,
     choppers: Mapping[str, DiskChopper],
+    source_position: sc.Variable,
     neutrons: int = 1_000_000,
     pulses: int = 1,
     seed: int | None = None,
@@ -25,6 +27,9 @@ def simulate_beamline(
         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
         for more information.
+    source_position:
+        A scalar variable with ``dtype=vector3`` that defines the source position.
+        Must be in the same coordinate system as the choppers' axle positions.
     neutrons:
         Number of neutrons to simulate.
     pulses:
@@ -45,7 +50,9 @@ def simulate_beamline(
             open=ch.slit_begin,
             close=ch.slit_end,
             phase=abs(ch.phase),
-            distance=ch.axle_position.fields.z,
+            distance=sc.norm(
+                ch.axle_position - source_position.to(unit=ch.axle_position.unit)
+            ),
             name=name,
         )
         for name, ch in choppers.items()
@@ -54,7 +61,7 @@ def simulate_beamline(
     if not tof_choppers:
         events = source.data.squeeze().flatten(to='event')
         return SimulationResults(
-            time_of_arrival=events.coords["time"],
+            time_of_arrival=events.coords["birth_time"],
             speed=events.coords["speed"],
             wavelength=events.coords["wavelength"],
             weight=events.data,

ess/reduce/time_of_flight/to_events.py

@@ -34,7 +34,7 @@ def to_events(
     rng = np.random.default_rng()
     event_coords = {}
     edge_dims = []
-    midp_dims = set()
+    midp_dims = set(da.dims)
     midp_coord_names = []
     # Separate bin-edge and midpoints coords
     for name in da.coords:
@@ -43,9 +43,9 @@ def to_events(
         if is_edges:
             if name in dims:
                 edge_dims.append(name)
+                midp_dims -= {name}
         else:
             midp_coord_names.append(name)
-            midp_dims.update(set(dims))
 
     edge_sizes = {dim: da.sizes[da.coords[dim].dim] for dim in edge_dims}
     for dim in edge_dims:

{essreduce-25.3.0.dist-info → essreduce-25.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: essreduce
-Version: 25.3.0
+Version: 25.4.0
 Summary: Common data reduction tools for the ESS facility
 Author: Scipp contributors
 License: BSD 3-Clause License
@@ -57,10 +57,12 @@ Requires-Dist: scippneutron>=25.02.0
 Requires-Dist: scippnexus>=24.11.0
 Provides-Extra: test
 Requires-Dist: ipywidgets; extra == "test"
+Requires-Dist: numba; extra == "test"
 Requires-Dist: pooch; extra == "test"
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: scipy>=1.7.0; extra == "test"
 Requires-Dist: tof>=25.01.2; extra == "test"
+Dynamic: license-file
 
 [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg)](CODE_OF_CONDUCT.md)
 [![PyPI badge](http://img.shields.io/pypi/v/essreduce.svg)](https://pypi.python.org/pypi/essreduce)

{essreduce-25.3.0.dist-info → essreduce-25.4.0.dist-info}/RECORD

@@ -3,26 +3,28 @@ 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=_zFaT9vZQ4HZ1g9qbCQxetenITdqGZMPhyNNffMpGKw,13244
+ess/reduce/streaming.py,sha256=TBttQV5WdSpUKh38J0pdv53seMWtUFswxd6-ltaZb_M,17403
 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=hyWkDJ0WYE2TS12dVxpRUh6RkzcUJL0bVDd4JjTidi0,24217
+ess/reduce/live/raw.py,sha256=66qV0G2rP8gK5tXuk-syTlDLE2jT3ehfmSnET7Xzfd0,24392
 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=NpBTBjWLKSnW0B1EarFdt2QxV0X7QBQLk2dSJq2ZuOw,19847
+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=15XcHbNbOfnAYjWXzzKyYDVNyNixRnP0hJ-Q2duwMWE,9896
-ess/reduce/nexus/workflow.py,sha256=ABVc9E1Qcos0wLcDE8bGDAOz3aPpHrj4TJyfHsQbx7I,24297
+ess/reduce/nexus/workflow.py,sha256=EiD6-58eGwoN5fbo47UTZy_oYFitCbwlIH-xqDOSp4c,24326
 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=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=bt28z6wixS4AegBxsl1uYBREP08TyAs8Y9Z738YcXE4,23476
+ess/reduce/time_of_flight/__init__.py,sha256=TSHfyoROwFhM2k3jHzamw3zeb0OQOaiuvgCgDEPEQ_g,1097
+ess/reduce/time_of_flight/eto_to_tof.py,sha256=Nq2gx7aejoZ_ExLTr9I6KZMqDxCKAx1PpGHslpNXkKU,25271
+ess/reduce/time_of_flight/fakes.py,sha256=REyHkJsSSq2_l5UOtpsv2aKkhCuro_i3KpVsxxITbW0,4470
+ess/reduce/time_of_flight/interpolator_numba.py,sha256=4fZLs5Q4UxXKJREYxRAV5qUWB_uR2PscvMP0vno1A-A,4544
+ess/reduce/time_of_flight/interpolator_scipy.py,sha256=sRJj2ncBiUMv6g9h-MJzI9xyY0Ir0degpAv6FIeSMBw,1834
+ess/reduce/time_of_flight/simulation.py,sha256=cIF_nWkLQlcWUCW2_wvWBU2ocg_8CSfOnfkoqdLdUgs,2923
+ess/reduce/time_of_flight/to_events.py,sha256=w9mHpnWd3vwN2ouob-GK_1NPrTjCaOzPuC2QuEey-m0,4342
 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
@@ -36,9 +38,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.3.0.dist-info/LICENSE,sha256=nVEiume4Qj6jMYfSRjHTM2jtJ4FGu0g-5Sdh7osfEYw,1553
-essreduce-25.3.0.dist-info/METADATA,sha256=bqJ7k-jVd1zBWfYhS4mS_LFj9Ogol9Xfvrvmw4EGPjM,3708
-essreduce-25.3.0.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-essreduce-25.3.0.dist-info/entry_points.txt,sha256=PMZOIYzCifHMTe4pK3HbhxUwxjFaZizYlLD0td4Isb0,66
-essreduce-25.3.0.dist-info/top_level.txt,sha256=0JxTCgMKPLKtp14wb1-RKisQPQWX7i96innZNvHBr-s,4
-essreduce-25.3.0.dist-info/RECORD,,
+essreduce-25.4.0.dist-info/licenses/LICENSE,sha256=nVEiume4Qj6jMYfSRjHTM2jtJ4FGu0g-5Sdh7osfEYw,1553
+essreduce-25.4.0.dist-info/METADATA,sha256=jVwDtqDA6slsUJQYBDTy_teK7EbLjGCfhqoa4YSf1Ac,3768
+essreduce-25.4.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+essreduce-25.4.0.dist-info/entry_points.txt,sha256=PMZOIYzCifHMTe4pK3HbhxUwxjFaZizYlLD0td4Isb0,66
+essreduce-25.4.0.dist-info/top_level.txt,sha256=0JxTCgMKPLKtp14wb1-RKisQPQWX7i96innZNvHBr-s,4
+essreduce-25.4.0.dist-info/RECORD,,

{essreduce-25.3.0.dist-info → essreduce-25.4.0.dist-info}/WHEEL

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