essreduce 25.5.0__tar.gz → 25.5.1__tar.gz

{essreduce-25.5.0/src/essreduce.egg-info → essreduce-25.5.1}/PKG-INFO

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

{essreduce-25.5.0 → essreduce-25.5.1}/docs/user-guide/tof/dream.ipynb

@@ -305,7 +305,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "wf = time_of_flight.GenericTofWorkflow()\n",
+    "wf = time_of_flight.GenericTofWorkflow(\n",
+    "    tof_lut_provider=time_of_flight.TofLutProvider.TOF\n",
+    ")\n",
     "wf[DetectorData[SampleRun]] = raw_data\n",
     "wf[time_of_flight.DetectorLtotal[SampleRun]] = Ltotal\n",
     "wf[time_of_flight.LtotalRange] = (\n",

{essreduce-25.5.0 → essreduce-25.5.1}/docs/user-guide/tof/frame-unwrapping.ipynb

@@ -159,7 +159,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "wf = time_of_flight.GenericTofWorkflow()\n",
+    "wf = time_of_flight.GenericTofWorkflow(\n",
+    "    tof_lut_provider=time_of_flight.TofLutProvider.TOF\n",
+    ")\n",
     "\n",
     "wf[DetectorData[SampleRun]] = nxevent_data\n",
     "wf[time_of_flight.DetectorLtotal[SampleRun]] = nxevent_data.coords[\"Ltotal\"]\n",
@@ -368,7 +370,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "wf = time_of_flight.GenericTofWorkflow()\n",
+    "wf = time_of_flight.GenericTofWorkflow(\n",
+    "    tof_lut_provider=time_of_flight.TofLutProvider.TOF\n",
+    ")\n",
     "\n",
     "nxevent_data = results.to_nxevent_data()\n",
     "\n",

{essreduce-25.5.0 → essreduce-25.5.1}/docs/user-guide/tof/wfm.ipynb

@@ -326,7 +326,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "wf = time_of_flight.GenericTofWorkflow()\n",
+    "wf = time_of_flight.GenericTofWorkflow(\n",
+    "    tof_lut_provider=time_of_flight.TofLutProvider.TOF\n",
+    ")\n",
     "wf[DetectorData[SampleRun]] = raw_data\n",
     "wf[time_of_flight.DetectorLtotal[SampleRun]] = Ltotal\n",
     "wf[time_of_flight.LtotalRange] = Ltotal, Ltotal\n",
@@ -353,9 +355,7 @@
    "outputs": [],
    "source": [
     "wf[time_of_flight.SimulationResults] = time_of_flight.simulate_beamline(\n",
-    "    choppers=disk_choppers,\n",
-    "    source_position=source_position,\n",
-    "    neutrons=3_000_000\n",
+    "    choppers=disk_choppers, source_position=source_position, neutrons=3_000_000\n",
     ")"
    ]
   },

{essreduce-25.5.0 → essreduce-25.5.1}/src/ess/reduce/nexus/types.py

@@ -341,10 +341,3 @@ class Choppers(
     sc.DataGroup[sc.DataGroup[Any]],
 ):
     """All choppers in a NeXus file."""
-
-
-class Analyzers(
-    sciline.Scope[RunType, sc.DataGroup[sc.DataGroup[Any]]],
-    sc.DataGroup[sc.DataGroup[Any]],
-):
-    """All analyzers in a NeXus file."""

{essreduce-25.5.0 → essreduce-25.5.1}/src/ess/reduce/nexus/workflow.py

@@ -19,7 +19,6 @@ from ..utils import prune_type_vars
 from . import _nexus_loader as nexus
 from .types import (
     AllNeXusComponents,
-    Analyzers,
     Beamline,
     CalibratedBeamline,
     CalibratedDetector,
@@ -525,13 +524,6 @@ def parse_disk_choppers(
     )
 
 
-def parse_analyzers(
-    analyzers: AllNeXusComponents[snx.NXcrystal, RunType],
-) -> Analyzers[RunType]:
-    """Convert the NeXus representation of an analyzer to ours."""
-    return Analyzers[RunType](analyzers.apply(nexus.compute_component_position))
-
-
 def _drop(
     children: dict[str, snx.Field | snx.Group], classes: tuple[snx.NXobject, ...]
 ) -> dict[str, snx.Field | snx.Group]:
@@ -628,7 +620,6 @@ _common_providers = (
     nx_class_for_source,
     nx_class_for_sample,
     nx_class_for_disk_chopper,
-    nx_class_for_crystal,
 )
 
 _monitor_providers = (
@@ -647,8 +638,6 @@ _detector_providers = (
 
 _chopper_providers = (parse_disk_choppers,)
 
-_analyzer_providers = (parse_analyzers,)
-
 _metadata_providers = (
     load_beamline_metadata_from_nexus,
     load_measurement_metadata_from_nexus,
@@ -711,7 +700,6 @@ def GenericNeXusWorkflow(
             *_monitor_providers,
             *_detector_providers,
             *_chopper_providers,
-            *_analyzer_providers,
             *_metadata_providers,
         )
     )

{essreduce-25.5.0 → essreduce-25.5.1}/src/ess/reduce/time_of_flight/__init__.py

@@ -29,9 +29,10 @@ from .types import (
     ResampledMonitorTofData,
     SimulationResults,
     TimeOfFlightLookupTable,
+    TimeOfFlightLookupTableFilename,
     TimeResolution,
 )
-from .workflow import GenericTofWorkflow
+from .workflow import GenericTofWorkflow, TofLutProvider
 
 __all__ = [
     "DetectorLtotal",
@@ -49,7 +50,9 @@ __all__ = [
     "ResampledMonitorTofData",
     "SimulationResults",
     "TimeOfFlightLookupTable",
+    "TimeOfFlightLookupTableFilename",
     "TimeResolution",
+    "TofLutProvider",
     "default_parameters",
     "providers",
     "resample_detector_time_of_flight_data",

{essreduce-25.5.0 → essreduce-25.5.1}/src/ess/reduce/time_of_flight/eto_to_tof.py

@@ -12,7 +12,6 @@ from collections.abc import Callable
 import numpy as np
 import scipp as sc
 import scippneutron as scn
-from scipp._scipp.core import _bins_no_validate
 from scippneutron._utils import elem_unit
 
 try:
@@ -532,7 +531,7 @@ def _time_of_flight_data_events(
 
     parts = da.bins.constituents
     parts["data"] = tofs
-    return da.bins.assign_coords(tof=_bins_no_validate(**parts))
+    return da.bins.assign_coords(tof=sc.bins(**parts, validate_indices=False))
 
 
 def detector_ltotal_from_straight_line_approximation(

{essreduce-25.5.0 → essreduce-25.5.1}/src/ess/reduce/time_of_flight/simulation.py

@@ -3,9 +3,11 @@
 from collections.abc import Mapping
 
 import scipp as sc
+import scippnexus as snx
 from scippneutron.chopper import DiskChopper
 
-from .types import SimulationResults
+from ..nexus.types import Choppers, Position, SampleRun
+from .types import NumberOfSimulatedNeutrons, SimulationResults
 
 
 def simulate_beamline(
@@ -82,3 +84,25 @@ def simulate_beamline(
         weight=events.data,
         distance=furthest_chopper.distance,
     )
+
+
+def simulate_chopper_cascade_using_tof(
+    choppers: Choppers[SampleRun],
+    neutrons: NumberOfSimulatedNeutrons,
+    source_position: Position[snx.NXsource, SampleRun],
+) -> SimulationResults:
+    """
+    Simulate neutrons traveling through the chopper cascade using the ``tof`` package.
+
+    Parameters
+    ----------
+    choppers:
+        Chopper settings.
+    neutrons:
+        Number of neutrons to simulate.
+    source_position:
+        Position of the source.
+    """
+    return simulate_beamline(
+        choppers=choppers, neutrons=neutrons, source_position=source_position
+    )

{essreduce-25.5.0 → essreduce-25.5.1}/src/ess/reduce/time_of_flight/types.py

@@ -46,6 +46,12 @@ class SimulationResults:
     distance: sc.Variable
 
 
+NumberOfSimulatedNeutrons = NewType("NumberOfSimulatedNeutrons", int)
+"""
+Number of neutrons simulated in the simulation that is used to create the lookup table.
+This is typically a large number, e.g., 1e6 or 1e7.
+"""
+
 LtotalRange = NewType("LtotalRange", tuple[sc.Variable, sc.Variable])
 """
 Range (min, max) of the total length of the flight path from the source to the detector.
@@ -78,6 +84,10 @@ resolution in the lookup table will be at least the supplied value here, but may
 smaller if the pulse period is not an integer multiple of the time resolution.
 """
 
+TimeOfFlightLookupTableFilename = NewType("TimeOfFlightLookupTableFilename", str)
+"""Filename of the time-of-flight lookup table."""
+
+
 TimeOfFlightLookupTable = NewType("TimeOfFlightLookupTable", sc.DataArray)
 """
 Lookup table giving time-of-flight as a function of distance and time of arrival.

{essreduce-25.5.0 → essreduce-25.5.1}/src/ess/reduce/time_of_flight/workflow.py

@@ -1,18 +1,36 @@
 # SPDX-License-Identifier: BSD-3-Clause
 # Copyright (c) 2025 Scipp contributors (https://github.com/scipp)
 from collections.abc import Iterable
+from enum import Enum, auto
 
 import sciline
+import scipp as sc
 
 from ..nexus import GenericNeXusWorkflow
 from ..utils import prune_type_vars
-from .eto_to_tof import default_parameters, providers
+from . import eto_to_tof, simulation
+from .types import TimeOfFlightLookupTable, TimeOfFlightLookupTableFilename
+
+
+class TofLutProvider(Enum):
+    """Provider for the time-of-flight lookup table."""
+
+    FILE = auto()  # From file
+    TOF = auto()  # Computed with 'tof' package from chopper settings
+    MCSTAS = auto()  # McStas simulation (not implemented yet)
+
+
+def load_tof_lookup_table(
+    filename: TimeOfFlightLookupTableFilename,
+) -> TimeOfFlightLookupTable:
+    return TimeOfFlightLookupTable(sc.io.load_hdf5(filename))
 
 
 def GenericTofWorkflow(
     *,
     run_types: Iterable[sciline.typing.Key] | None = None,
     monitor_types: Iterable[sciline.typing.Key] | None = None,
+    tof_lut_provider: TofLutProvider = TofLutProvider.FILE,
 ) -> sciline.Pipeline:
     """
     Generic workflow for computing the neutron time-of-flight for detector and monitor
@@ -42,6 +60,11 @@ def GenericTofWorkflow(
         List of monitor types to include in the workflow. If not provided, all monitor
         types are included.
         Must be a possible value of :class:`ess.reduce.nexus.types.MonitorType`.
+    tof_lut_provider:
+        Specifies how the time-of-flight lookup table is provided:
+        - FILE: Read from a file
+        - TOF: Computed from chopper settings using the 'tof' package
+        - MCSTAS: From McStas simulation (not implemented yet)
 
     Returns
     -------
@@ -50,9 +73,19 @@ def GenericTofWorkflow(
     """
     wf = GenericNeXusWorkflow(run_types=run_types, monitor_types=monitor_types)
 
-    for provider in providers():
+    for provider in eto_to_tof.providers():
         wf.insert(provider)
-    for key, value in default_parameters().items():
+
+    if tof_lut_provider == TofLutProvider.FILE:
+        wf.insert(load_tof_lookup_table)
+    else:
+        wf.insert(eto_to_tof.compute_tof_lookup_table)
+        if tof_lut_provider == TofLutProvider.TOF:
+            wf.insert(simulation.simulate_chopper_cascade_using_tof)
+        if tof_lut_provider == TofLutProvider.MCSTAS:
+            raise NotImplementedError("McStas simulation not implemented yet")
+
+    for key, value in eto_to_tof.default_parameters().items():
         wf[key] = value
 
     if run_types is not None or monitor_types is not None:

{essreduce-25.5.0 → essreduce-25.5.1}/src/ess/reduce/workflow.py

@@ -53,12 +53,14 @@ def get_typical_outputs(pipeline: Pipeline) -> tuple[Key, ...]:
     if (typical_outputs := getattr(pipeline, "typical_outputs", None)) is None:
         graph = pipeline.underlying_graph
         sink_nodes = [node for node, degree in graph.out_degree if degree == 0]
-        return sorted(_with_pretty_names(sink_nodes))
+        return sorted(_with_pretty_names(sink_nodes), key=lambda x: x[0])
     return _with_pretty_names(typical_outputs)
 
 
 def get_possible_outputs(pipeline: Pipeline) -> tuple[Key, ...]:
-    return sorted(_with_pretty_names(tuple(pipeline.underlying_graph.nodes)))
+    return sorted(
+        _with_pretty_names(tuple(pipeline.underlying_graph.nodes)), key=lambda x: x[0]
+    )
 
 
 def _with_pretty_names(outputs: Sequence[Key]) -> tuple[tuple[str, Key], ...]:

{essreduce-25.5.0 → essreduce-25.5.1/src/essreduce.egg-info}/PKG-INFO

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

{essreduce-25.5.0 → essreduce-25.5.1}/src/essreduce.egg-info/SOURCES.txt

@@ -138,4 +138,5 @@ tests/scripts/test_grow_nexus.py
 tests/time_of_flight/interpolator_test.py
 tests/time_of_flight/to_events_test.py
 tests/time_of_flight/unwrap_test.py
-tests/time_of_flight/wfm_test.py
+tests/time_of_flight/wfm_test.py
+tests/time_of_flight/workflow_test.py

{essreduce-25.5.0 → essreduce-25.5.1}/tests/nexus/nexus_loader_test.py

@@ -107,27 +107,6 @@ def _choppers_data() -> sc.DataGroup[sc.DataGroup[Any]]:
     )
 
 
-def _analyzers_data() -> sc.DataGroup[sc.DataGroup[Any]]:
-    return sc.DataGroup[sc.DataGroup[Any]](
-        {
-            'analyzer_B': sc.DataGroup[Any](
-                {
-                    'd_spacing': sc.scalar(3.355, unit='angstrom'),
-                    'usage': 'Bragg',
-                    'nexus_component_name': 'analyzer_B',
-                }
-            ),
-            'analyzer_A': sc.DataGroup[Any](
-                {
-                    'd_spacing': sc.scalar(3.104, unit='angstrom'),
-                    'usage': 'Bragg',
-                    'nexus_component_name': 'analyzer_A',
-                }
-            ),
-        }
-    )
-
-
 def _write_transformation(group: snx.Group, offset: sc.Variable) -> None:
     group.create_field('depends_on', sc.scalar('transformations/t1'))
     transformations = group.create_class('transformations', snx.NXtransformations)
@@ -184,11 +163,6 @@ def _write_nexus_data(store: Path | BytesIO) -> None:
             chop.create_field('slit_height', chopper['slit_height'])
             chop.create_field('slits', chopper['slits'])
 
-        for name, analyzer in _analyzers_data().items():
-            ana = instrument.create_class(name, snx.NXcrystal)
-            ana.create_field('d_spacing', analyzer['d_spacing'])
-            ana.create_field('usage', analyzer['usage'])
-
 
 @contextmanager
 def _file_store(request: pytest.FixtureRequest):
@@ -273,11 +247,6 @@ def expected_choppers() -> sc.DataGroup[sc.DataGroup[Any]]:
     return _choppers_data()
 
 
-@pytest.fixture
-def expected_analyzers() -> sc.DataGroup[sc.DataGroup[Any]]:
-    return _analyzers_data()
-
-
 def test_load_data_loads_expected_event_data(nexus_file, expected_bank12):
     events = nexus.load_data(
         nexus_file,
@@ -536,16 +505,6 @@ def test_load_disk_choppers(nexus_file, expected_choppers, entry_name):
     sc.testing.assert_identical(choppers, expected_choppers)
 
 
-@pytest.mark.parametrize('entry_name', [None, nexus.types.NeXusEntryName('entry-001')])
-def test_load_analyzers(nexus_file, expected_analyzers, entry_name):
-    loc = NeXusLocationSpec(
-        filename=nexus_file,
-        entry_name=entry_name,
-    )
-    analyzers = nexus.load_all_components(loc, nx_class=snx.NXcrystal)
-    sc.testing.assert_identical(analyzers, expected_analyzers)
-
-
 def test_extract_detector_data():
     detector = sc.DataGroup(
         {

{essreduce-25.5.0 → essreduce-25.5.1}/tests/nexus/workflow_test.py

@@ -10,7 +10,6 @@ from scipp.testing import assert_identical
 from ess.reduce import data
 from ess.reduce.nexus import compute_component_position, workflow
 from ess.reduce.nexus.types import (
-    Analyzers,
     BackgroundRun,
     Beamline,
     Choppers,
@@ -573,18 +572,6 @@ def test_generic_nexus_workflow_load_choppers() -> None:
     assert chopper['slit_edges'].shape == (2,)
 
 
-def test_generic_nexus_workflow_load_analyzers() -> None:
-    wf = GenericNeXusWorkflow()
-    wf[Filename[SampleRun]] = data.bifrost_simulated_elastic()
-    analyzers = wf.compute(Analyzers[SampleRun])
-
-    assert len(analyzers) == 45
-    analyzer = analyzers['144_channel_2_1_monochromator']
-    assert 'position' in analyzer
-    assert analyzer['d_spacing'].ndim == 0
-    assert analyzer['usage'] == 'Bragg'
-
-
 def test_generic_nexus_workflow_load_beamline_metadata() -> None:
     wf = GenericNeXusWorkflow()
     wf[Filename[SampleRun]] = data.bifrost_simulated_elastic()
@@ -626,8 +613,6 @@ def test_generic_nexus_workflow_includes_only_given_run_and_monitor_types() -> N
     assert MonitorData[BackgroundRun, Monitor3] not in graph
     assert Choppers[SampleRun] in graph
     assert Choppers[BackgroundRun] not in graph
-    assert Analyzers[SampleRun] in graph
-    assert Analyzers[BackgroundRun] not in graph
 
     assert NeXusComponentLocationSpec[Monitor1, SampleRun] in graph
     assert NeXusComponentLocationSpec[Monitor2, SampleRun] not in graph
@@ -664,8 +649,6 @@ def test_generic_nexus_workflow_includes_only_given_run_types() -> None:
     assert MonitorData[SampleRun, Monitor3] not in graph
     assert Choppers[EmptyBeamRun] in graph
     assert Choppers[SampleRun] not in graph
-    assert Analyzers[EmptyBeamRun] in graph
-    assert Analyzers[SampleRun] not in graph
 
     excluded_run_types = set(RunType.__constraints__) - {EmptyBeamRun}
     for node in graph:
@@ -689,8 +672,6 @@ def test_generic_nexus_workflow_includes_only_given_monitor_types() -> None:
     assert MonitorData[BackgroundRun, Monitor3] not in graph
     assert Choppers[SampleRun] in graph
     assert Choppers[BackgroundRun] in graph
-    assert Analyzers[SampleRun] in graph
-    assert Analyzers[BackgroundRun] in graph
 
     excluded_monitor_types = set(MonitorType.__constraints__) - {
         Monitor1,

essreduce-25.5.1/tests/time_of_flight/workflow_test.py

@@ -0,0 +1,136 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright (c) 2025 Scipp contributors (https://github.com/scipp)
+import numpy as np
+import pytest
+import sciline
+import scipp as sc
+import scippnexus as snx
+from scipp.testing import assert_identical
+
+from ess.reduce import time_of_flight
+from ess.reduce.nexus.types import (
+    CalibratedBeamline,
+    Choppers,
+    DetectorData,
+    NeXusData,
+    Position,
+    SampleRun,
+)
+from ess.reduce.time_of_flight import GenericTofWorkflow, TofLutProvider, fakes
+
+sl = pytest.importorskip("sciline")
+
+
+@pytest.fixture
+def calibrated_beamline():
+    return sc.DataArray(
+        data=sc.ones(dims=["detector_number"], shape=[10]),
+        coords={
+            "Ltotal": sc.scalar(80.0, unit="m"),
+            "detector_number": sc.array(
+                dims=["detector_number"], values=np.arange(10), unit=None
+            ),
+        },
+    )
+
+
+@pytest.fixture
+def nexus_data():
+    events = sc.DataArray(
+        data=sc.ones(dims=["event"], shape=[1000]),
+        coords={
+            "event_time_offset": sc.linspace(
+                "event", 0.0, 1000.0 / 14, num=1000, unit="ms"
+            ).to(unit="ns"),
+            "event_id": sc.array(
+                dims=["event"], values=np.arange(1000) % 10, unit=None
+            ),
+        },
+    )
+    return sc.DataArray(
+        sc.bins(
+            begin=sc.array(dims=["pulse"], values=[0], unit=None),
+            data=events,
+            dim="event",
+        )
+    )
+
+
+def test_GenericTofWorkflow_can_compute_tof_lut_without_nexus_file_or_detector_info():
+    wf = GenericTofWorkflow(tof_lut_provider=TofLutProvider.TOF)
+    wf[Choppers[SampleRun]] = fakes.psc_choppers()
+    wf[time_of_flight.types.NumberOfSimulatedNeutrons] = 10_000
+    wf[time_of_flight.types.LtotalRange] = (
+        sc.scalar(0.0, unit="m"),
+        sc.scalar(100.0, unit="m"),
+    )
+    wf[Position[snx.NXsource, SampleRun]] = fakes.source_position()
+    lut = wf.compute(time_of_flight.TimeOfFlightLookupTable)
+    assert isinstance(lut, sc.DataArray)
+
+
+def test_GenericTofWorkflow_with_tof_lut_from_tof_simulation(
+    calibrated_beamline: sc.DataArray, nexus_data: sc.DataArray
+):
+    wf = GenericTofWorkflow(tof_lut_provider=TofLutProvider.TOF)
+    wf[CalibratedBeamline[SampleRun]] = calibrated_beamline
+    wf[NeXusData[snx.NXdetector, SampleRun]] = nexus_data
+
+    # Should be able to compute DetectorData without chopper and simulation params
+    # This contains event_time_offset (time-of-arrival).
+    _ = wf.compute(DetectorData[SampleRun])
+    # LUT and Tof data cannot be computed without chopper and simulation params
+    with pytest.raises(sciline.UnsatisfiedRequirement):
+        _ = wf.compute(time_of_flight.TimeOfFlightLookupTable)
+    with pytest.raises(sciline.UnsatisfiedRequirement):
+        _ = wf.compute(time_of_flight.DetectorTofData[SampleRun])
+
+    wf[Choppers[SampleRun]] = fakes.psc_choppers()
+    wf[time_of_flight.types.NumberOfSimulatedNeutrons] = 10_000
+    wf[time_of_flight.types.LtotalRange] = (
+        sc.scalar(0.0, unit="m"),
+        sc.scalar(100.0, unit="m"),
+    )
+    wf[Position[snx.NXsource, SampleRun]] = fakes.source_position()
+
+    # Should be able to compute DetectorData with chopper and simulation params
+    _ = wf.compute(time_of_flight.TimeOfFlightLookupTable)
+    detector = wf.compute(time_of_flight.DetectorTofData[SampleRun])
+    assert 'tof' in detector.bins.coords
+
+
+def test_GenericTofWorkflow_with_tof_lut_from_mcstas_simulation():
+    with pytest.raises(
+        NotImplementedError, match="McStas simulation not implemented yet"
+    ):
+        GenericTofWorkflow(tof_lut_provider=TofLutProvider.MCSTAS)
+
+
+def test_GenericTofWorkflow_with_tof_lut_from_file(
+    calibrated_beamline: sc.DataArray,
+    nexus_data: sc.DataArray,
+    tmp_path: pytest.TempPathFactory,
+):
+    make_lut_wf = GenericTofWorkflow(tof_lut_provider=TofLutProvider.TOF)
+    make_lut_wf[Choppers[SampleRun]] = fakes.psc_choppers()
+    make_lut_wf[time_of_flight.types.NumberOfSimulatedNeutrons] = 10_000
+    make_lut_wf[time_of_flight.types.LtotalRange] = (
+        sc.scalar(0.0, unit="m"),
+        sc.scalar(100.0, unit="m"),
+    )
+    make_lut_wf[Position[snx.NXsource, SampleRun]] = fakes.source_position()
+    lut = make_lut_wf.compute(time_of_flight.TimeOfFlightLookupTable)
+    lut.save_hdf5(filename=tmp_path / "lut.h5")
+
+    wf = GenericTofWorkflow(tof_lut_provider=TofLutProvider.FILE)
+    wf[CalibratedBeamline[SampleRun]] = calibrated_beamline
+    wf[NeXusData[snx.NXdetector, SampleRun]] = nexus_data
+    wf[time_of_flight.TimeOfFlightLookupTableFilename] = (
+        tmp_path / "lut.h5"
+    ).as_posix()
+
+    loaded_lut = wf.compute(time_of_flight.TimeOfFlightLookupTable)
+    assert_identical(lut, loaded_lut)
+
+    detector = wf.compute(time_of_flight.DetectorTofData[SampleRun])
+    assert 'tof' in detector.bins.coords