essreduce 24.11.3__py3-none-any.whl → 25.1.0__py3-none-any.whl

ess/reduce/__init__.py

@@ -4,7 +4,7 @@
 
 import importlib.metadata
 
-from . import nexus, uncertainty
+from . import nexus, uncertainty, time_of_flight
 
 try:
     __version__ = importlib.metadata.version("essreduce")
@@ -13,4 +13,4 @@ except importlib.metadata.PackageNotFoundError:
 
 del importlib
 
-__all__ = ['nexus', 'uncertainty']
+__all__ = ["nexus", "uncertainty", "time_of_flight"]

ess/reduce/live/raw.py

@@ -111,6 +111,19 @@ class LogicalView:
     Logical view of a multi-dimensional detector.
 
     Instances can be used as a "projection" function for a detector view.
+
+    Parameters
+    ----------
+    fold:
+        Dimensions to fold. This is useful is the raw data has a single dimension that
+        corresponds to multiple dimensions in the logical view.
+    transpose:
+        Dimensions to transpose. This is useful for reordering dimensions.
+    select:
+        Dimensions with associated index to select from the data. This extracts a slice
+        of the data for each given dimension.
+    flatten:
+        Dimensions to flatten.
     """
 
     fold: dict[str, int] | None = None
@@ -281,11 +294,13 @@ class RollingDetectorView(Detector):
             noise_replica_count = 0
         else:
             noise_replica_count = 4
-        wf = GenericNeXusWorkflow()
+        wf = GenericNeXusWorkflow(run_types=[SampleRun], monitor_types=[])
         wf[RollingDetectorViewWindow] = window
         if isinstance(projection, LogicalView):
             wf[LogicalView] = projection
-            wf[NeXusTransformation[snx.NXdetector, SampleRun]] = sc.scalar(1)
+            wf[NeXusTransformation[snx.NXdetector, SampleRun]] = NeXusTransformation[
+                snx.NXdetector, SampleRun
+            ](sc.scalar(1))
             wf.insert(RollingDetectorView.from_detector_and_logical_view)
         elif projection == 'cylinder_mantle_z':
             wf.insert(make_cylinder_mantle_coords)

ess/reduce/nexus/_nexus_loader.py

@@ -3,6 +3,7 @@
 
 """NeXus loaders."""
 
+import errno
 from collections.abc import Generator, Mapping
 from contextlib import AbstractContextManager, contextmanager, nullcontext
 from dataclasses import dataclass
@@ -91,6 +92,8 @@ def compute_component_position(dg: sc.DataGroup) -> sc.DataGroup:
 def _open_nexus_file(
     file_path: FilePath | NeXusFile | NeXusGroup,
     definitions: Mapping | None | NoNewDefinitionsType = NoNewDefinitions,
+    *,
+    locking: bool | None = None,
 ) -> AbstractContextManager[snx.Group]:
     if isinstance(file_path, getattr(NeXusGroup, '__supertype__', type(None))):
         if (
@@ -101,9 +104,42 @@ def _open_nexus_file(
                 "Cannot apply new definitions to open nexus file or nexus group."
             )
         return nullcontext(file_path)
+
+    try:
+        return _open_nexus_file_from_path(file_path, definitions, locking=locking)
+    except OSError as err:
+        if err.errno == errno.EROFS:
+            # Failed to open because the filesystem is read-only.
+            # (According to https://www.ioplex.com/%7Emiallen/errcmpp.html
+            # this error code is universal.)
+            #
+            # On ESS machines, this happens for network filesystems of data that was
+            # ingested into SciCat, including raw data.
+            # In this case, it is safe to open the file without locking because:
+            # - For raw files, they were written on a separate machine and are synced
+            #   with the one running reduction software. So there cannot be concurrent
+            #   write and read accesses to the same file on the same filesystem.
+            #   The ground truth on the filesystem used by the file writer is protected
+            #   and cannot be corrupted by our reader.
+            # - For processed data, the file was copied to the read-only filesystem.
+            #   So the copy we are opening was not written by HDF5 directly and thus
+            #   locking has no effect anyway.
+            #
+            # When running on user machines, disabling locking can potentially corrupt
+            # files. But the risk is minimal because very few users will have read-only
+            # filesystems and do concurrent reads and writes.
+            return _open_nexus_file_from_path(file_path, definitions, locking=False)
+        raise
+
+
+def _open_nexus_file_from_path(
+    file_path: FilePath,
+    definitions: Mapping | None | NoNewDefinitionsType,
+    **kwargs: object,
+) -> AbstractContextManager[snx.Group]:
     if definitions is NoNewDefinitions:
-        return snx.File(file_path)
-    return snx.File(file_path, definitions=definitions)
+        return snx.File(file_path, **kwargs)
+    return snx.File(file_path, definitions=definitions, **kwargs)
 
 
 @contextmanager

ess/reduce/nexus/types.py

@@ -78,7 +78,17 @@ RunType = TypeVar(
     TransmissionRun[BackgroundRun],
     VanadiumRun,
 )
-"""TypeVar used for specifying BackgroundRun, EmptyBeamRun or SampleRun"""
+"""TypeVar for specifying what run some data belongs to.
+
+Possible values:
+
+- :class:`BackgroundRun`
+- :class:`EmptyBeamRun`
+- :class:`SampleRun`
+- :class:`TransmissionRun`
+- :class:`VanadiumRun`
+"""
+
 
 # 1.2  Monitor types
 Monitor1 = NewType('Monitor1', int)
@@ -97,6 +107,16 @@ IncidentMonitor = NewType('IncidentMonitor', int)
 """Incident monitor"""
 TransmissionMonitor = NewType('TransmissionMonitor', int)
 """Transmission monitor"""
+FrameMonitor0 = NewType('FrameMonitor', int)
+"""Frame monitor number 0"""
+FrameMonitor1 = NewType('FrameMonitor', int)
+"""Frame monitor number 1"""
+FrameMonitor2 = NewType('FrameMonitor', int)
+"""Frame monitor number 2"""
+FrameMonitor3 = NewType('FrameMonitor', int)
+"""Frame monitor number 3"""
+CaveMonitor = NewType('CaveMonitor', int)
+"""A monitor located in the instrument cave"""
 MonitorType = TypeVar(
     'MonitorType',
     Monitor1,
@@ -107,8 +127,31 @@ MonitorType = TypeVar(
     Monitor6,
     IncidentMonitor,
     TransmissionMonitor,
+    FrameMonitor0,
+    FrameMonitor1,
+    FrameMonitor2,
+    FrameMonitor3,
+    CaveMonitor,
 )
-"""TypeVar used for specifying the monitor type such as Incident or Transmission"""
+"""TypeVar for specifying what monitor some data belongs to.
+
+Possible values:
+
+- :class:`Monitor1`
+- :class:`Monitor2`
+- :class:`Monitor3`
+- :class:`Monitor4`
+- :class:`Monitor5`
+- :class:`Monitor6`
+- :class:`IncidentMonitor`
+- :class:`TransmissionMonitor`
+- :class:`FrameMonitor0`
+- :class:`FrameMonitor1`
+- :class:`FrameMonitor2`
+- :class:`FrameMonitor3`
+- :class:`CaveMonitor`
+"""
+
 
 Component = TypeVar(
     'Component',
@@ -125,6 +168,11 @@ Component = TypeVar(
     Monitor6,
     IncidentMonitor,
     TransmissionMonitor,
+    FrameMonitor0,
+    FrameMonitor1,
+    FrameMonitor2,
+    FrameMonitor3,
+    CaveMonitor,
 )
 UniqueComponent = TypeVar('UniqueComponent', snx.NXsample, snx.NXsource)
 """Components that can be identified by their type as there will only be one."""

ess/reduce/nexus/workflow.py

@@ -3,12 +3,12 @@
 
 """Workflow and workflow components for interacting with NeXus files."""
 
-from collections.abc import Sequence
+from collections.abc import Iterable
 from copy import deepcopy
 from typing import Any
 
-import networkx as nx
 import sciline
+import sciline.typing
 import scipp as sc
 import scippnexus as snx
 from scipp.constants import g
@@ -649,30 +649,39 @@ def LoadDetectorWorkflow() -> sciline.Pipeline:
 
 def GenericNeXusWorkflow(
     *,
-    run_types: Sequence[sciline.typing.Key] | None = None,
-    monitor_types: Sequence[sciline.typing.Key] | None = None,
+    run_types: Iterable[sciline.typing.Key] | None = None,
+    monitor_types: Iterable[sciline.typing.Key] | None = None,
 ) -> sciline.Pipeline:
     """
     Generic workflow for loading detector and monitor data from a NeXus file.
 
+    It is possible to limit which run types and monitor types
+    are supported by the returned workflow.
+    This is useful to reduce the size of the workflow and make it easier to inspect.
+    Make sure to add *all* required run types and monitor types when using this feature.
+
+    Attention
+    ---------
+    Filtering by run type and monitor type does not work with nested type vars.
+    E.g., if you have a type like ``Outer[Inner[RunType]]``, this type and its
+    provider will be removed.
+
     Parameters
     ----------
     run_types:
         List of run types to include in the workflow. If not provided, all run types
-        are included. It is recommended to specify run types to avoid creating very
-        large workflows.
+        are included.
+        Must be a possible value of :class:`ess.reduce.nexus.types.RunType`.
     monitor_types:
         List of monitor types to include in the workflow. If not provided, all monitor
-        types are included. It is recommended to specify monitor types to avoid creating
-        very large workflows.
+        types are included.
+        Must be a possible value of :class:`ess.reduce.nexus.types.MonitorType`.
 
     Returns
     -------
     :
         The workflow.
     """
-    if monitor_types is not None and run_types is None:
-        raise ValueError("run_types must be specified if monitor_types is specified")
     wf = sciline.Pipeline(
         (
             *_common_providers,
@@ -685,16 +694,34 @@ def GenericNeXusWorkflow(
     wf[DetectorBankSizes] = DetectorBankSizes({})
     wf[PreopenNeXusFile] = PreopenNeXusFile(False)
 
-    g = wf.underlying_graph
-    ancestors = set()
-    # DetectorData and MonitorData are the "final" outputs, so finding and removing all
-    # their ancestors is what we need to strip unused run and monitor types.
-    for rt in run_types or ():
-        ancestors |= nx.ancestors(g, DetectorData[rt])
-        ancestors.add(DetectorData[rt])
-        for mt in monitor_types or ():
-            ancestors |= nx.ancestors(g, MonitorData[rt, mt])
-            ancestors.add(MonitorData[rt, mt])
-    if run_types is not None:
-        g.remove_nodes_from(set(g.nodes) - ancestors)
+    if run_types is not None or monitor_types is not None:
+        _prune_type_vars(wf, run_types=run_types, monitor_types=monitor_types)
+
     return wf
+
+
+def _prune_type_vars(
+    workflow: sciline.Pipeline,
+    *,
+    run_types: Iterable[sciline.typing.Key] | None,
+    monitor_types: Iterable[sciline.typing.Key] | None,
+) -> None:
+    # Remove all nodes that use a run type or monitor types that is
+    # not listed in the function arguments.
+    excluded_run_types = _excluded_type_args(RunType, run_types)
+    excluded_monitor_types = _excluded_type_args(MonitorType, monitor_types)
+    excluded_types = excluded_run_types | excluded_monitor_types
+
+    graph = workflow.underlying_graph
+    to_remove = [
+        node for node in graph if excluded_types & set(getattr(node, "__args__", set()))
+    ]
+    graph.remove_nodes_from(to_remove)
+
+
+def _excluded_type_args(
+    type_var: Any, keep: Iterable[sciline.typing.Key] | None
+) -> set[sciline.typing.Key]:
+    if keep is None:
+        return set()
+    return set(type_var.__constraints__) - set(keep)

ess/reduce/parameter.py

@@ -71,7 +71,12 @@ class ParamWithOptions(Parameter[T]):
 
     @classmethod
     def from_enum(cls: type[C], t: type[T], default: T) -> C:
-        return cls(name=str(t), description=t.__doc__, options=t, default=default)
+        return cls(
+            name=t.__name__,
+            description=t.__doc__,
+            options=t.__members__,
+            default=default,
+        )
 
 
 @dataclass

ess/reduce/time_of_flight/__init__.py

@@ -0,0 +1,59 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright (c) 2023 Scipp contributors (https://github.com/scipp)
+
+"""
+Utilities for computing real neutron time-of-flight from chopper settings and
+neutron time-of-arrival at the detectors.
+"""
+
+from .toa_to_tof import default_parameters, resample_tof_data, providers, TofWorkflow
+from .simulation import simulate_beamline
+from .types import (
+    DistanceResolution,
+    FrameFoldedTimeOfArrival,
+    FramePeriod,
+    LookupTableRelativeErrorThreshold,
+    Ltotal,
+    LtotalRange,
+    MaskedTimeOfFlightLookupTable,
+    PivotTimeAtDetector,
+    PulsePeriod,
+    PulseStride,
+    PulseStrideOffset,
+    RawData,
+    ResampledTofData,
+    SimulationResults,
+    TimeOfArrivalMinusPivotTimeModuloPeriod,
+    TimeOfFlightLookupTable,
+    TofData,
+    UnwrappedTimeOfArrival,
+    UnwrappedTimeOfArrivalMinusPivotTime,
+)
+
+
+__all__ = [
+    "DistanceResolution",
+    "FrameFoldedTimeOfArrival",
+    "FramePeriod",
+    "LookupTableRelativeErrorThreshold",
+    "Ltotal",
+    "LtotalRange",
+    "MaskedTimeOfFlightLookupTable",
+    "PivotTimeAtDetector",
+    "PulsePeriod",
+    "PulseStride",
+    "PulseStrideOffset",
+    "RawData",
+    "ResampledTofData",
+    "SimulationResults",
+    "TimeOfArrivalMinusPivotTimeModuloPeriod",
+    "TimeOfFlightLookupTable",
+    "TofData",
+    "TofWorkflow",
+    "UnwrappedTimeOfArrival",
+    "UnwrappedTimeOfArrivalMinusPivotTime",
+    "default_parameters",
+    "providers",
+    "resample_tof_data",
+    "simulate_beamline",
+]

ess/reduce/time_of_flight/fakes.py

@@ -0,0 +1,240 @@
+# 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,
+        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
+            )
+        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:
+        # Create some fake pulse time zero
+        start = sc.datetime("2024-01-01T12:00:00.000000")
+        period = sc.reciprocal(self.frequency)
+
+        detector = self.model_result.detectors[name]
+        raw_data = detector.data.flatten(to="event")
+        # Select only the neutrons that make it to the detector
+        raw_data = raw_data[~raw_data.masks["blocked_by_others"]].copy()
+        raw_data.coords["Ltotal"] = detector.distance
+
+        # Format the data in a way that resembles data loaded from NeXus
+        event_data = raw_data.copy(deep=False)
+        dt = period.to(unit="us")
+        event_time_zero = (dt * (event_data.coords["toa"] // dt)).to(dtype=int) + start
+        raw_data.coords["event_time_zero"] = event_time_zero
+        event_data.coords["event_time_zero"] = event_time_zero
+        event_data.coords["event_time_offset"] = (
+            event_data.coords.pop("toa").to(unit="s") % period
+        )
+        del event_data.coords["tof"]
+        del event_data.coords["speed"]
+        del event_data.coords["time"]
+        del event_data.coords["wavelength"]
+
+        return (
+            event_data.group("event_time_zero").rename_dims(event_time_zero="pulse"),
+            raw_data.group("event_time_zero").rename_dims(event_time_zero="pulse"),
+        )
+
+
+wfm1_chopper = DiskChopper(
+    frequency=sc.scalar(-70.0, unit="Hz"),
+    beam_position=sc.scalar(0.0, unit="deg"),
+    phase=sc.scalar(-47.10, unit="deg"),
+    axle_position=sc.vector(value=[0, 0, 6.6], unit="m"),
+    slit_begin=sc.array(
+        dims=["cutout"],
+        values=np.array([83.71, 140.49, 193.26, 242.32, 287.91, 330.3]) + 15.0,
+        unit="deg",
+    ),
+    slit_end=sc.array(
+        dims=["cutout"],
+        values=np.array([94.7, 155.79, 212.56, 265.33, 314.37, 360.0]) + 15.0,
+        unit="deg",
+    ),
+    slit_height=sc.scalar(10.0, unit="cm"),
+    radius=sc.scalar(30.0, unit="cm"),
+)
+
+wfm2_chopper = DiskChopper(
+    frequency=sc.scalar(-70.0, unit="Hz"),
+    beam_position=sc.scalar(0.0, unit="deg"),
+    phase=sc.scalar(-76.76, unit="deg"),
+    axle_position=sc.vector(value=[0, 0, 7.1], unit="m"),
+    slit_begin=sc.array(
+        dims=["cutout"],
+        values=np.array([65.04, 126.1, 182.88, 235.67, 284.73, 330.32]) + 15.0,
+        unit="deg",
+    ),
+    slit_end=sc.array(
+        dims=["cutout"],
+        values=np.array([76.03, 141.4, 202.18, 254.97, 307.74, 360.0]) + 15.0,
+        unit="deg",
+    ),
+    slit_height=sc.scalar(10.0, unit="cm"),
+    radius=sc.scalar(30.0, unit="cm"),
+)
+
+foc1_chopper = DiskChopper(
+    frequency=sc.scalar(-56.0, unit="Hz"),
+    beam_position=sc.scalar(0.0, unit="deg"),
+    phase=sc.scalar(-62.40, unit="deg"),
+    axle_position=sc.vector(value=[0, 0, 8.8], unit="m"),
+    slit_begin=sc.array(
+        dims=["cutout"],
+        values=np.array([74.6, 139.6, 194.3, 245.3, 294.8, 347.2]),
+        unit="deg",
+    ),
+    slit_end=sc.array(
+        dims=["cutout"],
+        values=np.array([95.2, 162.8, 216.1, 263.1, 310.5, 371.6]),
+        unit="deg",
+    ),
+    slit_height=sc.scalar(10.0, unit="cm"),
+    radius=sc.scalar(30.0, unit="cm"),
+)
+
+foc2_chopper = DiskChopper(
+    frequency=sc.scalar(-28.0, unit="Hz"),
+    beam_position=sc.scalar(0.0, unit="deg"),
+    phase=sc.scalar(-12.27, unit="deg"),
+    axle_position=sc.vector(value=[0, 0, 15.9], unit="m"),
+    slit_begin=sc.array(
+        dims=["cutout"],
+        values=np.array([98.0, 154.0, 206.8, 255.0, 299.0, 344.65]),
+        unit="deg",
+    ),
+    slit_end=sc.array(
+        dims=["cutout"],
+        values=np.array([134.6, 190.06, 237.01, 280.88, 323.56, 373.76]),
+        unit="deg",
+    ),
+    slit_height=sc.scalar(10.0, unit="cm"),
+    radius=sc.scalar(30.0, unit="cm"),
+)
+
+pol_chopper = DiskChopper(
+    frequency=sc.scalar(-14.0, unit="Hz"),
+    beam_position=sc.scalar(0.0, unit="deg"),
+    phase=sc.scalar(0.0, unit="deg"),
+    axle_position=sc.vector(value=[0, 0, 17.0], unit="m"),
+    slit_begin=sc.array(
+        dims=["cutout"],
+        values=np.array([40.0]),
+        unit="deg",
+    ),
+    slit_end=sc.array(
+        dims=["cutout"],
+        values=np.array([240.0]),
+        unit="deg",
+    ),
+    slit_height=sc.scalar(10.0, unit="cm"),
+    radius=sc.scalar(30.0, unit="cm"),
+)
+
+pulse_skipping = DiskChopper(
+    frequency=sc.scalar(-7.0, unit="Hz"),
+    beam_position=sc.scalar(0.0, unit="deg"),
+    phase=sc.scalar(0.0, unit="deg"),
+    axle_position=sc.vector(value=[0, 0, 30.0], unit="m"),
+    slit_begin=sc.array(
+        dims=["cutout"],
+        values=np.array([40.0]),
+        unit="deg",
+    ),
+    slit_end=sc.array(
+        dims=["cutout"],
+        values=np.array([140.0]),
+        unit="deg",
+    ),
+    slit_height=sc.scalar(10.0, unit="cm"),
+    radius=sc.scalar(30.0, unit="cm"),
+)
+
+
+def wfm_choppers():
+    return {
+        "wfm1": wfm1_chopper,
+        "wfm2": wfm2_chopper,
+        "foc1": foc1_chopper,
+        "foc2": foc2_chopper,
+        "pol": pol_chopper,
+    }
+
+
+def psc_choppers():
+    return {
+        name: DiskChopper(
+            frequency=ch.frequency,
+            beam_position=ch.beam_position,
+            phase=ch.phase,
+            axle_position=ch.axle_position,
+            slit_begin=ch.slit_begin[0:1],
+            slit_end=ch.slit_end[0:1],
+            slit_height=ch.slit_height[0:1],
+            radius=ch.radius,
+        )
+        for name, ch in wfm_choppers().items()
+    }

ess/reduce/time_of_flight/simulation.py

@@ -0,0 +1,74 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright (c) 2025 Scipp contributors (https://github.com/scipp)
+from collections.abc import Mapping
+
+import scipp as sc
+from scippneutron.chopper import DiskChopper
+
+from .types import SimulationResults
+
+
+def simulate_beamline(
+    choppers: Mapping[str, DiskChopper],
+    neutrons: int = 1_000_000,
+    seed: int | None = None,
+    facility: str = 'ess',
+) -> SimulationResults:
+    """
+    Simulate a pulse of neutrons propagating through a chopper cascade using the
+    ``tof`` package (https://tof.readthedocs.io).
+
+    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
+        for more information.
+    neutrons:
+        Number of neutrons to simulate.
+    seed:
+        Seed for the random number generator used in the simulation.
+    facility:
+        Facility where the experiment is performed.
+    """
+    import tof
+
+    tof_choppers = [
+        tof.Chopper(
+            frequency=abs(ch.frequency),
+            direction=tof.AntiClockwise
+            if (ch.frequency.value > 0.0)
+            else tof.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()
+    ]
+    source = tof.Source(facility=facility, neutrons=neutrons, seed=seed)
+    if not tof_choppers:
+        events = source.data.squeeze()
+        return SimulationResults(
+            time_of_arrival=events.coords["time"],
+            speed=events.coords["speed"],
+            wavelength=events.coords["wavelength"],
+            weight=events.data,
+            distance=0.0 * sc.units.m,
+        )
+    model = tof.Model(source=source, choppers=tof_choppers)
+    results = model.run()
+    # Find name of the furthest chopper in tof_choppers
+    furthest_chopper = max(tof_choppers, key=lambda c: c.distance)
+    events = results[furthest_chopper.name].data.squeeze()
+    events = events[
+        ~(events.masks["blocked_by_others"] | events.masks["blocked_by_me"])
+    ]
+    return SimulationResults(
+        time_of_arrival=events.coords["toa"],
+        speed=events.coords["speed"],
+        wavelength=events.coords["wavelength"],
+        weight=events.data,
+        distance=furthest_chopper.distance,
+    )