feat: more flexible helper for batch reduction

docs/user-guide/amor/amor-reduction.ipynb

@@ -467,13 +467,15 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from ess.reflectometry.tools import orso_datasets_from_measurements\n",
+    "from ess.reflectometry.tools import from_measurements\n",
     "\n",
-    "datasets = orso_datasets_from_measurements(\n",
+    "datasets = from_measurements(\n",
     "    workflow,\n",
     "    runs.values(),\n",
+    "    target=orso.OrsoIofQDataset,\n",
     "    # Optionally scale the curves to overlap using `scale_reflectivity_curves_to_overlap`\n",
-    "    scale_to_overlap=True\n",
+    "    # with the same \"critical edge interval\" that was used before\n",
+    "    scale_to_overlap=(sc.scalar(0.01, unit='1/angstrom'), sc.scalar(0.014, unit='1/angstrom'))\n",
     ")"
    ]
   },

src/ess/amor/load.py

@@ -17,6 +17,7 @@
     NeXusComponent,
     NeXusDetectorName,
     ProtonCurrent,
+    RawChopper,
     RawSampleRotation,
     RunType,
     SampleRotation,
@@ -29,7 +30,6 @@
     ChopperFrequency,
     ChopperPhase,
     ChopperSeparation,
-    RawChopper,
 )
 
 

src/ess/amor/normalization.py

@@ -88,6 +88,7 @@ def evaluate_reference_at_sample_coords(
     ref = ref.transform_coords(
         (
             "Q",
+            "theta",
             "wavelength_resolution",
             "sample_size_resolution",
             "angular_resolution",

src/ess/amor/types.py

@@ -27,8 +27,4 @@ class ChopperSeparation(sciline.Scope[RunType, sc.Variable], sc.Variable):
     """Distance between the two choppers."""
 
 
-class RawChopper(sciline.Scope[RunType, sc.DataGroup], sc.DataGroup):
-    """Chopper data loaded from nexus file."""
-
-
 GravityToggle = NewType("GravityToggle", bool)

src/ess/reflectometry/tools.py

@@ -8,10 +8,15 @@
 import sciline
 import scipp as sc
 import scipy.optimize as opt
-from orsopy.fileio.orso import OrsoDataset
 
 from ess.reflectometry import orso
-from ess.reflectometry.types import ReflectivityOverQ
+from ess.reflectometry.types import (
+    Filename,
+    ReducibleData,
+    ReflectivityOverQ,
+    SampleRun,
+)
+from ess.reflectometry.workflow import with_filenames
 
 _STD_TO_FWHM = sc.scalar(2.0) * sc.sqrt(sc.scalar(2.0) * sc.log(sc.scalar(2.0)))
 
@@ -279,18 +284,18 @@ def combine_curves(
     )
 
 
-def orso_datasets_from_measurements(
+def from_measurements(
     workflow: sciline.Pipeline,
-    runs: Sequence[Mapping[type, Any]],
+    runs: Sequence[Mapping[type, Any]] | Mapping[Any, Mapping[type, Any]],
+    target: type | Sequence[type] = orso.OrsoIofQDataset,
     *,
-    scale_to_overlap: bool = True,
-) -> list[OrsoDataset]:
-    '''Produces a list of ORSO datasets containing one
-    reflectivity curve for each of the provided runs.
+    scale_to_overlap: bool | tuple[sc.Variable, sc.Variable] = False,
+) -> list | Mapping:
+    '''Produces a list of datasets containing for each of the provided runs.
     Each entry of :code:`runs` is a mapping of parameters and
     values needed to produce the dataset.
 
-    Optionally, the reflectivity curves can be scaled to overlap in
+    Optionally, the results can be scaled so that the reflectivity curves overlap in
     the regions where they have the same Q-value.
 
     Parameters
@@ -299,38 +304,81 @@ def orso_datasets_from_measurements(
         The sciline workflow used to compute `ReflectivityOverQ` for each of the runs.
 
     runs:
-        The sciline parameters to be used for each run
+        The sciline parameters to be used for each run.
+
+    target:
+        The domain type(s) to compute for each run.
 
     scale_to_overlap:
-        If True the curves will be scaled to overlap.
-        Note that the curve of the first run is unscaled and
-        the rest are scaled to match it.
+        If ``True`` the curves will be scaled to overlap.
+        If a tuple then this argument will be passed as the ``critical_edge_interval``
+        argument to the ``scale_reflectivity_curves_to_overlap`` function.
 
     Returns
     ---------
     list of the computed ORSO datasets, containing one reflectivity curve each
     '''
-    reflectivity_curves = []
-    for parameters in runs:
+    names = runs.keys() if hasattr(runs, 'keys') else None
+    runs = runs.values() if hasattr(runs, 'values') else runs
+
+    def init_workflow(workflow, parameters):
         wf = workflow.copy()
-        for name, value in parameters.items():
-            wf[name] = value
-        reflectivity_curves.append(wf.compute(ReflectivityOverQ))
-
-    scale_factors = (
-        scale_reflectivity_curves_to_overlap([r.hist() for r in reflectivity_curves])[1]
-        if scale_to_overlap
-        else (1,) * len(runs)
-    )
+        for tp, value in parameters.items():
+            if tp is Filename[SampleRun]:
+                continue
+            wf[tp] = value
+
+        if Filename[SampleRun] in parameters:
+            if isinstance(parameters[Filename[SampleRun]], list | tuple):
+                wf = with_filenames(
+                    wf,
+                    SampleRun,
+                    parameters[Filename[SampleRun]],
+                )
+            else:
+                wf[Filename[SampleRun]] = parameters[Filename[SampleRun]]
+        return wf
+
+    if scale_to_overlap:
+        results = []
+        for parameters in runs:
+            wf = init_workflow(workflow, parameters)
+            results.append(wf.compute((ReflectivityOverQ, ReducibleData[SampleRun])))
+
+        scale_factors = scale_reflectivity_curves_to_overlap(
+            [r[ReflectivityOverQ].hist() for r in results],
+            critical_edge_interval=scale_to_overlap
+            if isinstance(scale_to_overlap, list | tuple)
+            else None,
+        )[1]
 
     datasets = []
-    for parameters, curve, scale_factor in zip(
-        runs, reflectivity_curves, scale_factors, strict=True
-    ):
-        wf = workflow.copy()
-        for name, value in parameters.items():
-            wf[name] = value
-        wf[ReflectivityOverQ] = scale_factor * curve
-        dataset = wf.compute(orso.OrsoIofQDataset)
+    for i, parameters in enumerate(runs):
+        wf = init_workflow(workflow, parameters)
+        if scale_to_overlap:
+            # Optimization in case we can avoid re-doing some work:
+            # Check if any of the targets need ReducibleData if
+            # ReflectivityOverQ already exists.
+            # If they don't, we can avoid recomputing ReducibleData.
+            targets = target if hasattr(target, '__len__') else (target,)
+            if any(
+                _workflow_needs_quantity_A_even_if_quantity_B_is_set(
+                    wf[t], ReducibleData[SampleRun], ReflectivityOverQ
+                )
+                for t in targets
+            ):
+                wf[ReducibleData[SampleRun]] = (
+                    scale_factors[i] * results[i][ReducibleData[SampleRun]]
+                )
+            else:
+                wf[ReflectivityOverQ] = scale_factors[i] * results[i][ReflectivityOverQ]
+
+        dataset = wf.compute(target)
         datasets.append(dataset)
-    return datasets
+    return datasets if names is None else dict(zip(names, datasets, strict=True))
+
+
+def _workflow_needs_quantity_A_even_if_quantity_B_is_set(workflow, A, B):
+    wf = workflow.copy()
+    wf[B] = 'Not important'
+    return A in wf.underlying_graph

src/ess/reflectometry/types.py

@@ -24,6 +24,10 @@
 CoordTransformationGraph = NewType("CoordTransformationGraph", dict)
 
 
+class RawChopper(sciline.Scope[RunType, sc.DataGroup], sc.DataGroup):
+    """Chopper data loaded from nexus file."""
+
+
 class ReducibleData(sciline.Scope[RunType, sc.DataArray], sc.DataArray):
     """Event data with common coordinates added"""
 

src/ess/reflectometry/workflow.py

@@ -6,15 +6,16 @@
 import sciline
 import scipp as sc
 
-from ess.amor.types import RawChopper
 from ess.reflectometry.orso import (
     OrsoExperiment,
     OrsoOwner,
     OrsoSample,
     OrsoSampleFilenames,
 )
 from ess.reflectometry.types import (
+    DetectorRotation,
     Filename,
+    RawChopper,
     ReducibleData,
     RunType,
     SampleRotation,
@@ -62,15 +63,34 @@ def with_filenames(
 
     mapped = wf.map(df)
 
-    wf[ReducibleData[runtype]] = mapped[ReducibleData[runtype]].reduce(
-        index=axis_name, func=_concatenate_event_lists
-    )
-    wf[RawChopper[runtype]] = mapped[RawChopper[runtype]].reduce(
-        index=axis_name, func=_any_value
-    )
-    wf[SampleRotation[runtype]] = mapped[SampleRotation[runtype]].reduce(
-        index=axis_name, func=_any_value
-    )
+    try:
+        wf[ReducibleData[runtype]] = mapped[ReducibleData[runtype]].reduce(
+            index=axis_name, func=_concatenate_event_lists
+        )
+    except ValueError:
+        # ReducibleData[runtype] is independent of Filename[runtype]
+        pass
+    try:
+        wf[RawChopper[runtype]] = mapped[RawChopper[runtype]].reduce(
+            index=axis_name, func=_any_value
+        )
+    except ValueError:
+        # RawChopper[runtype] is independent of Filename[runtype]
+        pass
+    try:
+        wf[SampleRotation[runtype]] = mapped[SampleRotation[runtype]].reduce(
+            index=axis_name, func=_any_value
+        )
+    except ValueError:
+        # SampleRotation[runtype] is independent of Filename[runtype]
+        pass
+    try:
+        wf[DetectorRotation[runtype]] = mapped[DetectorRotation[runtype]].reduce(
+            index=axis_name, func=_any_value
+        )
+    except ValueError:
+        # DetectorRotation[runtype] is independent of Filename[runtype]
+        pass
 
     if runtype is SampleRun:
         wf[OrsoSample] = mapped[OrsoSample].reduce(index=axis_name, func=_any_value)

tests/amor/tools_test.py

@@ -0,0 +1,68 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright (c) 2024 Scipp contributors (https://github.com/scipp)
+import pytest
+import sciline
+import scipp as sc
+from scipp.testing import assert_allclose
+
+from amor.pipeline_test import amor_pipeline  # noqa: F401
+from ess.amor import data
+from ess.amor.types import ChopperPhase
+from ess.reflectometry.tools import from_measurements
+from ess.reflectometry.types import (
+    DetectorRotation,
+    Filename,
+    QBins,
+    ReducedReference,
+    ReferenceRun,
+    ReflectivityOverQ,
+    SampleRotation,
+    SampleRun,
+)
+
+# The files used in the AMOR reduction workflow have some scippnexus warnings
+pytestmark = pytest.mark.filterwarnings(
+    "ignore:.*Invalid transformation, .*missing attribute 'vector':UserWarning",
+)
+
+
+@pytest.fixture
+def pipeline_with_1632_reference(amor_pipeline):  # noqa: F811
+    amor_pipeline[ChopperPhase[ReferenceRun]] = sc.scalar(7.5, unit='deg')
+    amor_pipeline[ChopperPhase[SampleRun]] = sc.scalar(7.5, unit='deg')
+    amor_pipeline[Filename[ReferenceRun]] = data.amor_run('1632')
+    amor_pipeline[ReducedReference] = amor_pipeline.compute(ReducedReference)
+    return amor_pipeline
+
+
+@pytestmark
+def test_from_measurements_tool_concatenates_event_lists(
+    pipeline_with_1632_reference: sciline.Pipeline,
+):
+    pl = pipeline_with_1632_reference
+
+    run = {
+        Filename[SampleRun]: list(map(data.amor_run, (1636, 1639, 1641))),
+        QBins: sc.geomspace(
+            dim='Q', start=0.062, stop=0.18, num=391, unit='1/angstrom'
+        ),
+        DetectorRotation[SampleRun]: sc.scalar(0.140167, unit='rad'),
+        SampleRotation[SampleRun]: sc.scalar(0.0680678, unit='rad'),
+    }
+    results = from_measurements(
+        pl,
+        [run],
+        target=ReflectivityOverQ,
+        scale_to_overlap=False,
+    )
+
+    results2 = []
+    for fname in run[Filename[SampleRun]]:
+        pl.copy()
+        pl[Filename[SampleRun]] = fname
+        pl[QBins] = run[QBins]
+        pl[DetectorRotation[SampleRun]] = run[DetectorRotation[SampleRun]]
+        pl[SampleRotation[SampleRun]] = run[SampleRotation[SampleRun]]
+        results2.append(pl.compute(ReflectivityOverQ).hist().data)
+
+    assert_allclose(sum(results2), results[0].hist().data)