essreduce 25.1.1__py3-none-any.whl → 25.2.1__py3-none-any.whl

ess/reduce/__init__.py

@@ -1,10 +1,10 @@
 # SPDX-License-Identifier: BSD-3-Clause
-# Copyright (c) 2024 Scipp contributors (https://github.com/scipp)
-# ruff: noqa: E402, F401
+# Copyright (c) 2025 Scipp contributors (https://github.com/scipp)
+# ruff: noqa: E402, F401, I
 
 import importlib.metadata
 
-from . import nexus, uncertainty, time_of_flight
+from . import nexus, time_of_flight, uncertainty
 
 try:
     __version__ = importlib.metadata.version("essreduce")
@@ -13,4 +13,4 @@ except importlib.metadata.PackageNotFoundError:
 
 del importlib
 
-__all__ = ["nexus", "uncertainty", "time_of_flight"]
+__all__ = ["nexus", "time_of_flight", "uncertainty"]

ess/reduce/live/raw.py

@@ -19,6 +19,8 @@ options:
   flatten dimensions of the data.
 """
 
+from __future__ import annotations
+
 from collections.abc import Callable, Sequence
 from dataclasses import dataclass, field
 from math import ceil
@@ -38,6 +40,8 @@ from ess.reduce.nexus.types import (
 )
 from ess.reduce.nexus.workflow import GenericNeXusWorkflow
 
+from . import roi
+
 CalibratedPositionWithNoisyReplicas = NewType(
     'CalibratedPositionWithNoisyReplicas', sc.Variable
 )
@@ -73,10 +77,14 @@ class Histogrammer:
         self._coords = coords
         self._edges = edges
 
+    @property
+    def replicas(self) -> int:
+        return self._replicas
+
     @staticmethod
     def from_coords(
         coords: ProjectedCoords, resolution: DetectorViewResolution
-    ) -> 'Histogrammer':
+    ) -> Histogrammer:
         """
         Create a histogrammer from coordinates and resolution.
 
@@ -102,7 +110,34 @@ class Histogrammer:
     def __call__(self, da: sc.DataArray) -> sc.DataArray:
         self._current += 1
         coords = self._coords[self._replica_dim, self._current % self._replicas]
-        return sc.DataArray(da.data, coords=coords).hist(self._edges)
+        return self._hist(da.data, coords=coords)
+
+    def _hist(self, data: sc.Variable, *, coords: sc.DataGroup) -> sc.DataArray:
+        # If input is multi-dim we need to flatten since those dims cannot be preserved.
+        return sc.DataArray(data, coords=coords).flatten(to='_').hist(self._edges)
+
+    def input_indices(self) -> sc.DataArray:
+        """Return an array with input indices corresponding to each histogram bin."""
+        dim = 'detector_number'
+        # For some projections one of the coords is a scalar, convert to flat table.
+        coords = self._coords.broadcast(sizes=self._coords.sizes).flatten(to=dim).copy()
+        ndet = sc.index(coords.sizes[dim] // self._replicas)
+        da = sc.DataArray(
+            sc.arange(dim, coords.sizes[dim], dtype='int64', unit=None) % ndet,
+            coords=coords,
+        )
+        return sc.DataArray(da.bin(self._edges).bins.data, coords=self._edges)
+
+    def apply_full(self, var: sc.Variable) -> sc.DataArray:
+        """
+        Apply the histogrammer to a variable using all replicas.
+
+        This is used for one-off operations where the full data is needed, e.g., for
+        transforming pixel weights. Compare to :py:meth:`__call__`, which applies the
+        histogrammer to a single replica for efficiency.
+        """
+        replicated = sc.concat([var] * self.replicas, dim=self._replica_dim)
+        return self._hist(replicated, coords=self._coords) / self.replicas
 
 
 @dataclass
@@ -149,20 +184,27 @@ class Detector:
             sc.zeros(sizes=detector_number.sizes, unit='counts', dtype='int32'),
             coords={'detector_number': detector_number},
         )
+        self._detector_number = detector_number
         self._flat_detector_number = detector_number.flatten(to='event_id')
         self._start = int(self._flat_detector_number[0].value)
         self._stop = int(self._flat_detector_number[-1].value)
         self._size = int(self._flat_detector_number.size)
-        if not sc.issorted(self._flat_detector_number, dim='event_id'):
-            raise ValueError("Detector numbers must be sorted.")
-        if self._stop - self._start + 1 != self._size:
-            raise ValueError("Detector numbers must be consecutive.")
+        self._sorted = sc.issorted(self._flat_detector_number, dim='event_id')
+        self._consecutive = self._stop - self._start + 1 == self._size
+
+    @property
+    def detector_number(self) -> sc.Variable:
+        return self._detector_number
 
     @property
     def data(self) -> sc.DataArray:
         return self._data
 
     def bincount(self, data: Sequence[int]) -> sc.DataArray:
+        if not self._sorted:
+            raise ValueError("Detector numbers must be sorted to use `bincount`.")
+        if not self._consecutive:
+            raise ValueError("Detector numbers must be consecutive to use `bincount`.")
         offset = np.asarray(data, dtype=np.int32) - self._start
         # Ignore events with detector numbers outside the range of the detector. This
         # should not happen in valid files but for now it is useful until we are sure
@@ -213,10 +255,27 @@ class RollingDetectorView(Detector):
         self._projection = projection
         self._window = window
         self._current = 0
-        self._history: sc.DataArray | None = None
-        self._cache: sc.DataArray | None = None
+        self._history: sc.DataArray
+        self._cache: sc.DataArray
+        self._cumulative: sc.DataArray
+        self.clear_counts()
+
+    @property
+    def max_window(self) -> int:
+        return self._window
 
-        counts = self.bincount([])
+    @property
+    def cumulative(self) -> sc.DataArray:
+        return self._cumulative
+
+    def clear_counts(self) -> None:
+        """
+        Clear counts.
+
+        Overrides Detector.clear_counts, to properly clear sliding window history and
+        cache.
+        """
+        counts = sc.zeros_like(self.data)
         if self._projection is not None:
             counts = self._projection(counts)
         self._history = (
@@ -225,13 +284,71 @@ class RollingDetectorView(Detector):
             .copy()
         )
         self._cache = self._history.sum('window')
+        self._cumulative = sc.zeros_like(self._cache)
+
+    def make_roi_filter(self) -> roi.ROIFilter:
+        """Return a ROI filter operating via the projection plane of the view."""
+        norm = 1.0
+        if isinstance(self._projection, Histogrammer):
+            indices = self._projection.input_indices()
+            norm = self._projection.replicas
+        else:
+            indices = sc.ones(sizes=self.data.sizes, dtype='int32', unit=None)
+            indices = sc.cumsum(indices, mode='exclusive')
+            if isinstance(self._projection, LogicalView):
+                indices = self._projection(indices)
+        return roi.ROIFilter(indices=indices, norm=norm)
+
+    def transform_weights(
+        self,
+        weights: sc.Variable | sc.DataArray | None = None,
+        *,
+        threshold: float = 0.1,
+    ) -> sc.DataArray:
+        """
+        Transform raw pixel weights to the projection plane.
+
+        Parameters
+        ----------
+        weights:
+            Raw pixel weights to transform. If None, default weights of 1 are used.
+        threshold:
+            Threshold for identifying bins with a low weight. If the weight is below the
+            threshold times the median weight, the bin is marked as invalid. This is
+            relevant to avoid issues with color scales in plots, where noise in bins
+            with low weight may dominate the color scale if auto-scaling is used.
+        """
+        if weights is None:
+            weights = sc.ones(
+                sizes=self.detector_number.sizes, dtype='float32', unit=''
+            )
+        else:
+            if weights.sizes != self.detector_number.sizes:
+                raise sc.DimensionError(
+                    f'Invalid {weights.sizes=} for {self.detector_number.sizes=}.'
+                )
+            if isinstance(weights, sc.DataArray):
+                if (det_num := weights.coords.get('detector_number')) is not None:
+                    if not sc.identical(det_num, self.detector_number):
+                        raise sc.CoordError("Mismatching detector numbers in weights.")
+                weights = weights.data
+        if isinstance(self._projection, Histogrammer):
+            xs = self._projection.apply_full(weights)  # Use all replicas
+        elif self._projection is not None:
+            xs = self._projection(weights)
+        else:
+            xs = weights.copy()
+        nonempty = xs.values[xs.values > 0]
+        mask = xs.values < threshold * np.median(nonempty)
+        xs.values[mask] = np.nan
+        return xs if isinstance(xs, sc.DataArray) else sc.DataArray(xs)
 
     @staticmethod
     def from_detector_and_histogrammer(
         detector: CalibratedDetector[SampleRun],
         window: RollingDetectorViewWindow,
         projection: Histogrammer,
-    ) -> 'RollingDetectorView':
+    ) -> RollingDetectorView:
         """Helper for constructing via a Sciline workflow."""
         return RollingDetectorView(
             detector_number=detector.coords['detector_number'],
@@ -244,7 +361,7 @@ class RollingDetectorView(Detector):
         detector: CalibratedDetector[SampleRun],
         window: RollingDetectorViewWindow,
         projection: LogicalView,
-    ) -> 'RollingDetectorView':
+    ) -> RollingDetectorView:
         """Helper for constructing via a Sciline workflow."""
         return RollingDetectorView(
             detector_number=detector.coords['detector_number'],
@@ -261,7 +378,7 @@ class RollingDetectorView(Detector):
         projection: Literal['xy_plane', 'cylinder_mantle_z'] | LogicalView,
         resolution: dict[str, int] | None = None,
         pixel_noise: Literal['cylindrical'] | sc.Variable | None = None,
-    ) -> 'RollingDetectorView':
+    ) -> RollingDetectorView:
         """
         Create a rolling detector view from a NeXus file using GenericNeXusWorkflow.
 
@@ -293,7 +410,7 @@ class RollingDetectorView(Detector):
             pixel_noise = sc.scalar(0.0, unit='m')
             noise_replica_count = 0
         else:
-            noise_replica_count = 4
+            noise_replica_count = 16
         wf = GenericNeXusWorkflow(run_types=[SampleRun], monitor_types=[])
         wf[RollingDetectorViewWindow] = window
         if isinstance(projection, LogicalView):
@@ -329,7 +446,20 @@ class RollingDetectorView(Detector):
         wf[NeXusDetectorName] = detector_name
         return wf.compute(RollingDetectorView)
 
-    def get(self, window: int | None = None) -> sc.DataArray:
+    def get(self, *, window: int | None = None) -> sc.DataArray:
+        """
+        Get the sum of counts over a window of the most recent counts.
+
+        Parameters
+        ----------
+        window:
+            Size of the window to use. If None, the full history is used.
+
+        Returns
+        -------
+        :
+            Sum of counts over the window.
+        """
         if window is not None and not 0 <= window <= self._window:
             raise ValueError("Window size must be less than the history size.")
         if window is None or window == self._window:
@@ -343,13 +473,38 @@ class RollingDetectorView(Detector):
                 data += self._history['window', 0 : self._current].sum('window')
         return data
 
+    def add_events(self, data: sc.DataArray) -> None:
+        """
+        Add counts in the form of events grouped by pixel ID.
+
+        Parameters
+        ----------
+        data:
+            Events grouped by pixel ID, given by binned data.
+        """
+        counts = data.bins.size().to(dtype='int32', copy=False)
+        counts.unit = 'counts'
+        self._add_counts(counts)
+
     def add_counts(self, data: Sequence[int]) -> None:
+        """
+        Add counts in the form of a sequence of pixel IDs.
+
+        Parameters
+        ----------
+        data:
+            List of pixel IDs.
+        """
         counts = self.bincount(data)
+        self._add_counts(counts)
+
+    def _add_counts(self, counts: sc.Variable) -> None:
         if self._projection is not None:
             counts = self._projection(counts)
         self._cache -= self._history['window', self._current]
         self._history['window', self._current] = counts
         self._cache += counts
+        self._cumulative += counts
         self._current = (self._current + 1) % self._window
 
 
@@ -455,9 +610,12 @@ def position_noise_for_cylindrical_pixel(
 
 
 def gaussian_position_noise(sigma: PositionNoiseSigma) -> PositionNoise:
+    sigma = sigma.to(unit='m', copy=False)
     size = _noise_size
     position = sc.empty(sizes={'position': size}, unit='m', dtype=sc.DType.vector3)
-    position.values = np.random.default_rng().normal(0, sigma.value, size=(size, 3))
+    position.values = np.random.default_rng(seed=1234).normal(
+        0, sigma.value, size=(size, 3)
+    )
     return PositionNoise(position)
 
 

ess/reduce/live/roi.py

@@ -0,0 +1,115 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright (c) 2025 Scipp contributors (https://github.com/scipp)
+"""Utilities for region of interest (ROI) selection."""
+
+from __future__ import annotations
+
+from typing import TypeVar
+
+import numpy as np
+import scipp as sc
+
+
+def select_indices_in_intervals(
+    intervals: sc.DataGroup[tuple[int, int] | tuple[sc.Variable, sc.Variable]],
+    indices: sc.Variable | sc.DataArray,
+) -> sc.Variable:
+    """
+    Return subset of indices that fall within the intervals.
+
+    Parameters
+    ----------
+    intervals:
+        DataGroup with dimension names as keys and tuples of low and high values. This
+        can be used to define a band or a rectangle to selected. When low and high are
+        scipp.Variable, the selection is done using label-based indexing. In this case
+        `indices` must be a DataArray with corresponding coordinates.
+    indices:
+        Variable or DataArray with indices to select from. If binned data the selected
+        indices will be returned concatenated into a dense array.
+    """
+    out_dim = 'index'
+    for dim, bounds in intervals.items():
+        low, high = sorted(bounds)
+        indices = indices[dim, low:high]
+    indices = indices.flatten(to=out_dim)
+    if indices.bins is None:
+        return indices
+    indices = indices.bins.concat().value
+    return indices.rename_dims({indices.dim: out_dim})
+
+
+T = TypeVar('T', sc.DataArray, sc.Variable)
+
+
+def apply_selection(
+    data: T, *, selection: sc.Variable, norm: float = 1.0
+) -> tuple[T, sc.Variable]:
+    """
+    Apply selection to data.
+
+    Parameters
+    ----------
+    data:
+        Data to filter.
+    selection:
+        Variable with indices to select.
+    norm:
+        Normalization factor to apply to the selected data. This is used for cases where
+        indices may be selected multiple times.
+
+    Returns
+    -------
+    :
+        Filtered data and scale factor.
+    """
+    indices, counts = np.unique(selection.values, return_counts=True)
+    if data.ndim != 1:
+        data = data.flatten(to='detector_number')
+    scale = sc.array(dims=[data.dim], values=counts) / norm
+    return data[indices], scale
+
+
+class ROIFilter:
+    """Filter for selecting a region of interest (ROI)."""
+
+    def __init__(self, indices: sc.Variable | sc.DataArray, norm: float = 1.0) -> None:
+        """
+        Create a new ROI filter.
+
+        Parameters
+        ----------
+        indices:
+            Variable with indices to filter. The indices facilitate selecting a 2-D
+            ROI in a projection of a 3-D dataset. Typically the indices are given by a
+            2-D array. Each element in the array may correspond to a single index (when
+            there is no projection) or a list of indices that were projected into an
+            output pixel.
+        """
+        self._indices = indices
+        self._selection = sc.array(dims=['index'], values=[])
+        self._norm = norm
+
+    def set_roi_from_intervals(self, intervals: sc.DataGroup) -> None:
+        """Set the ROI from (typically 1 or 2) intervals."""
+        self._selection = select_indices_in_intervals(intervals, self._indices)
+
+    def apply(self, data: T) -> tuple[T, sc.Variable]:
+        """
+        Apply the ROI filter to data.
+
+        The returned scale factor can be used to handle filtering via a projection, to
+        take into account that fractions of source data point contribute to a data point
+        in the projection.
+
+        Parameters
+        ----------
+        data:
+            Data to filter.
+
+        Returns
+        -------
+        :
+            Filtered data and scale factor.
+        """
+        return apply_selection(data, selection=self._selection, norm=self._norm)

ess/reduce/nexus/__init__.py

@@ -13,23 +13,23 @@ The submodule :mod:`types` defines all domain types.
 """
 
 from . import types
-from .workflow import GenericNeXusWorkflow
 from ._nexus_loader import (
-    load_data,
-    group_event_data,
-    load_component,
-    load_all_components,
     compute_component_position,
     extract_signal_data_array,
+    group_event_data,
+    load_all_components,
+    load_component,
+    load_data,
 )
+from .workflow import GenericNeXusWorkflow
 
 __all__ = [
-    'types',
+    'GenericNeXusWorkflow',
+    'compute_component_position',
+    'extract_signal_data_array',
     'group_event_data',
     'load_all_components',
-    'load_data',
     'load_component',
-    'compute_component_position',
-    'extract_signal_data_array',
-    'GenericNeXusWorkflow',
+    'load_data',
+    'types',
 ]

ess/reduce/nexus/_nexus_loader.py

@@ -30,6 +30,14 @@ class NoNewDefinitionsType: ...
 NoNewDefinitions = NoNewDefinitionsType()
 
 
+class NoLockingIfNeededType:
+    def __repr__(self) -> str:
+        return "NoLockingIfNeeded"
+
+
+NoLockingIfNeeded = NoLockingIfNeededType()
+
+
 def load_component(
     location: NeXusLocationSpec,
     *,
@@ -93,7 +101,7 @@ def _open_nexus_file(
     file_path: FilePath | NeXusFile | NeXusGroup,
     definitions: Mapping | None | NoNewDefinitionsType = NoNewDefinitions,
     *,
-    locking: bool | None = None,
+    locking: bool | str | None | NoLockingIfNeededType = NoLockingIfNeeded,
 ) -> AbstractContextManager[snx.Group]:
     if isinstance(file_path, getattr(NeXusGroup, '__supertype__', type(None))):
         if (
@@ -106,32 +114,63 @@ def _open_nexus_file(
         return nullcontext(file_path)
 
     try:
-        return _open_nexus_file_from_path(file_path, definitions, locking=locking)
+        return _open_nexus_file_from_path(
+            file_path,
+            definitions,
+            locking=None if locking is NoLockingIfNeeded else locking,
+        )
     except OSError as err:
-        if err.errno == errno.EROFS:
-            # Failed to open because the filesystem is read-only.
-            # (According to https://www.ioplex.com/%7Emiallen/errcmpp.html
-            # this error code is universal.)
-            #
-            # On ESS machines, this happens for network filesystems of data that was
-            # ingested into SciCat, including raw data.
-            # In this case, it is safe to open the file without locking because:
-            # - For raw files, they were written on a separate machine and are synced
-            #   with the one running reduction software. So there cannot be concurrent
-            #   write and read accesses to the same file on the same filesystem.
-            #   The ground truth on the filesystem used by the file writer is protected
-            #   and cannot be corrupted by our reader.
-            # - For processed data, the file was copied to the read-only filesystem.
-            #   So the copy we are opening was not written by HDF5 directly and thus
-            #   locking has no effect anyway.
-            #
-            # When running on user machines, disabling locking can potentially corrupt
-            # files. But the risk is minimal because very few users will have read-only
-            # filesystems and do concurrent reads and writes.
+        if _attempt_to_open_without_locking(err, locking):
             return _open_nexus_file_from_path(file_path, definitions, locking=False)
         raise
 
 
+# On ESS machines, some network filesystems are read-only.
+# E.g., data that was ingested into SciCat, including raw data.
+# HDF5 fails to open such files because it cannot lock the files.
+# In this case, it is safe(*) to open the file without locking because:
+#
+# - For raw files, they were written on a separate machine and are synced
+#   with the one running reduction software. So there cannot be concurrent
+#   write and read accesses to the same file on the same filesystem.
+#   The ground truth on the filesystem used by the file writer is protected
+#   and cannot be corrupted by our reader.
+# - For processed data, the file was copied to the read-only filesystem.
+#   So the copy we are opening was not written by HDF5 directly and thus
+#   locking has no effect anyway.
+#
+# When running on user machines, disabling locking can potentially corrupt
+# files. But the risk is minimal because very few users will have read-only
+# filesystems and do concurrent reads and writes.
+#
+# (*) Files on the read-only filesystem may still change while a file is open for
+# reading if they get updated from the original file. E.g., when reading a file that is
+# currently being written to. This can crash the reader. But our code is anyway not set
+# up to deal with changing files, so the added risk is not significant.
+#
+# See https://github.com/HDFGroup/hdf5/blob/e9ab45f0f4d7240937d5f88055f6c217da80f0d4/doxygen/dox/file-locking.dox
+# about HDF5 file locking.
+def _attempt_to_open_without_locking(
+    err: OSError, locking: bool | str | None | NoLockingIfNeededType
+) -> bool:
+    if locking is not NoLockingIfNeeded:
+        return False  # Respect user's choice.
+    if err.errno == errno.EROFS:
+        # Read-only filesystem.
+        # (According to https://www.ioplex.com/%7Emiallen/errcmpp.html
+        # this error code is universal.)
+        return True
+
+    # HDF5 tracks file locking flags internally within a single process.
+    # If the same file is opened multiple times, we can get a flag mismatch.
+    # We can try opening without locking, maybe this matches the original flags.
+    if "file locking flag values don't match" in err.args[0]:
+        return True
+    if "file locking 'ignore disabled locks' flag values don't match" in err.args[0]:
+        return True
+    return False
+
+
 def _open_nexus_file_from_path(
     file_path: FilePath,
     definitions: Mapping | None | NoNewDefinitionsType,

ess/reduce/streaming.py

@@ -4,6 +4,7 @@
 
 from abc import ABC, abstractmethod
 from collections.abc import Callable
+from copy import deepcopy
 from typing import Any, Generic, TypeVar
 
 import networkx as nx
@@ -29,6 +30,8 @@ def maybe_hist(value: T) -> T:
     :
         Histogram.
     """
+    if not isinstance(value, sc.Variable | sc.DataArray):
+        return value
     return value if value.bins is None else value.hist()
 
 
@@ -90,11 +93,11 @@ class EternalAccumulator(Accumulator[T]):
 
     @property
     def value(self) -> T:
-        return self._value.copy()
+        return deepcopy(self._value)
 
     def _do_push(self, value: T) -> None:
         if self._value is None:
-            self._value = value.copy()
+            self._value = deepcopy(value)
         else:
             self._value += value
 
@@ -146,6 +149,7 @@ class StreamProcessor:
         target_keys: tuple[sciline.typing.Key, ...],
         accumulators: dict[sciline.typing.Key, Accumulator, Callable[..., Accumulator]]
         | tuple[sciline.typing.Key, ...],
+        allow_bypass: bool = False,
     ) -> None:
         """
         Create a stream processor.
@@ -163,6 +167,12 @@ class StreamProcessor:
             passed, :py:class:`EternalAccumulator` is used for all keys. Otherwise, a
             dict mapping keys to accumulator instances can be passed. If a dict value is
             a callable, base_workflow.bind_and_call(value) is used to make an instance.
+        allow_bypass:
+            If True, allow bypassing accumulators for keys that are not in the
+            accumulators dict. This is useful for dynamic keys that are not "terminated"
+            in any accumulator. USE WITH CARE! This will lead to incorrect results
+            unless the values for these keys are valid for all chunks comprised in the
+            final accumulators at the point where :py:meth:`finalize` is called.
         """
         workflow = sciline.Pipeline()
         for key in target_keys:
@@ -201,19 +211,59 @@ class StreamProcessor:
             for key, value in self._accumulators.items()
         }
         self._target_keys = target_keys
+        self._allow_bypass = allow_bypass
 
     def add_chunk(
         self, chunks: dict[sciline.typing.Key, Any]
     ) -> dict[sciline.typing.Key, Any]:
+        """
+        Legacy interface for accumulating values from chunks and finalizing the result.
+
+        It is recommended to use :py:meth:`accumulate` and :py:meth:`finalize` instead.
+
+        Parameters
+        ----------
+        chunks:
+            Chunks to be processed.
+
+        Returns
+        -------
+        :
+            Finalized result.
+        """
+        self.accumulate(chunks)
+        return self.finalize()
+
+    def accumulate(self, chunks: dict[sciline.typing.Key, Any]) -> None:
+        """
+        Accumulate values from chunks without finalizing the result.
+
+        Parameters
+        ----------
+        chunks:
+            Chunks to be processed.
+        """
         for key, value in chunks.items():
             self._process_chunk_workflow[key] = value
             # There can be dynamic keys that do not "terminate" in any accumulator. In
             # that case, we need to make sure they can be and are used when computing
             # the target keys.
-            self._finalize_workflow[key] = value
+            if self._allow_bypass:
+                self._finalize_workflow[key] = value
         to_accumulate = self._process_chunk_workflow.compute(self._accumulators)
         for key, processed in to_accumulate.items():
             self._accumulators[key].push(processed)
+
+    def finalize(self) -> dict[sciline.typing.Key, Any]:
+        """
+        Get the final result by computing the target keys based on accumulated values.
+
+        Returns
+        -------
+        :
+            Finalized result.
+        """
+        for key in self._accumulators:
             self._finalize_workflow[key] = self._accumulators[key].value
         return self._finalize_workflow.compute(self._target_keys)