essreduce 25.12.0__tar.gz → 25.12.1__tar.gz

{essreduce-25.12.0 → essreduce-25.12.1}/PKG-INFO

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

{essreduce-25.12.0 → essreduce-25.12.1}/src/ess/reduce/nexus/workflow.py

@@ -370,6 +370,8 @@ def get_calibrated_detector(
     ----------
     detector:
         NeXus detector group.
+    transform:
+        Transformation matrix for the detector.
     offset:
         Offset to add to the detector position.
     bank_sizes:
@@ -430,8 +432,8 @@ def assemble_detector_data(
 
 def get_calibrated_monitor(
     monitor: NeXusComponent[MonitorType, RunType],
+    transform: NeXusTransformation[MonitorType, RunType],
     offset: MonitorPositionOffset[RunType, MonitorType],
-    source_position: Position[snx.NXsource, RunType],
 ) -> EmptyMonitor[RunType, MonitorType]:
     """
     Extract the data array corresponding to a monitor's signal field.
@@ -443,16 +445,16 @@ def get_calibrated_monitor(
     ----------
     monitor:
         NeXus monitor group.
+    transform:
+        Transformation matrix for the monitor.
     offset:
         Offset to add to the monitor position.
-    source_position:
-        Position of the neutron source.
     """
-    monitor = nexus.compute_component_position(monitor)
+    transform_unit = transform.value.unit
     return EmptyMonitor[RunType, MonitorType](
         nexus.extract_signal_data_array(monitor).assign_coords(
-            position=monitor['position'] + offset.to(unit=monitor['position'].unit),
-            source_position=source_position,
+            position=transform.value * sc.vector([0, 0, 0], unit=transform_unit)
+            + offset.to(unit=transform_unit),
         )
     )
 

{essreduce-25.12.0 → essreduce-25.12.1}/src/ess/reduce/normalization.py

@@ -2,7 +2,11 @@
 # Copyright (c) 2025 Scipp contributors (https://github.com/scipp)
 """Normalization routines for neutron data reduction."""
 
+from __future__ import annotations
+
+import enum
 import functools
+import warnings
 
 import scipp as sc
 
@@ -14,6 +18,7 @@ def normalize_by_monitor_histogram(
     *,
     monitor: sc.DataArray,
     uncertainty_broadcast_mode: UncertaintyBroadcastMode,
+    skip_range_check: bool = False,
 ) -> sc.DataArray:
     """Normalize detector data by a normalized histogrammed monitor.
 
@@ -23,10 +28,13 @@ def normalize_by_monitor_histogram(
     - For *event* detectors, the monitor values are mapped to the detector
       using :func:`scipp.lookup`. That is, for detector event :math:`d_i`,
       :math:`m_i` is the monitor bin value at the same coordinate.
-    - For *histogram* detectors, the monitor is rebinned using to the detector
+    - For *histogram* detectors, the monitor is generally rebinned using the detector
       binning using :func:`scipp.rebin`. Thus, detector value :math:`d_i` and
       monitor value :math:`m_i` correspond to the same bin.
 
+        - In case the detector coordinate does not have a dimension in common with the
+          monitor, :func:`scipp.lookup` is used as in the event case.
+
     In both cases, let :math:`x_i` be the lower bound of monitor bin :math:`i`
     and let :math:`\\Delta x_i = x_{i+1} - x_i` be the width of that bin.
 
@@ -47,6 +55,16 @@ def normalize_by_monitor_histogram(
         Must be one-dimensional and have a dimension coordinate, typically "wavelength".
     uncertainty_broadcast_mode:
         Choose how uncertainties of the monitor are broadcast to the sample data.
+    skip_range_check:
+        If false (default), the detector data must be within the range of the monitor
+        coordinate. Set this to true to disable the check.
+        The value of out-of-range bins / events is undefined in that case.
+
+        This is useful when the detector contains data outside the monitor range, and it
+        is difficult or impossible to slice the detector without also removing in-range
+        data. In this case, the caller can mask those data points and skip the range
+        check. ``normalize_by_monitor_histogram`` does not take masks into account when
+        checking ranges as that is expensive to implement in a general case.
 
     Returns
     -------
@@ -60,22 +78,45 @@ def normalize_by_monitor_histogram(
     normalize_by_monitor_integrated:
         Normalize by an integrated monitor.
     """
-    _check_monitor_range_contains_detector(monitor=monitor, detector=detector)
+    if not skip_range_check:
+        _check_monitor_range_contains_detector(monitor=monitor, detector=detector)
 
     dim = monitor.dim
 
-    if detector.bins is None:
-        monitor = monitor.rebin({dim: detector.coords[dim]})
-    detector = _mask_detector_for_norm(detector=detector, monitor=monitor)
-    coord = monitor.coords[dim]
-    delta_w = sc.DataArray(coord[1:] - coord[:-1], masks=monitor.masks)
-    norm = broadcast_uncertainties(
-        monitor / delta_w, prototype=detector, mode=uncertainty_broadcast_mode
-    )
-
-    if detector.bins is None:
-        return detector / norm.rebin({dim: detector.coords[dim]})
-    return detector.bins / sc.lookup(norm, dim=dim)
+    match _HistogramNormalizationMode.deduce(detector, dim):
+        case _HistogramNormalizationMode.Events:
+            detector = _mask_detector_for_norm(detector=detector, monitor=monitor)
+            norm = _histogram_monitor_term(
+                monitor,
+                dim,
+                broadcast_to=detector,
+                uncertainty_broadcast_mode=uncertainty_broadcast_mode,
+            )
+            if dim in detector.bins.coords:
+                return detector.bins / sc.lookup(norm, dim=dim)
+            else:
+                return detector / norm
+
+        case _HistogramNormalizationMode.BinsCommonDim:
+            monitor = monitor.rebin({dim: detector.coords[dim]})
+            detector = _mask_detector_for_norm(detector=detector, monitor=monitor)
+            norm = _histogram_monitor_term(
+                monitor,
+                dim,
+                broadcast_to=detector,
+                uncertainty_broadcast_mode=uncertainty_broadcast_mode,
+            )
+            return detector / norm
+
+        case _HistogramNormalizationMode.BinsDifferentDim:
+            detector = _mask_detector_for_norm(detector=detector, monitor=monitor)
+            # No broadcast here because there are no common dims, use lookup instead.
+            norm = _histogram_monitor_term(
+                monitor,
+                dim,
+                uncertainty_broadcast_mode=uncertainty_broadcast_mode,
+            )
+            return detector / sc.lookup(norm)[_compute_bin_centers(detector, dim)]
 
 
 def normalize_by_monitor_integrated(
@@ -83,6 +124,7 @@ def normalize_by_monitor_integrated(
     *,
     monitor: sc.DataArray,
     uncertainty_broadcast_mode: UncertaintyBroadcastMode,
+    skip_range_check: bool = False,
 ) -> sc.DataArray:
     """Normalize detector data by an integrated monitor.
 
@@ -113,6 +155,16 @@ def normalize_by_monitor_integrated(
         Must be one-dimensional and have a dimension coordinate, typically "wavelength".
     uncertainty_broadcast_mode:
         Choose how uncertainties of the monitor are broadcast to the sample data.
+    skip_range_check:
+        If false (default), the detector data must be within the range of the monitor
+        coordinate. Set this to true to disable the check.
+        The value of out-of-range bins / events is undefined in that case.
+
+        This is useful when the detector contains data outside the monitor range, and it
+        is difficult or impossible to slice the detector without also removing in-range
+        data. In this case, the caller can mask those data points and skip the range
+        check. ``normalize_by_monitor_histogram`` does not take masks into account when
+        checking ranges as that is expensive to implement in a general case.
 
     Returns
     -------
@@ -126,7 +178,8 @@ def normalize_by_monitor_integrated(
     normalize_by_monitor_histogram:
         Normalize by a monitor histogram.
     """
-    _check_monitor_range_contains_detector(monitor=monitor, detector=detector)
+    if not skip_range_check:
+        _check_monitor_range_contains_detector(monitor=monitor, detector=detector)
     detector = _mask_detector_for_norm(detector=detector, monitor=monitor)
     norm = monitor.nansum().data
     norm = broadcast_uncertainties(
@@ -149,15 +202,15 @@ def _check_monitor_range_contains_detector(
     # monitor range that is less than the detector bins which is fine for the events,
     # but would be wrong if the detector was subsequently histogrammed.
     if (det_coord := detector.coords.get(dim)) is not None:
-        lo = det_coord[dim, :-1].nanmin()
-        hi = det_coord[dim, 1:].nanmax()
+        ...
     elif (det_coord := detector.bins.coords.get(dim)) is not None:
-        lo = det_coord.nanmin()
-        hi = det_coord.nanmax()
+        ...
     else:
         raise sc.CoordError(
             f"Missing '{dim}' coordinate in detector for monitor normalization."
         )
+    lo = det_coord.nanmin()
+    hi = det_coord.nanmax()
 
     if monitor.coords[dim].min() > lo or monitor.coords[dim].max() < hi:
         raise ValueError(
@@ -181,13 +234,17 @@ def _mask_detector_for_norm(
     if (monitor_mask := _monitor_mask(monitor)) is None:
         return detector
 
-    if (detector_coord := detector.coords.get(monitor.dim)) is not None:
+    if (detector_coord := detector.coords.get(dim)) is not None:
         # Apply the mask to the bins or a dense detector.
-        # Use rebin to reshape the mask to the detector.
-        mask = sc.DataArray(monitor_mask, coords={dim: monitor.coords[dim]}).rebin(
-            {dim: detector_coord}
-        ).data != sc.scalar(0, unit=None)
-        return detector.assign_masks({"_monitor_mask": mask})
+        mask_da = sc.DataArray(monitor_mask, coords={dim: monitor.coords[dim]})
+        if dim in detector_coord.dims:
+            # Use rebin to reshape the mask to the detector.
+            mask = mask_da.rebin({dim: detector_coord}).data != sc.scalar(0, unit=None)
+            return detector.assign_masks(_monitor_mask=mask)
+        # else: need to use lookup to apply mask at matching coord elements
+        return detector.assign_masks(
+            _monitor_mask=sc.lookup(mask_da)[_compute_bin_centers(detector, dim)]
+        )
 
     # else: Apply the mask to the events.
     if dim not in detector.bins.coords:
@@ -197,7 +254,7 @@ def _mask_detector_for_norm(
     event_mask = sc.lookup(
         sc.DataArray(monitor_mask, coords={dim: monitor.coords[dim]})
     )[detector.bins.coords[dim]]
-    return detector.bins.assign_masks({"_monitor_mask": event_mask})
+    return detector.bins.assign_masks(_monitor_mask=event_mask)
 
 
 def _monitor_mask(monitor: sc.DataArray) -> sc.Variable | None:
@@ -213,3 +270,74 @@ def _monitor_mask(monitor: sc.DataArray) -> sc.Variable | None:
     if not masks:
         return None
     return functools.reduce(sc.logical_or, masks)
+
+
+def _histogram_monitor_term(
+    monitor: sc.DataArray,
+    dim: str,
+    *,
+    broadcast_to: sc.DataArray | None = None,
+    uncertainty_broadcast_mode: UncertaintyBroadcastMode,
+) -> sc.DataArray:
+    if not monitor.coords.is_edges(dim, dim):
+        raise sc.CoordError(
+            f"Monitor coordinage {dim} must be bin-edges for normalization."
+        )
+    coord = monitor.coords[dim]
+    delta_w = sc.DataArray(coord[1:] - coord[:-1], masks=monitor.masks)
+    norm = monitor / delta_w
+
+    if broadcast_to is not None:
+        return broadcast_uncertainties(
+            norm, prototype=broadcast_to, mode=uncertainty_broadcast_mode
+        )
+
+    match uncertainty_broadcast_mode:
+        case UncertaintyBroadcastMode.fail:
+            return norm
+        case UncertaintyBroadcastMode.drop:
+            return sc.values(norm)
+        case _:
+            warnings.warn(
+                "Cannot broadcast uncertainties in this case.",
+                UserWarning,
+                stacklevel=3,
+            )
+            return norm
+
+
+class _HistogramNormalizationMode(enum.Enum):
+    Events = enum.auto()
+    """Use an event coordinate to lookup monitor values."""
+    BinsCommonDim = enum.auto()
+    """Use a bin coordinate which contains the monitor dimension.
+
+    The coordinate may be multi-dimensional but one dimension matches
+    the dimension of the monitor.
+    """
+    BinsDifferentDim = enum.auto()
+    """Use a bin coordinate which does not contain the monitor dimension.
+
+    The coordinate may be multi-dimensions, e.g., in the DREAM powder workflow
+    where it has dims (two_theta, dspacing [bin-edges]).
+    """
+
+    @classmethod
+    def deduce(cls, detector: sc.DataArray, dim: str) -> _HistogramNormalizationMode:
+        # Use an event-coord when available:
+        if detector.bins is not None and dim in detector.bins.coords:
+            return _HistogramNormalizationMode.Events
+        # else: use a bin-coord.
+
+        det_coord = detector.coords[dim]
+        if dim in det_coord.dims:
+            return _HistogramNormalizationMode.BinsCommonDim
+        return _HistogramNormalizationMode.BinsDifferentDim
+
+
+def _compute_bin_centers(da: sc.DataArray, name: str) -> sc.Variable:
+    coord = da.coords[name]
+    for dim in coord.dims:
+        if da.coords.is_edges(name, dim):
+            coord = sc.midpoints(coord, dim=dim)
+    return coord

{essreduce-25.12.0 → essreduce-25.12.1}/src/ess/reduce/time_of_flight/eto_to_tof.py

@@ -317,7 +317,19 @@ def _time_of_flight_data_events(
     parts = da.bins.constituents
     parts["data"] = tofs
     result = da.bins.assign_coords(tof=sc.bins(**parts, validate_indices=False))
-    return result.bins.drop_coords("event_time_offset")
+    out = result.bins.drop_coords("event_time_offset")
+
+    # The result may still have an 'event_time_zero' dimension (in the case of an
+    # event monitor where events were not grouped by pixel).
+    if "event_time_zero" in out.dims:
+        if ("event_time_zero" in out.coords) and (
+            "event_time_zero" not in out.bins.coords
+        ):
+            out.bins.coords["event_time_zero"] = sc.bins_like(
+                out, out.coords["event_time_zero"]
+            )
+        out = out.bins.concat("event_time_zero")
+    return out
 
 
 def detector_ltotal_from_straight_line_approximation(
@@ -357,6 +369,7 @@ def detector_ltotal_from_straight_line_approximation(
 
 def monitor_ltotal_from_straight_line_approximation(
     monitor_beamline: EmptyMonitor[RunType, MonitorType],
+    source_position: Position[snx.NXsource, RunType],
 ) -> MonitorLtotal[RunType, MonitorType]:
     """
     Compute Ltotal for the monitor.
@@ -369,7 +382,10 @@ def monitor_ltotal_from_straight_line_approximation(
         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)
+    graph = {
+        **scn.conversion.graph.beamline.beamline(scatter=False),
+        'source_position': lambda: source_position,
+    }
     return MonitorLtotal[RunType, MonitorType](
         monitor_beamline.transform_coords(
             "Ltotal", graph=graph, keep_intermediate=False

{essreduce-25.12.0 → essreduce-25.12.1}/src/essreduce.egg-info/PKG-INFO

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

{essreduce-25.12.0 → essreduce-25.12.1}/tests/nexus/workflow_test.py

@@ -336,6 +336,79 @@ def test_get_calibrated_detector_forwards_masks(
     assert 'mymask' in detector.masks
 
 
+def test_get_calibrated_detector_with_time_dependent_transformation(
+    time_dependent_depends_on: snx.TransformationChain,
+) -> None:
+    """Test that get_calibrated_detector works with time-dependent transformations.
+
+    This test verifies that when a transformation is time-dependent and resolved
+    to a specific time interval, the detector positions are correctly computed
+    using the transformation value at that time.
+    """
+    # Create a simple detector with pixel offsets
+    detector_number = sc.arange('detector_number', 4, unit=None)
+    data = sc.DataArray(
+        sc.empty_like(detector_number),
+        coords={
+            'detector_number': detector_number,
+            'x_pixel_offset': sc.array(
+                dims=['detector_number'], values=[0.0, 0.1, 0.2, 0.3], unit='m'
+            ),
+            'y_pixel_offset': sc.zeros(dims=['detector_number'], shape=[4], unit='m'),
+            'z_pixel_offset': sc.zeros(dims=['detector_number'], shape=[4], unit='m'),
+        },
+    )
+    nexus_detector = workflow.NeXusComponent[snx.NXdetector, SampleRun](
+        sc.DataGroup(
+            data=data,
+            depends_on=time_dependent_depends_on,
+            nexus_component_name='detector1',
+        )
+    )
+
+    # Resolve the time-dependent transformation to a specific time interval
+    # Using the middle time bin (time index 1): translation of (1, 2, 0) m
+    transform = workflow.to_transformation(
+        time_dependent_depends_on,
+        TimeInterval(slice(1, 2)),
+    )
+
+    # Get the calibrated detector
+    detector = workflow.get_calibrated_detector(
+        nexus_detector, offset=workflow.no_offset, bank_sizes={}, transform=transform
+    )
+
+    # Verify the detector has the correct structure
+    assert detector.sizes == {'detector_number': 4}
+    assert 'position' in detector.coords
+    assert detector.coords['position'].sizes == {'detector_number': 4}
+
+    # Verify the positions are correctly computed
+    # The transformation: translate (1, 0, 0) then translate (0, 2, 0)
+    # Combined with pixel offsets in x: [0.0, 0.1, 0.2, 0.3]
+    # Expected positions:
+    # [(1.0, 2.0, 0.0), (1.1, 2.0, 0.0), (1.2, 2.0, 0.0), (1.3, 2.0, 0.0)]
+    expected_x = sc.array(
+        dims=['detector_number'], values=[1.0, 1.1, 1.2, 1.3], unit='m'
+    )
+    expected_y = sc.array(
+        dims=['detector_number'], values=[2.0, 2.0, 2.0, 2.0], unit='m'
+    )
+    expected_z = sc.array(
+        dims=['detector_number'], values=[0.0, 0.0, 0.0, 0.0], unit='m'
+    )
+
+    assert sc.allclose(
+        detector.coords['position'].fields.x, expected_x, rtol=sc.scalar(1e-10)
+    )
+    assert sc.allclose(
+        detector.coords['position'].fields.y, expected_y, rtol=sc.scalar(1e-10)
+    )
+    assert sc.allclose(
+        detector.coords['position'].fields.z, expected_z, rtol=sc.scalar(1e-10)
+    )
+
+
 @pytest.fixture
 def calibrated_detector() -> workflow.EmptyDetector[SampleRun]:
     detector_number = sc.arange('detector_number', 6, unit=None)
@@ -429,10 +502,12 @@ def test_get_calibrated_monitor_extracts_data_field_from_nexus_monitor(
     monitor = workflow.get_calibrated_monitor(
         nexus_monitor,
         offset=workflow.no_offset,
-        source_position=sc.vector([0.0, 0.0, -10.0], unit='m'),
+        transform=NeXusTransformation.from_chain(
+            workflow.get_transformation_chain(nexus_monitor),
+        ),
     )
     assert_identical(
-        monitor.drop_coords(('position', 'source_position')),
+        monitor.drop_coords('position'),
         compute_component_position(nexus_monitor)['data'],
     )
 
@@ -444,11 +519,52 @@ def test_get_calibrated_monitor_subtracts_offset_from_position(
     monitor = workflow.get_calibrated_monitor(
         nexus_monitor,
         offset=offset,
-        source_position=sc.vector([0.0, 0.0, -10.0], unit='m'),
+        transform=NeXusTransformation.from_chain(
+            workflow.get_transformation_chain(nexus_monitor),
+        ),
     )
     assert_identical(monitor.coords['position'], sc.vector([1.1, 2.2, 3.3], unit='m'))
 
 
+def test_get_calibrated_monitor_with_time_dependent_transformation(
+    time_dependent_depends_on: snx.TransformationChain,
+) -> None:
+    """Test that get_calibrated_monitor works with time-dependent transformations.
+
+    This test verifies that when a transformation is time-dependent and resolved
+    to a specific time interval, the monitor position is correctly computed using
+    the transformation value at that time.
+    """
+    # Create a simple monitor
+    data = sc.DataArray(sc.scalar(1.2), coords={'something': sc.scalar(13)})
+    nexus_monitor = workflow.NeXusComponent[FrameMonitor1, SampleRun](
+        sc.DataGroup(data=data, depends_on=time_dependent_depends_on)
+    )
+
+    # Resolve the time-dependent transformation to a specific time interval
+    # Using the middle time bin (time index 1): translation of (1, 2, 0) m
+    transform = workflow.to_transformation(
+        time_dependent_depends_on,
+        TimeInterval(slice(1, 2)),
+    )
+
+    # Get the calibrated monitor
+    monitor = workflow.get_calibrated_monitor(
+        nexus_monitor, transform=transform, offset=workflow.no_offset
+    )
+
+    # Verify the monitor has the correct structure
+    assert 'position' in monitor.coords
+
+    # Verify the position is correctly computed
+    # The transformation: translate (1, 0, 0) then translate (0, 2, 0)
+    # Applied to origin gives position (1, 2, 0)
+    expected_position = sc.vector([1.0, 2.0, 0.0], unit='m')
+    assert sc.allclose(
+        monitor.coords['position'], expected_position, rtol=sc.scalar(1e-10)
+    )
+
+
 @pytest.fixture
 def calibrated_monitor() -> workflow.EmptyMonitor[SampleRun, FrameMonitor1]:
     return workflow.EmptyMonitor[SampleRun, FrameMonitor1](
@@ -559,7 +675,6 @@ def test_load_event_monitor_workflow(loki_tutorial_sample_run_60250: Path) -> No
     wf[NeXusName[FrameMonitor1]] = 'monitor_1'
     da = wf.compute(RawMonitor[SampleRun, FrameMonitor1])
     assert 'position' in da.coords
-    assert 'source_position' in da.coords
     assert da.bins is not None
     assert da.dims == ('event_time_zero',)
     assert da.bins.constituents['data'].variances is not None
@@ -571,7 +686,6 @@ def test_load_histogram_monitor_workflow(dream_coda_test_file: Path) -> None:
     wf[NeXusName[FrameMonitor1]] = 'monitor_bunker'
     da = wf.compute(RawMonitor[SampleRun, FrameMonitor1])
     assert 'position' in da.coords
-    assert 'source_position' in da.coords
     assert da.bins is None
     assert set(da.dims) == {'time', 'frame_time'}
     assert 'time' in da.coords.keys()
@@ -629,7 +743,6 @@ def test_generic_nexus_workflow(
     assert da.dims == ('detector_number',)
     da = wf.compute(RawMonitor[SampleRun, FrameMonitor1])
     assert 'position' in da.coords
-    assert 'source_position' in da.coords
     assert da.bins is not None
     assert da.dims == ('event_time_zero',)
 

{essreduce-25.12.0 → essreduce-25.12.1}/tests/normalization_test.py

@@ -41,6 +41,7 @@ class TestNormalizeByMonitorHistogram:
             sc.array(dims=['w'], values=[0, 10, 30], unit='counts'),
             coords={'w': sc.arange('w', 3.0, unit='Å')},
         ).bin(w=sc.array(dims=['w'], values=[0.0, 2, 3], unit='Å'))
+        del detector.bins.coords['w']
         monitor = sc.DataArray(
             sc.array(dims=['w'], values=[5.0, 6.0], unit='counts'),
             coords={'w': sc.array(dims=['w'], values=[0.0, 2, 3], unit='Å')},
@@ -55,6 +56,7 @@ class TestNormalizeByMonitorHistogram:
             sc.array(dims=['w'], values=[0.0, 4, 5], unit='counts'),
             coords={'w': sc.arange('w', 3.0, unit='Å')},
         ).bin(w=sc.array(dims=['w'], values=[0.0, 2, 3], unit='Å'))
+        del expected.bins.coords['w']
 
         sc.testing.assert_identical(normalized, expected)
 
@@ -565,6 +567,47 @@ class TestNormalizeByMonitorHistogram:
 
         sc.testing.assert_allclose(normalized, expected)
 
+    def test_different_dims_dense(self) -> None:
+        detector = sc.DataArray(
+            sc.array(  # sizes={'x': 3, 'y': 2}
+                dims=['x', 'y'], values=[[11.0, 10], [9, 8], [7, 6]], unit='counts'
+            ),
+            coords={
+                'x': sc.array(dims=['x'], values=[0.0, 1, 2, 3], unit='m'),
+                'y': sc.array(dims=['y'], values=[-5, -1, 4], unit='kg'),
+                'w': sc.array(  # bin edges in x
+                    dims=['x', 'y'], values=[[1.0, 2], [2, 3], [4, 5], [5, 3]], unit='Å'
+                ),
+            },
+        )
+        monitor = sc.DataArray(
+            sc.array(dims=['w'], values=[3.0, 5, 7], unit='counts'),
+            coords={'w': sc.array(dims=['w'], values=[0.0, 2, 4, 6], unit='Å')},
+            masks={'M': sc.array(dims=['w'], values=[False, True, False])},
+        )
+        normalized = normalize_by_monitor_histogram(
+            detector,
+            monitor=monitor,
+            uncertainty_broadcast_mode=UncertaintyBroadcastMode.fail,
+        )
+
+        expected = sc.DataArray(
+            sc.array(
+                dims=['x', 'y'],
+                values=[[22 / 3, np.nan], [np.nan, 16 / 7], [2.0, 12 / 7]],
+                unit='counts',
+            ),
+            coords=detector.coords,
+            masks={
+                '_monitor_mask': sc.array(
+                    dims=['x', 'y'],
+                    values=[[False, True], [True, False], [False, False]],
+                ),
+            },
+        )
+
+        sc.testing.assert_allclose(normalized, expected)
+
     def test_independent_of_monitor_binning_bin(self) -> None:
         detector = sc.DataArray(
             sc.array(dims=['w'], values=[3, 10, 20, 30], unit='counts'),

{essreduce-25.12.0 → essreduce-25.12.1}/tox.ini

@@ -26,8 +26,8 @@ commands = pytest {posargs}
 description = invoke sphinx-build to build the HTML docs
 deps = -r requirements/docs.txt
 allowlist_externals=find
-commands = python -m sphinx -j2 -v -b html -d {toxworkdir}/docs_doctrees docs html
-           python -m sphinx -j2 -v -b doctest -d {toxworkdir}/docs_doctrees docs html
+commands = python -m sphinx -v -b html -d {toxworkdir}/docs_doctrees docs html
+           python -m sphinx -v -b doctest -d {toxworkdir}/docs_doctrees docs html
            find html -type f -name "*.ipynb" -not -path "html/_sources/*" -delete
 
 [testenv:releasedocs]
@@ -42,7 +42,7 @@ commands = {[testenv:docs]commands}
 [testenv:linkcheck]
 description = Run Sphinx linkcheck
 deps = -r requirements/docs.txt
-commands = python -m sphinx -j2 -v -b linkcheck -d {toxworkdir}/docs_doctrees docs html
+commands = python -m sphinx -v -b linkcheck -d {toxworkdir}/docs_doctrees docs html
 
 [testenv:static]
 description = Code formatting and static analysis