essreduce 25.11.0__tar.gz → 25.11.2__tar.gz

{essreduce-25.11.0 → essreduce-25.11.2}/PKG-INFO

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

{essreduce-25.11.0 → essreduce-25.11.2}/requirements/base.txt

@@ -68,7 +68,7 @@ python-dateutil==2.9.0.post0
     #   scippnexus
 sciline==25.11.0
     # via -r base.in
-scipp==25.8.0
+scipp==25.11.0
     # via
     #   -r base.in
     #   scippneutron

{essreduce-25.11.0 → essreduce-25.11.2}/requirements/basetest.txt

@@ -97,7 +97,7 @@ python-dateutil==2.9.0.post0
     # via matplotlib
 requests==2.32.5
     # via pooch
-scipp==25.8.0
+scipp==25.11.0
     # via tof
 scipy==1.16.3
     # via

{essreduce-25.11.0 → essreduce-25.11.2}/src/ess/reduce/nexus/__init__.py

@@ -20,6 +20,7 @@ from ._nexus_loader import (
     load_all_components,
     load_component,
     load_data,
+    load_from_path,
     open_component_group,
     open_nexus_file,
 )
@@ -33,6 +34,7 @@ __all__ = [
     'load_all_components',
     'load_component',
     'load_data',
+    'load_from_path',
     'open_component_group',
     'open_nexus_file',
     'types',

{essreduce-25.11.0 → essreduce-25.11.2}/src/ess/reduce/nexus/_nexus_loader.py

@@ -8,7 +8,7 @@ from collections.abc import Generator, Mapping
 from contextlib import AbstractContextManager, contextmanager, nullcontext
 from dataclasses import dataclass
 from math import prod
-from typing import TypeVar, cast
+from typing import Any, TypeVar, cast
 
 import scipp as sc
 import scippnexus as snx
@@ -42,6 +42,31 @@ class NoLockingIfNeededType:
 NoLockingIfNeeded = NoLockingIfNeededType()
 
 
+def load_from_path(
+    location: NeXusLocationSpec,
+    definitions: Mapping | NoNewDefinitionsType = NoNewDefinitions,
+) -> Any:
+    """Load a field or group from a NeXus file given its location.
+
+    Parameters
+    ----------
+    location:
+        Location of the field within the NeXus file (filename, entry name, selection).
+    definitions:
+        Application definitions to use for the file.
+
+    Returns
+    -------
+    :
+        The loaded field (as a variable, data array, or raw python object) or group
+        (as a data group).
+    """
+    with open_nexus_file(location.filename, definitions=definitions) as f:
+        entry = _unique_child_group(f, snx.NXentry, location.entry_name)
+        item = entry[location.component_name]
+        return item[location.selection]
+
+
 def load_component(
     location: NeXusLocationSpec,
     *,

{essreduce-25.11.0 → essreduce-25.11.2}/src/ess/reduce/nexus/workflow.py

@@ -385,7 +385,11 @@ def get_calibrated_detector(
     # If the NXdetector in the file is not 1-D, we want to match the order of dims.
     # zip_pixel_offsets otherwise yields a vector with dimensions in the order given
     # by the x/y/z offsets.
-    offsets = snx.zip_pixel_offsets(da.coords).transpose(da.dims).copy()
+    offsets = snx.zip_pixel_offsets(da.coords)
+    # Get the dims in the order of the detector data array, but filter out dims that
+    # don't exist in the offsets (e.g. the detector data may have a 'time' dimension).
+    dims = [dim for dim in da.dims if dim in offsets.dims]
+    offsets = offsets.transpose(dims).copy()
     # We use the unit of the offsets as this is likely what the user expects.
     if transform.value.unit is not None and transform.value.unit != '':
         transform_value = transform.value.to(unit=offsets.unit)
@@ -399,7 +403,7 @@ def get_calibrated_detector(
 
 def assemble_detector_data(
     detector: EmptyDetector[RunType],
-    event_data: NeXusData[snx.NXdetector, RunType],
+    neutron_data: NeXusData[snx.NXdetector, RunType],
 ) -> RawDetector[RunType]:
     """
     Assemble a detector data array with event data.
@@ -410,14 +414,15 @@ def assemble_detector_data(
     ----------
     detector:
         Calibrated detector data array.
-    event_data:
-        Event data array.
+    neutron_data:
+        Neutron data array (events or histogram).
     """
-    grouped = nexus.group_event_data(
-        event_data=event_data, detector_number=detector.coords['detector_number']
-    )
+    if neutron_data.bins is not None:
+        neutron_data = nexus.group_event_data(
+            event_data=neutron_data, detector_number=detector.coords['detector_number']
+        )
     return RawDetector[RunType](
-        _add_variances(grouped)
+        _add_variances(neutron_data)
         .assign_coords(detector.coords)
         .assign_masks(detector.masks)
     )
@@ -504,6 +509,19 @@ def _drop(
     }
 
 
+class _EmptyField:
+    """Empty field that can replace a missing detector_number in NXdetector."""
+
+    def __init__(self, sizes: dict[str, int]):
+        self.attrs = {}
+        self.sizes = sizes.copy()
+        self.dims = tuple(sizes.keys())
+        self.shape = tuple(sizes.values())
+
+    def __getitem__(self, key: Any) -> sc.Variable:
+        return sc.zeros(dims=self.dims, shape=self.shape, unit=None, dtype='int32')
+
+
 class _StrippedDetector(snx.NXdetector):
     """Detector definition without large geometry or event data for ScippNexus.
 
@@ -513,8 +531,36 @@ class _StrippedDetector(snx.NXdetector):
     def __init__(
         self, attrs: dict[str, Any], children: dict[str, snx.Field | snx.Group]
     ):
-        children = _drop(children, (snx.NXoff_geometry, snx.NXevent_data))
-        children['data'] = children['detector_number']
+        if 'detector_number' in children:
+            data = children['detector_number']
+        else:
+            # We get the 'data' sizes before the NXdata is dropped
+            if 'data' not in children:
+                raise KeyError(
+                    "StrippedDetector: Cannot determine shape of the detector. "
+                    "No 'detector_number' was found, and the 'data' entry is missing."
+                )
+            if 'value' not in children['data']:
+                raise KeyError(
+                    "StrippedDetector: Cannot determine shape of the detector. "
+                    "The 'data' entry has no 'value'."
+                )
+            # We drop any time-related dimension from the data sizes, as they are not
+            # relevant for the detector geometry/shape.
+            data = _EmptyField(
+                sizes={
+                    dim: size
+                    for dim, size in children['data']['value'].sizes.items()
+                    if dim not in ('time', 'frame_time')
+                }
+            )
+
+        children = _drop(
+            children, (snx.NXoff_geometry, snx.NXevent_data, snx.NXdata, snx.NXlog)
+        )
+
+        children['data'] = data
+
         super().__init__(attrs=attrs, children=children)
 
 
@@ -528,7 +574,7 @@ class _DummyField:
         self.shape = (0,)
 
     def __getitem__(self, key: Any) -> sc.Variable:
-        return sc.empty(dims=self.dims, shape=self.shape, unit=None)
+        return sc.zeros(dims=self.dims, shape=self.shape, unit=None, dtype='int32')
 
 
 class _StrippedMonitor(snx.NXmonitor):
@@ -645,16 +691,12 @@ def LoadMonitorWorkflow(
 
 
 def LoadDetectorWorkflow(
-    *,
-    run_types: Iterable[sciline.typing.Key],
-    monitor_types: Iterable[sciline.typing.Key],
+    *, run_types: Iterable[sciline.typing.Key]
 ) -> sciline.Pipeline:
     """Generic workflow for loading detector data from a NeXus file."""
     wf = sciline.Pipeline(
         (*_common_providers, *_detector_providers),
-        constraints=_gather_constraints(
-            run_types=run_types, monitor_types=monitor_types
-        ),
+        constraints=_gather_constraints(run_types=run_types, monitor_types=[]),
     )
     wf[DetectorBankSizes] = DetectorBankSizes({})
     wf[PreopenNeXusFile] = PreopenNeXusFile(False)

{essreduce-25.11.0 → essreduce-25.11.2}/src/ess/reduce/time_of_flight/__init__.py

@@ -28,6 +28,7 @@ from .types import (
     PulseStrideOffset,
     TimeOfFlightLookupTable,
     TimeOfFlightLookupTableFilename,
+    ToaDetector,
     TofDetector,
     TofMonitor,
 )
@@ -51,6 +52,7 @@ __all__ = [
     "TimeOfFlightLookupTable",
     "TimeOfFlightLookupTableFilename",
     "TimeResolution",
+    "ToaDetector",
     "TofDetector",
     "TofLookupTableWorkflow",
     "TofMonitor",

{essreduce-25.11.0 → essreduce-25.11.2}/src/ess/reduce/time_of_flight/eto_to_tof.py

@@ -36,6 +36,7 @@ from .types import (
     MonitorLtotal,
     PulseStrideOffset,
     TimeOfFlightLookupTable,
+    ToaDetector,
     TofDetector,
     TofMonitor,
 )
@@ -196,12 +197,32 @@ def _guess_pulse_stride_offset(
     return sorted(tofs, key=lambda x: sc.isnan(tofs[x]).sum())[0]
 
 
-def _time_of_flight_data_events(
+def _prepare_tof_interpolation_inputs(
     da: sc.DataArray,
     lookup: sc.DataArray,
     ltotal: sc.Variable,
-    pulse_stride_offset: int,
-) -> sc.DataArray:
+    pulse_stride_offset: int | None,
+) -> dict:
+    """
+    Prepare the inputs required for the time-of-flight interpolation.
+    This function is used when computing the time-of-flight for event data, and for
+    computing the time-of-arrival for event data (as they both require guessing the
+    pulse_stride_offset if not provided).
+
+    Parameters
+    ----------
+    da:
+        Data array with event 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 detector.
+    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 None, a guess is made.
+    """
     etos = da.bins.coords["event_time_offset"].to(dtype=float, copy=False)
     eto_unit = elem_unit(etos)
 
@@ -259,12 +280,34 @@ def _time_of_flight_data_events(
         pulse_index += pulse_stride_offset
         pulse_index %= pulse_stride
 
-    # Compute time-of-flight for all neutrons using the interpolator
-    tofs = interp(
+    return {
+        "eto": etos,
+        "pulse_index": pulse_index,
+        "pulse_period": pulse_period,
+        "interp": interp,
+        "ltotal": ltotal,
+    }
+
+
+def _time_of_flight_data_events(
+    da: sc.DataArray,
+    lookup: sc.DataArray,
+    ltotal: sc.Variable,
+    pulse_stride_offset: int | None,
+) -> sc.DataArray:
+    inputs = _prepare_tof_interpolation_inputs(
+        da=da,
+        lookup=lookup,
         ltotal=ltotal,
-        event_time_offset=etos,
-        pulse_index=pulse_index,
-        pulse_period=pulse_period,
+        pulse_stride_offset=pulse_stride_offset,
+    )
+
+    # Compute time-of-flight for all neutrons using the interpolator
+    tofs = inputs["interp"](
+        ltotal=inputs["ltotal"],
+        event_time_offset=inputs["eto"],
+        pulse_index=inputs["pulse_index"],
+        pulse_period=inputs["pulse_period"],
     )
 
     parts = da.bins.constituents
@@ -416,6 +459,53 @@ def monitor_time_of_flight_data(
     )
 
 
+def detector_time_of_arrival_data(
+    detector_data: RawDetector[RunType],
+    lookup: TimeOfFlightLookupTable,
+    ltotal: DetectorLtotal[RunType],
+    pulse_stride_offset: PulseStrideOffset,
+) -> ToaDetector[RunType]:
+    """
+    Convert the time-of-flight data to time-of-arrival data using a lookup table.
+    The output data will have a time-of-arrival coordinate.
+    The time-of-arrival is the time since the neutron was emitted from the source.
+    It is basically equal to event_time_offset + pulse_index * pulse_period.
+
+    Parameters
+    ----------
+    da:
+        Raw detector data loaded from a NeXus file, e.g., NXdetector 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 detector.
+    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 detector_data.bins is None:
+        raise NotImplementedError(
+            "Computing time-of-arrival in histogram mode is not implemented yet."
+        )
+    inputs = _prepare_tof_interpolation_inputs(
+        da=detector_data,
+        lookup=lookup,
+        ltotal=ltotal,
+        pulse_stride_offset=pulse_stride_offset,
+    )
+    parts = detector_data.bins.constituents
+    parts["data"] = inputs["eto"]
+    # The pulse index is None if pulse_stride == 1 (i.e., no pulse skipping)
+    if inputs["pulse_index"] is not None:
+        parts["data"] = parts["data"] + inputs["pulse_index"] * inputs["pulse_period"]
+    result = detector_data.bins.assign_coords(
+        toa=sc.bins(**parts, validate_indices=False)
+    )
+    return result
+
+
 def providers() -> tuple[Callable]:
     """
     Providers of the time-of-flight workflow.
@@ -425,4 +515,5 @@ def providers() -> tuple[Callable]:
         monitor_time_of_flight_data,
         detector_ltotal_from_straight_line_approximation,
         monitor_ltotal_from_straight_line_approximation,
+        detector_time_of_arrival_data,
     )

{essreduce-25.11.0 → essreduce-25.11.2}/src/ess/reduce/time_of_flight/fakes.py

@@ -56,7 +56,7 @@ class FakeBeamline:
                 else tof_pkg.Clockwise,
                 open=ch.slit_begin,
                 close=ch.slit_end,
-                phase=abs(ch.phase),
+                phase=ch.phase if ch.frequency.value > 0.0 else -ch.phase,
                 distance=sc.norm(ch.axle_position - source_position),
                 name=name,
             )

{essreduce-25.11.0 → essreduce-25.11.2}/src/ess/reduce/time_of_flight/lut.py

@@ -420,7 +420,7 @@ def simulate_chopper_cascade_using_tof(
             else tof.Clockwise,
             open=ch.slit_begin,
             close=ch.slit_end,
-            phase=abs(ch.phase),
+            phase=ch.phase if ch.frequency.value > 0.0 else -ch.phase,
             distance=sc.norm(
                 ch.axle_position - source_position.to(unit=ch.axle_position.unit)
             ),

{essreduce-25.11.0 → essreduce-25.11.2}/src/ess/reduce/time_of_flight/types.py

@@ -37,5 +37,17 @@ class TofDetector(sl.Scope[RunType, sc.DataArray], sc.DataArray):
     """Detector data with time-of-flight coordinate."""
 
 
+class ToaDetector(sl.Scope[RunType, sc.DataArray], sc.DataArray):
+    """Detector data with time-of-arrival coordinate.
+
+    When the pulse stride is 1 (i.e., no pulse skipping), the time-of-arrival is the
+    same as the event_time_offset. When pulse skipping is used, the time-of-arrival is
+    the event_time_offset + pulse_offset * pulse_period.
+    This means that the time-of-arrival is basically the event_time_offset wrapped
+    over the frame period instead of the pulse period
+    (where frame_period = pulse_stride * pulse_period).
+    """
+
+
 class TofMonitor(sl.Scope[RunType, MonitorType, sc.DataArray], sc.DataArray):
     """Monitor data with time-of-flight coordinate."""

{essreduce-25.11.0 → essreduce-25.11.2}/src/essreduce.egg-info/PKG-INFO

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

{essreduce-25.11.0 → essreduce-25.11.2}/tests/conftest.py

@@ -63,9 +63,9 @@ def tbl_registry() -> Registry:
     return make_registry(
         'ess/tbl',
         files={
-            "857127_00000112_small.hdf": "md5:6f3059e0e5e111a2a8f1b368f24c6f93",
+            "857127_00000112_small.hdf": "md5:0db89493b859dbb2f7354c3711ed7fbd",
         },
-        version='1',
+        version='2',
     )
 
 

{essreduce-25.11.0 → essreduce-25.11.2}/tests/nexus/workflow_test.py

@@ -4,15 +4,17 @@ from datetime import UTC, datetime
 from pathlib import Path
 
 import pytest
+import sciline as sl
 import scipp as sc
 import scippnexus as snx
 from scipp.testing import assert_identical
 
-from ess.reduce.nexus import compute_component_position, workflow
+from ess.reduce.nexus import compute_component_position, load_from_path, workflow
 from ess.reduce.nexus.types import (
     BackgroundRun,
     Beamline,
     EmptyBeamRun,
+    EmptyDetector,
     Filename,
     FrameMonitor0,
     FrameMonitor1,
@@ -20,6 +22,8 @@ from ess.reduce.nexus.types import (
     Measurement,
     MonitorType,
     NeXusComponentLocationSpec,
+    NeXusFileSpec,
+    NeXusLocationSpec,
     NeXusName,
     NeXusTransformation,
     PreopenNeXusFile,
@@ -576,7 +580,7 @@ def test_load_histogram_monitor_workflow(dream_coda_test_file: Path) -> None:
 
 
 def test_load_detector_workflow(loki_tutorial_sample_run_60250: Path) -> None:
-    wf = LoadDetectorWorkflow(run_types=[SampleRun], monitor_types=[])
+    wf = LoadDetectorWorkflow(run_types=[SampleRun])
     wf[Filename[SampleRun]] = loki_tutorial_sample_run_60250
     wf[NeXusName[snx.NXdetector]] = 'larmor_detector'
     da = wf.compute(RawDetector[SampleRun])
@@ -585,6 +589,31 @@ def test_load_detector_workflow(loki_tutorial_sample_run_60250: Path) -> None:
     assert da.dims == ('detector_number',)
 
 
+def test_load_histogram_detector_workflow(tbl_commissioning_orca_file: Path) -> None:
+    wf = LoadDetectorWorkflow(run_types=[SampleRun])
+    wf[Filename[SampleRun]] = tbl_commissioning_orca_file
+    wf[NeXusName[snx.NXdetector]] = 'orca_detector'
+    da = wf.compute(RawDetector[SampleRun])
+    assert 'position' in da.coords
+    assert da.bins is None
+    assert 'time' in da.dims
+    assert da.ndim == 3
+
+
+def test_load_empty_histogram_detector_workflow(
+    tbl_commissioning_orca_file: Path,
+) -> None:
+    wf = LoadDetectorWorkflow(run_types=[SampleRun])
+    wf[Filename[SampleRun]] = tbl_commissioning_orca_file
+    wf[NeXusName[snx.NXdetector]] = 'orca_detector'
+    da = wf.compute(EmptyDetector[SampleRun])
+    assert 'position' in da.coords
+    assert da.bins is None
+    # The empty detector has no time dimension, only the dimensions of the geometry
+    assert 'time' not in da.dims
+    assert da.ndim == 2
+
+
 @pytest.mark.parametrize('preopen', [True, False])
 def test_generic_nexus_workflow(
     preopen: bool, loki_tutorial_sample_run_60250: Path
@@ -750,3 +779,48 @@ def assert_not_contains_type_arg(node: object, excluded: set[type]) -> None:
     assert not any(
         arg in excluded for arg in getattr(node, "__args__", ())
     ), f"Node {node} contains one of {excluded!r}"
+
+
+def test_generic_nexus_workflow_load_custom_field_user_affiliation(
+    loki_tutorial_sample_run_60250: Path,
+) -> None:
+    class UserAffiliation(sl.Scope[RunType, str], str):
+        """User affiliation."""
+
+    def load_user_affiliation(
+        file: NeXusFileSpec[RunType], path: NeXusName[UserAffiliation[RunType]]
+    ) -> UserAffiliation[RunType]:
+        return UserAffiliation[RunType](
+            load_from_path(NeXusLocationSpec(filename=file.value, component_name=path))
+        )
+
+    wf = GenericNeXusWorkflow(run_types=[SampleRun], monitor_types=[])
+    wf.insert(load_user_affiliation)
+    wf[Filename[SampleRun]] = loki_tutorial_sample_run_60250
+    # Path is relative to the top-level '/entry'
+    wf[NeXusName[UserAffiliation[SampleRun]]] = 'user_0/affiliation'
+    affiliation = wf.compute(UserAffiliation[SampleRun])
+    assert affiliation == 'ESS'
+
+
+def test_generic_nexus_workflow_load_custom_group_user(
+    loki_tutorial_sample_run_60250: Path,
+) -> None:
+    class UserInfo(sl.Scope[RunType, str], str):
+        """User info."""
+
+    def load_user_info(
+        file: NeXusFileSpec[RunType], path: NeXusName[UserInfo[RunType]]
+    ) -> UserInfo[RunType]:
+        return UserInfo[RunType](
+            load_from_path(NeXusLocationSpec(filename=file.value, component_name=path))
+        )
+
+    wf = GenericNeXusWorkflow(run_types=[SampleRun], monitor_types=[])
+    wf.insert(load_user_info)
+    wf[Filename[SampleRun]] = loki_tutorial_sample_run_60250
+    # Path is relative to the top-level '/entry'
+    wf[NeXusName[UserInfo]] = 'user_0'
+    user_info = wf.compute(UserInfo[SampleRun])
+    assert user_info['affiliation'] == 'ESS'
+    assert user_info['name'] == 'John Doe'

{essreduce-25.11.0 → essreduce-25.11.2}/tests/time_of_flight/unwrap_test.py

@@ -9,7 +9,12 @@ from scippneutron.conversion.graph.tof import elastic as elastic_graph
 
 from ess.reduce import time_of_flight
 from ess.reduce.nexus.types import AnyRun, RawDetector, SampleRun
-from ess.reduce.time_of_flight import GenericTofWorkflow, TofLookupTableWorkflow, fakes
+from ess.reduce.time_of_flight import (
+    GenericTofWorkflow,
+    PulsePeriod,
+    TofLookupTableWorkflow,
+    fakes,
+)
 
 sl = pytest.importorskip("sciline")
 
@@ -441,3 +446,63 @@ def test_unwrap_int(dtype, lut_workflow_psc_choppers) -> None:
     _validate_result_events(
         tofs=tofs, ref=ref, percentile=100, diff_threshold=0.02, rtol=0.05
     )
+
+
+def test_compute_toa():
+    distance = sc.scalar(80.0, unit="m")
+    choppers = fakes.psc_choppers()
+
+    lut_wf = make_lut_workflow(
+        choppers=choppers, neutrons=500_000, seed=1234, pulse_stride=1
+    )
+
+    pl, _ = _make_workflow_event_mode(
+        distance=distance,
+        choppers=choppers,
+        lut_workflow=lut_wf,
+        seed=2,
+        pulse_stride_offset=0,
+        error_threshold=0.1,
+    )
+
+    toas = pl.compute(time_of_flight.ToaDetector[SampleRun])
+
+    assert "toa" in toas.bins.coords
+    raw = pl.compute(RawDetector[SampleRun])
+    assert sc.allclose(toas.bins.coords["toa"], raw.bins.coords["event_time_offset"])
+
+
+def test_compute_toa_pulse_skipping():
+    distance = sc.scalar(100.0, unit="m")
+    choppers = fakes.pulse_skipping_choppers()
+
+    lut_wf = make_lut_workflow(
+        choppers=choppers, neutrons=500_000, seed=1234, pulse_stride=2
+    )
+
+    pl, _ = _make_workflow_event_mode(
+        distance=distance,
+        choppers=choppers,
+        lut_workflow=lut_wf,
+        seed=2,
+        pulse_stride_offset=1,
+        error_threshold=0.1,
+    )
+
+    raw = pl.compute(RawDetector[SampleRun])
+
+    toas = pl.compute(time_of_flight.ToaDetector[SampleRun])
+
+    assert "toa" in toas.bins.coords
+    pulse_period = lut_wf.compute(PulsePeriod)
+    hist = toas.bins.concat().hist(
+        toa=sc.array(
+            dims=["toa"],
+            values=[0, pulse_period.value, pulse_period.value * 2],
+            unit=pulse_period.unit,
+        ).to(unit=toas.bins.coords["toa"].unit)
+    )
+    # There should be counts in both bins
+    n = raw.sum().value
+    assert hist.data[0].value > n / 5
+    assert hist.data[1].value > n / 5