essreduce 25.4.1__py3-none-any.whl → 25.5.1__py3-none-any.whl

ess/reduce/time_of_flight/eto_to_tof.py

@@ -11,28 +11,39 @@ from collections.abc import Callable
 
 import numpy as np
 import scipp as sc
-from scipp._scipp.core import _bins_no_validate
+import scippneutron as scn
 from scippneutron._utils import elem_unit
 
 try:
     from .interpolator_numba import Interpolator as InterpolatorImpl
 except ImportError:
     from .interpolator_scipy import Interpolator as InterpolatorImpl
+
+from ..nexus.types import (
+    CalibratedBeamline,
+    CalibratedMonitor,
+    DetectorData,
+    MonitorData,
+    MonitorType,
+    RunType,
+)
 from .to_events import to_events
 from .types import (
+    DetectorLtotal,
+    DetectorTofData,
     DistanceResolution,
     LookupTableRelativeErrorThreshold,
-    Ltotal,
     LtotalRange,
+    MonitorLtotal,
+    MonitorTofData,
     PulsePeriod,
     PulseStride,
     PulseStrideOffset,
-    RawData,
-    ResampledTofData,
+    ResampledDetectorTofData,
+    ResampledMonitorTofData,
     SimulationResults,
     TimeOfFlightLookupTable,
     TimeResolution,
-    TofData,
 )
 
 
@@ -84,7 +95,7 @@ def _compute_mean_tof_in_distance_range(
     frame_period:
         Period of the source pulses, i.e., time between consecutive pulse starts.
     time_bins_half_width:
-        Half the width of the time bins.
+        Half width of the time bins in the event_time_offset axis.
     """
     simulation_distance = simulation.distance.to(unit=distance_unit)
     distances = sc.midpoints(distance_bins)
@@ -104,8 +115,7 @@ def _compute_mean_tof_in_distance_range(
         },
     ).flatten(to="event")
 
-    # Add the event_time_offset coordinate to the data. We first operate on the
-    # frame period. The table will later be folded to the pulse period.
+    # Add the event_time_offset coordinate, wrapped to the frame_period
     data.coords['event_time_offset'] = data.coords['toa'] % frame_period
 
     # Because we staggered the mesh by half a bin width, we want the values above
@@ -134,51 +144,6 @@ def _compute_mean_tof_in_distance_range(
     return mean_tof
 
 
-def _fold_table_to_pulse_period(
-    table: sc.DataArray, pulse_period: sc.Variable, pulse_stride: int
-) -> sc.DataArray:
-    """
-    Fold the lookup table to the pulse period. We make sure the left and right edges of
-    the table wrap around the ``event_time_offset`` dimension.
-
-    Parameters
-    ----------
-    table:
-        Lookup table with time-of-flight as a function of distance and time-of-arrival.
-    pulse_period:
-        Period of the source pulses, i.e., time between consecutive pulse starts.
-    pulse_stride:
-        Stride of used pulses. Usually 1, but may be a small integer when
-        pulse-skipping.
-    """
-    size = table.sizes['event_time_offset']
-    if (size % pulse_stride) != 0:
-        raise ValueError(
-            "TimeOfFlightLookupTable: the number of time bins must be a multiple of "
-            f"the pulse stride, but got {size} time bins and a pulse stride of "
-            f"{pulse_stride}."
-        )
-
-    size = size // pulse_stride
-    out = sc.concat([table, table['event_time_offset', 0]], dim='event_time_offset')
-    out = sc.concat(
-        [
-            out['event_time_offset', (i * size) : (i + 1) * size + 1]
-            for i in range(pulse_stride)
-        ],
-        dim='pulse',
-    )
-    return out.assign_coords(
-        event_time_offset=sc.concat(
-            [
-                table.coords['event_time_offset']['event_time_offset', :size],
-                pulse_period,
-            ],
-            'event_time_offset',
-        )
-    )
-
-
 def compute_tof_lookup_table(
     simulation: SimulationResults,
     ltotal_range: LtotalRange,
@@ -212,6 +177,43 @@ def compute_tof_lookup_table(
     error_threshold:
         Threshold for the relative standard deviation (coefficient of variation) of the
         projected time-of-flight above which values are masked.
+
+    Notes
+    -----
+
+    Below are some details about the binning and wrapping around frame period in the
+    time dimension.
+
+    We have some simulated ``toa`` (events) from a Tof/McStas simulation.
+    Those are absolute ``toa``, unwrapped.
+    First we compute the usual ``event_time_offset = toa % frame_period``.
+
+    Now, we want to ensure periodic boundaries. If we make a bin centered around 0,
+    and a bin centered around 71ms: the first bin will use events between 0 and
+    ``0.5 * dt`` (where ``dt`` is the bin width).
+    The last bin will use events between ``frame_period - 0.5*dt`` and
+    ``frame_period + 0.5 * dt``. So when we compute the mean inside those two bins,
+    they will not yield the same results.
+    It is as if the first bin is missing the events it should have between
+    ``-0.5 * dt`` and 0 (because of the modulo we computed above).
+
+    To fix this, we do not make a last bin around 71ms (the bins stop at
+    ``frame_period - 0.5*dt``). Instead, we compute modulo a second time,
+    but this time using ``event_time_offset %= (frame_period - 0.5*dt)``.
+    (we cannot directly do ``event_time_offset = toa % (frame_period - 0.5*dt)`` in a
+    single step because it would introduce a gradual shift,
+    as the pulse number increases).
+
+    This second modulo effectively takes all the events that would have gone in the
+    last bin (between ``frame_period - 0.5*dt`` and ``frame_period``) and puts them in
+    the first bin. Instead of placing them between ``-0.5*dt`` and 0,
+    it places them between 0 and ``0.5*dt``, but this does not really matter,
+    because we then take the mean inside the first bin.
+    Whether the events are on the left or right side of zero does not matter.
+
+    Finally, we make a copy of the left edge, and append it to the right of the table,
+    thus ensuring that the values on the right edge are strictly the same as on the
+    left edge.
     """
     distance_unit = "m"
     time_unit = simulation.time_of_arrival.unit
@@ -276,16 +278,31 @@ def compute_tof_lookup_table(
     table.coords["distance"] = sc.midpoints(table.coords["distance"])
     table.coords["event_time_offset"] = sc.midpoints(table.coords["event_time_offset"])
 
-    table = _fold_table_to_pulse_period(
-        table=table, pulse_period=pulse_period, pulse_stride=pulse_stride
+    # Copy the left edge to the right to create periodic boundary conditions
+    table = sc.DataArray(
+        data=sc.concat(
+            [table.data, table.data['event_time_offset', 0]], dim='event_time_offset'
+        ),
+        coords={
+            "distance": table.coords["distance"],
+            "event_time_offset": sc.concat(
+                [table.coords["event_time_offset"], frame_period],
+                dim='event_time_offset',
+            ),
+            "pulse_period": pulse_period,
+            "pulse_stride": sc.scalar(pulse_stride, unit=None),
+            "distance_resolution": table.coords["distance"][1]
+            - table.coords["distance"][0],
+            "time_resolution": table.coords["event_time_offset"][1]
+            - table.coords["event_time_offset"][0],
+            "error_threshold": sc.scalar(error_threshold),
+        },
     )
 
     # In-place masking for better performance
     _mask_large_uncertainty(table, error_threshold)
 
-    return TimeOfFlightLookupTable(
-        table.transpose(('pulse', 'distance', 'event_time_offset'))
-    )
+    return TimeOfFlightLookupTable(table)
 
 
 class TofInterpolator:
@@ -293,22 +310,6 @@ class TofInterpolator:
         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)
@@ -321,23 +322,16 @@ class TofInterpolator:
         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
-            ),
+            values=lookup.data.to(unit=self._time_unit, copy=False).values,
         )
 
     def __call__(
         self,
-        pulse_index: sc.Variable,
         ltotal: sc.Variable,
         event_time_offset: sc.Variable,
+        pulse_period: sc.Variable,
+        pulse_index: sc.Variable | None = None,
     ) -> 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}, "
@@ -349,31 +343,30 @@ class TofInterpolator:
                 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
+                times=event_time_offset,
+                distances=ltotal,
+                pulse_index=pulse_index.values if pulse_index is not None else None,
+                pulse_period=pulse_period.value,
             ),
             unit=self._time_unit,
         )
 
 
 def _time_of_flight_data_histogram(
-    da: sc.DataArray,
-    lookup: sc.DataArray,
-    ltotal: sc.Variable,
-    pulse_period: sc.Variable,
+    da: sc.DataArray, lookup: sc.DataArray, ltotal: sc.Variable
 ) -> sc.DataArray:
     # 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"}))
     raw_eto = da.coords[key].to(dtype=float, copy=False)
     eto_unit = raw_eto.unit
-    pulse_period = pulse_period.to(unit=eto_unit)
+    pulse_period = lookup.coords["pulse_period"].to(unit=eto_unit)
 
     # In histogram mode, because there is a wrap around at the end of the pulse, we
     # need to insert a bin edge at that exact location to avoid having the last bin
@@ -386,31 +379,14 @@ def _time_of_flight_data_histogram(
     rebinned = da.rebin({key: new_bins})
     etos = rebinned.coords[key]
 
-    # In histogram mode, the lookup table cannot have a pulse dimension because we
-    # cannot know in the histogrammed data which pulse the events belong to.
-    # So we merge the pulse dimension in the lookup table. A quick way to do this
-    # is to take the mean of the data along the pulse dimension (there should
-    # only be regions that are NaN in one pulse and finite in the other).
-    merged = lookup.data.nanmean('pulse')
-    dim = merged.dims[0]
-    lookup = sc.DataArray(
-        data=merged.fold(dim=dim, sizes={'pulse': 1, dim: merged.sizes[dim]}),
-        coords={
-            'pulse': sc.arange('pulse', 1.0),
-            'distance': lookup.coords['distance'],
-            'event_time_offset': lookup.coords['event_time_offset'],
-        },
-    )
-    pulse_index = sc.zeros(sizes=etos.sizes)
-
     # 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 = interp(
-        pulse_index=pulse_index,
         ltotal=ltotal.broadcast(sizes=etos.sizes),
         event_time_offset=etos,
+        pulse_period=pulse_period,
     )
 
     return rebinned.assign_coords(tof=tofs)
@@ -420,6 +396,7 @@ def _guess_pulse_stride_offset(
     pulse_index: sc.Variable,
     ltotal: sc.Variable,
     event_time_offset: sc.Variable,
+    pulse_period: sc.Variable,
     pulse_stride: int,
     interp: TofInterpolator,
 ) -> int:
@@ -446,6 +423,8 @@ def _guess_pulse_stride_offset(
         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_period:
+        Period of the source pulses, i.e., time between consecutive pulse starts.
     pulse_stride:
         Stride of used pulses.
     interp:
@@ -469,7 +448,12 @@ def _guess_pulse_stride_offset(
     )
     for i in range(pulse_stride):
         pulse_inds = (pulse_index + i) % pulse_stride
-        tofs[i] = interp(pulse_index=pulse_inds, ltotal=ltotal, event_time_offset=etos)
+        tofs[i] = interp(
+            ltotal=ltotal,
+            event_time_offset=etos,
+            pulse_index=pulse_inds,
+            pulse_period=pulse_period,
+        )
     # Find the entry in the list with the least number of nan values
     return sorted(tofs, key=lambda x: sc.isnan(tofs[x]).sum())[0]
 
@@ -478,8 +462,6 @@ def _time_of_flight_data_events(
     da: sc.DataArray,
     lookup: sc.DataArray,
     ltotal: sc.Variable,
-    pulse_period: sc.Variable,
-    pulse_stride: int,
     pulse_stride_offset: int,
 ) -> sc.DataArray:
     etos = da.bins.coords["event_time_offset"].to(dtype=float, copy=False)
@@ -492,20 +474,21 @@ def _time_of_flight_data_events(
     ltotal = sc.bins_like(etos, ltotal).bins.constituents["data"]
     etos = etos.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:
+    pulse_index = None
+    pulse_period = lookup.coords["pulse_period"].to(unit=eto_unit)
+    pulse_stride = lookup.coords["pulse_stride"].value
+
+    if pulse_stride > 1:
+        # Compute a pulse index for every event: it is the index of the pulse within a
+        # frame period. The index ranges from zero to pulse_stride - 1.
         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
+        pulse_period_ns = pulse_period.to(unit=etz_unit, dtype=int)
+        frame_period = pulse_period_ns * 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
@@ -513,17 +496,17 @@ def _time_of_flight_data_events(
         # 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
+        diff_to_epoch = (etz.min() - epoch) % pulse_period_ns
         # 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)
+        reference = epoch + diff_to_epoch - (pulse_period_ns // 2)
         # Use in-place operations to avoid large allocations
         pulse_index = etz - reference
         pulse_index %= frame_period
-        pulse_index //= pulse_period
+        pulse_index //= pulse_period_ns
 
         # Apply the pulse_stride_offset
         if pulse_stride_offset is None:
@@ -531,6 +514,7 @@ def _time_of_flight_data_events(
                 pulse_index=pulse_index,
                 ltotal=ltotal,
                 event_time_offset=etos,
+                pulse_period=pulse_period,
                 pulse_stride=pulse_stride,
                 interp=interp,
             )
@@ -538,21 +522,86 @@ def _time_of_flight_data_events(
         pulse_index %= pulse_stride
 
     # Compute time-of-flight for all neutrons using the interpolator
-    tofs = interp(pulse_index=pulse_index, ltotal=ltotal, event_time_offset=etos)
+    tofs = interp(
+        ltotal=ltotal,
+        event_time_offset=etos,
+        pulse_index=pulse_index,
+        pulse_period=pulse_period,
+    )
 
     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(
+    detector_beamline: CalibratedBeamline[RunType],
+) -> DetectorLtotal[RunType]:
+    """
+    Compute Ltotal for the detector pixels.
+    This is a naive straight-line approximation to Ltotal based on basic component
+    positions.
+
+    Parameters
+    ----------
+    detector_beamline:
+        Beamline data for the detector that contains the positions necessary to compute
+        the straight-line approximation to Ltotal (source, sample, and detector
+        positions).
+    """
+    graph = scn.conversion.graph.beamline.beamline(scatter=True)
+    return DetectorLtotal[RunType](
+        detector_beamline.transform_coords(
+            "Ltotal", graph=graph, keep_intermediate=False
+        ).coords["Ltotal"]
+    )
+
+
+def monitor_ltotal_from_straight_line_approximation(
+    monitor_beamline: CalibratedMonitor[RunType, MonitorType],
+) -> MonitorLtotal[RunType, MonitorType]:
+    """
+    Compute Ltotal for the monitor.
+    This is a naive straight-line approximation to Ltotal based on basic component
+    positions.
+
+    Parameters
+    ----------
+    monitor_beamline:
+        Beamline data for the monitor that contains the positions necessary to compute
+        the straight-line approximation to Ltotal (source and monitor positions).
+    """
+    graph = scn.conversion.graph.beamline.beamline(scatter=False)
+    return MonitorLtotal[RunType, MonitorType](
+        monitor_beamline.transform_coords(
+            "Ltotal", graph=graph, keep_intermediate=False
+        ).coords["Ltotal"]
+    )
 
 
-def time_of_flight_data(
-    da: RawData,
+def _compute_tof_data(
+    da: sc.DataArray,
+    lookup: sc.DataArray,
+    ltotal: sc.Variable,
+    pulse_stride_offset: int,
+) -> sc.DataArray:
+    if da.bins is None:
+        return _time_of_flight_data_histogram(da=da, lookup=lookup, ltotal=ltotal)
+    else:
+        return _time_of_flight_data_events(
+            da=da,
+            lookup=lookup,
+            ltotal=ltotal,
+            pulse_stride_offset=pulse_stride_offset,
+        )
+
+
+def detector_time_of_flight_data(
+    detector_data: DetectorData[RunType],
     lookup: TimeOfFlightLookupTable,
-    ltotal: Ltotal,
-    pulse_period: PulsePeriod,
-    pulse_stride: PulseStride,
+    ltotal: DetectorLtotal[RunType],
     pulse_stride_offset: PulseStrideOffset,
-) -> TofData:
+) -> DetectorTofData[RunType]:
     """
     Convert the time-of-arrival data to time-of-flight data using a lookup table.
     The output data will have a time-of-flight coordinate.
@@ -567,33 +616,55 @@ def time_of_flight_data(
         arrival.
     ltotal:
         Total length of the flight path from the source to the detector.
-    pulse_period:
-        Period of the source pulses, i.e., time between consecutive pulse starts.
-    pulse_stride:
-        Stride of used pulses. Usually 1, but may be a small integer when
-        pulse-skipping.
     pulse_stride_offset:
         When pulse-skipping, the offset of the first pulse in the stride. This is
         typically zero but can be a small integer < pulse_stride.
     """
-
-    if da.bins is None:
-        out = _time_of_flight_data_histogram(
-            da=da, lookup=lookup, ltotal=ltotal, pulse_period=pulse_period
+    return DetectorTofData[RunType](
+        _compute_tof_data(
+            da=detector_data,
+            lookup=lookup,
+            ltotal=ltotal,
+            pulse_stride_offset=pulse_stride_offset,
         )
-    else:
-        out = _time_of_flight_data_events(
-            da=da,
+    )
+
+
+def monitor_time_of_flight_data(
+    monitor_data: MonitorData[RunType, MonitorType],
+    lookup: TimeOfFlightLookupTable,
+    ltotal: MonitorLtotal[RunType, MonitorType],
+    pulse_stride_offset: PulseStrideOffset,
+) -> MonitorTofData[RunType, MonitorType]:
+    """
+    Convert the time-of-arrival data to time-of-flight data using a lookup table.
+    The output data will have a time-of-flight coordinate.
+
+    Parameters
+    ----------
+    da:
+        Raw monitor data loaded from a NeXus file, e.g., NXmonitor containing
+        NXevent_data.
+    lookup:
+        Lookup table giving time-of-flight as a function of distance and time of
+        arrival.
+    ltotal:
+        Total length of the flight path from the source to the monitor.
+    pulse_stride_offset:
+        When pulse-skipping, the offset of the first pulse in the stride. This is
+        typically zero but can be a small integer < pulse_stride.
+    """
+    return MonitorTofData[RunType, MonitorType](
+        _compute_tof_data(
+            da=monitor_data,
             lookup=lookup,
             ltotal=ltotal,
-            pulse_period=pulse_period,
-            pulse_stride=pulse_stride,
             pulse_stride_offset=pulse_stride_offset,
         )
-    return TofData(out)
+    )
 
 
-def resample_tof_data(da: TofData) -> ResampledTofData:
+def _resample_tof_data(da: sc.DataArray) -> sc.DataArray:
     """
     Histogrammed data that has been converted to `tof` will typically have
     unsorted bin edges (due to either wrapping of `time_of_flight` or wavelength
@@ -626,13 +697,29 @@ def resample_tof_data(da: TofData) -> ResampledTofData:
     coord = da.coords["tof"]
     bin_width = (coord[dim, 1:] - coord[dim, :-1]).nanmedian()
     rehist = events.hist(tof=bin_width)
-    return ResampledTofData(
-        rehist.assign_coords(
-            {key: var for key, var in da.coords.items() if dim not in var.dims}
-        )
+    return rehist.assign_coords(
+        {key: var for key, var in da.coords.items() if dim not in var.dims}
     )
 
 
+def resample_detector_time_of_flight_data(
+    da: DetectorTofData[RunType],
+) -> ResampledDetectorTofData[RunType]:
+    """
+    Resample the detector time-of-flight data to ensure that the bin edges are sorted.
+    """
+    return ResampledDetectorTofData(_resample_tof_data(da))
+
+
+def resample_monitor_time_of_flight_data(
+    da: MonitorTofData[RunType, MonitorType],
+) -> ResampledMonitorTofData[RunType, MonitorType]:
+    """
+    Resample the monitor time-of-flight data to ensure that the bin edges are sorted.
+    """
+    return ResampledMonitorTofData(_resample_tof_data(da))
+
+
 def default_parameters() -> dict:
     """
     Default parameters of the time-of-flight workflow.
@@ -651,4 +738,10 @@ def providers() -> tuple[Callable]:
     """
     Providers of the time-of-flight workflow.
     """
-    return (compute_tof_lookup_table, time_of_flight_data)
+    return (
+        compute_tof_lookup_table,
+        detector_time_of_flight_data,
+        monitor_time_of_flight_data,
+        detector_ltotal_from_straight_line_approximation,
+        monitor_ltotal_from_straight_line_approximation,
+    )

ess/reduce/time_of_flight/fakes.py

@@ -28,9 +28,9 @@ class FakeBeamline:
         import math
 
         import tof as tof_pkg
-        from tof.facilities.ess_pulse import pulse
+        from tof.facilities.ess_pulse import frequency as ess_frequency
 
-        self.frequency = pulse.frequency
+        self.frequency = ess_frequency
         self.npulses = math.ceil((run_length * self.frequency).to(unit="").value)
         self.events_per_pulse = events_per_pulse
         if source_position is None: