modacor 1.0.0__py3-none-any.whl

modacor/tests/modules/base_modules/test_subtract_databundles.py

@@ -0,0 +1,136 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# /usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from __future__ import annotations
+
+__coding__ = "utf-8"
+__authors__ = ["Brian R. Pauw"]  # add names to the list as appropriate
+__copyright__ = "Copyright 2025, The MoDaCor team"
+__date__ = "16/11/2025"
+__status__ = "Development"  # "Development", "Production"
+# end of header and standard imports
+
+import unittest
+
+import numpy as np
+
+from modacor import ureg
+from modacor.dataclasses.basedata import BaseData
+from modacor.dataclasses.databundle import DataBundle
+from modacor.dataclasses.processing_data import ProcessingData
+from modacor.io.io_sources import IoSources
+from modacor.modules.base_modules.subtract_databundles import SubtractDatabundles
+
+TEST_IO_SOURCES = IoSources()
+
+
+class TestSubtractDatabundles(unittest.TestCase):
+    """Testing class for modacor/modules/base_modules/subtract_databundles.py"""
+
+    def setUp(self):
+        # Two simple 2x3 BaseData objects to subtract
+        signal1 = np.array([[10.0, 20.0, 30.0], [40.0, 50.0, 60.0]], dtype=float)
+        signal2 = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], dtype=float)
+
+        # Absolute 1σ uncertainties
+        unc1 = 0.5 * np.ones_like(signal1)
+        unc2 = 0.2 * np.ones_like(signal2)
+
+        self.bd1 = BaseData(
+            signal=signal1,
+            units=ureg.Unit("count"),
+            uncertainties={"u": unc1},
+        )
+        self.bd2 = BaseData(
+            signal=signal2,
+            units=ureg.Unit("count"),
+            uncertainties={"u": unc2},
+        )
+
+        self.bundle1 = DataBundle(signal=self.bd1)
+        self.bundle2 = DataBundle(signal=self.bd2)
+
+        self.processing_data = ProcessingData()
+        self.processing_data["bundle1"] = self.bundle1
+        self.processing_data["bundle2"] = self.bundle2
+
+        # Ground truth using BaseData.__sub__
+        self.expected_result = self.bd1 - self.bd2
+
+    def tearDown(self):
+        pass
+
+    # ------------------------------------------------------------------ #
+    # Tests
+    # ------------------------------------------------------------------ #
+
+    def test_subtract_databundles_calculation(self):
+        """
+        SubtractDatabundles.calculate() should subtract the second DataBundle's
+        signal from the first, using BaseData.__sub__ semantics.
+        """
+        step = SubtractDatabundles(io_sources=TEST_IO_SOURCES)
+        step.modify_config_by_kwargs(
+            with_processing_keys=["bundle1", "bundle2"],
+        )
+        step.processing_data = self.processing_data
+
+        output = step.calculate()
+
+        # Only the minuend key should be in output
+        self.assertEqual(list(output.keys()), ["bundle1"])
+
+        result_bd: BaseData = self.processing_data["bundle1"]["signal"]
+
+        # Signal and uncertainties should match the precomputed result
+        np.testing.assert_allclose(result_bd.signal, self.expected_result.signal)
+        for key in self.expected_result.uncertainties:
+            np.testing.assert_allclose(
+                result_bd.uncertainties[key],
+                self.expected_result.uncertainties[key],
+            )
+
+        # Units should be preserved (count - count → count)
+        self.assertEqual(result_bd.units, self.expected_result.units)
+
+    def test_subtract_databundles_execution_via_call(self):
+        """
+        SubtractDatabundles.__call__ should run the step and update ProcessingData in-place.
+        """
+        # Re-initialize processing_data to original state
+        processing_data = ProcessingData()
+        processing_data["bundle1"] = DataBundle(signal=self.bd1)
+        processing_data["bundle2"] = DataBundle(signal=self.bd2)
+
+        step = SubtractDatabundles(io_sources=TEST_IO_SOURCES)
+        step.modify_config_by_kwargs(
+            with_processing_keys=["bundle1", "bundle2"],
+        )
+
+        step(processing_data)
+
+        result_bd: BaseData = processing_data["bundle1"]["signal"]
+
+        np.testing.assert_allclose(result_bd.signal, self.expected_result.signal)
+        for key in self.expected_result.uncertainties:
+            np.testing.assert_allclose(
+                result_bd.uncertainties[key],
+                self.expected_result.uncertainties[key],
+            )
+        self.assertEqual(result_bd.units, self.expected_result.units)
+
+    def test_requires_exactly_two_keys(self):
+        """
+        SubtractDatabundles should assert if 'with_processing_keys' does not
+        contain exactly two keys.
+        """
+        step = SubtractDatabundles(io_sources=TEST_IO_SOURCES)
+        # Only one key → should trigger the assertion in calculate()
+        step.modify_config_by_kwargs(
+            with_processing_keys=["bundle1"],
+        )
+        step.processing_data = self.processing_data
+
+        with self.assertRaises(AssertionError):
+            step.calculate()

modacor/tests/modules/base_modules/test_units_label_update.py

@@ -0,0 +1,91 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# /usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from __future__ import annotations
+
+__coding__ = "utf-8"
+__authors__ = ["Brian R. Pauw"]  # add names to the list as appropriate
+__copyright__ = "Copyright 2025, The MoDaCor team"
+__date__ = "16/12/2025"
+__status__ = "Development"  # "Development", "Production"
+# end of header and standard imports
+
+import numpy as np
+
+from modacor import ureg
+from modacor.dataclasses.basedata import BaseData
+from modacor.dataclasses.databundle import DataBundle
+from modacor.dataclasses.processing_data import ProcessingData
+from modacor.io.io_sources import IoSources
+
+# adjust import if your file lives elsewhere
+from modacor.modules.base_modules.units_label_update import UnitsLabelUpdate
+
+
+def _make_pd() -> ProcessingData:
+    pd = ProcessingData()
+    db = DataBundle()
+
+    db["intensity_scale_factor"] = BaseData(
+        signal=np.array(2.0),
+        units="dimensionless",
+        uncertainties={"propagate_to_all": np.array(0.05)},
+    )
+    db["other_factor"] = BaseData(
+        signal=np.array([1.0, 2.0, 3.0]),
+        units="dimensionless",
+        uncertainties={"propagate_to_all": np.array([0.1, 0.1, 0.1])},
+    )
+
+    pd["intensity_calibration"] = db
+    return pd
+
+
+def test_units_update_sets_units_for_multiple_keys_without_touching_values():
+    pd = _make_pd()
+    before_sf = pd["intensity_calibration"]["intensity_scale_factor"].signal.copy()
+    before_sf_u = dict(pd["intensity_calibration"]["intensity_scale_factor"].uncertainties)
+
+    before_other = pd["intensity_calibration"]["other_factor"].signal.copy()
+    before_other_u = dict(pd["intensity_calibration"]["other_factor"].uncertainties)
+
+    step = UnitsLabelUpdate(io_sources=IoSources())
+    step.modify_config_by_dict(
+        {
+            "with_processing_keys": ["intensity_calibration"],
+            "update_pairs": {
+                "intensity_scale_factor": {"units": "meter"},
+                "other_factor": {"units": "1/second"},
+            },
+        }
+    )
+    step.execute(pd)
+
+    sf = pd["intensity_calibration"]["intensity_scale_factor"]
+    other = pd["intensity_calibration"]["other_factor"]
+
+    assert sf.units == ureg.Unit("meter")
+    assert other.units == ureg.Unit("1/second")
+
+    np.testing.assert_allclose(sf.signal, before_sf)
+    np.testing.assert_allclose(other.signal, before_other)
+    np.testing.assert_allclose(sf.uncertainties["propagate_to_all"], before_sf_u["propagate_to_all"])
+    np.testing.assert_allclose(other.uncertainties["propagate_to_all"], before_other_u["propagate_to_all"])
+
+
+def test_units_update_accepts_shorthand_string_form():
+    pd = _make_pd()
+
+    step = UnitsLabelUpdate(io_sources=IoSources())
+    step.modify_config_by_dict(
+        {
+            "with_processing_keys": ["intensity_calibration"],
+            "update_pairs": {
+                "intensity_scale_factor": "second",
+            },
+        }
+    )
+    step.execute(pd)
+
+    assert pd["intensity_calibration"]["intensity_scale_factor"].units == ureg.Unit("second")

modacor/tests/modules/technique_modules/scattering/test_geometry_helpers.py

@@ -0,0 +1,198 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# /usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from __future__ import annotations
+
+__coding__ = "utf-8"
+__authors__ = ["Brian R. Pauw"]  # add names to the list as appropriate
+__copyright__ = "Copyright 2026, The MoDaCor team"
+__date__ = "06/01/2026"
+__status__ = "Development"  # "Development", "Production"
+# end of header and standard imports
+__version__ = "20260106.1"
+
+import numpy as np
+import pytest
+
+from modacor import ureg
+from modacor.dataclasses.basedata import BaseData
+from modacor.modules.technique_modules.scattering.geometry_helpers import (
+    prepare_static_scalar,
+    require_scalar,
+    unit_vec3,
+)
+
+# ----------------------------
+# unit_vec3
+# ----------------------------
+
+
+def test_unit_vec3_normalizes():
+    v = np.array([3.0, 0.0, 4.0])
+    u = unit_vec3(v)
+    np.testing.assert_allclose(np.linalg.norm(u), 1.0)
+    np.testing.assert_allclose(u, np.array([0.6, 0.0, 0.8]))
+
+
+def test_unit_vec3_rejects_zero_vector():
+    with pytest.raises(ValueError, match="must be non-zero"):
+        unit_vec3((0.0, 0.0, 0.0), name="basis_fast")
+
+
+# ----------------------------
+# require_scalar
+# ----------------------------
+
+
+def test_require_scalar_passes_scalar_and_sets_rod0():
+    # scalar signal => ndim=0 => rank_of_data MUST be 0
+    bd = BaseData(signal=np.array(2.5), units=ureg.m, rank_of_data=0)
+    out = require_scalar("z", bd)
+    assert np.size(out.signal) == 1
+    assert out.rank_of_data == 0
+    assert out.units.is_compatible_with(ureg.m)
+    np.testing.assert_allclose(out.signal, 2.5)
+
+
+def test_require_scalar_squeezes_singleton_array():
+    # singleton array is valid; RoD must not exceed ndim
+    bd = BaseData(signal=np.array([[[[2.5]]]]), units=ureg.m, rank_of_data=0)
+    out = require_scalar("z", bd)
+    assert np.size(out.signal) == 1
+    assert out.rank_of_data == 0
+    np.testing.assert_allclose(out.signal, 2.5)
+
+
+def test_require_scalar_rejects_non_scalar():
+    bd = BaseData(signal=np.array([1.0, 2.0]), units=ureg.m, rank_of_data=0)
+    with pytest.raises(ValueError, match="must be scalar"):
+        require_scalar("det_z", bd)
+
+
+# ----------------------------
+# prepare_static_scalar
+# ----------------------------
+
+
+def test_prepare_static_scalar_passes_through_scalar():
+    # scalar signal => ndim=0 => RoD must be 0
+    bd = BaseData(signal=np.array(2.5), units=ureg.m, rank_of_data=0)
+    out = prepare_static_scalar(bd, require_units=ureg.m, uncertainty_key="jitter")
+    assert np.size(out.signal) == 1
+    assert out.rank_of_data == 0
+    assert out.units.is_compatible_with(ureg.m)
+    np.testing.assert_allclose(out.signal, 2.5)
+    # passthrough: don't assert uncertainties content
+
+
+def test_prepare_static_scalar_reduces_shape_5_1_1_1_uniform_weights_mean_and_sem():
+    values = np.array([2.50, 2.52, 2.48, 2.51, 2.49], dtype=float).reshape(5, 1, 1, 1)
+    bd = BaseData(signal=values, units=ureg.m, rank_of_data=0)
+
+    out = prepare_static_scalar(bd, require_units=ureg.m, uncertainty_key="sem")
+
+    exp_mean = float(np.mean(values))
+    flat = values.ravel()
+    exp_var = float(np.mean((flat - exp_mean) ** 2))  # population var
+    exp_sem = float(np.sqrt(exp_var) / np.sqrt(flat.size))
+
+    np.testing.assert_allclose(out.signal, exp_mean, rtol=0, atol=1e-15)
+    assert out.rank_of_data == 0
+    assert "sem" in out.uncertainties
+    np.testing.assert_allclose(out.uncertainties["sem"], exp_sem, rtol=0, atol=1e-15)
+
+
+def test_prepare_static_scalar_reduces_1d_shape_5_to_scalar_mean_and_sem():
+    """
+    New: common case where NeXus/HDF5 read yields a squeezed vector shape (5,)
+    (e.g. after user preprocessing or reader behavior).
+    """
+    values = np.array([2.50, 2.52, 2.48, 2.51, 2.49], dtype=float)  # shape (5,)
+    bd = BaseData(signal=values, units=ureg.m, rank_of_data=0)
+
+    out = prepare_static_scalar(bd, require_units=ureg.m, uncertainty_key="sem")
+
+    exp_mean = float(np.mean(values))
+    exp_var = float(np.mean((values - exp_mean) ** 2))  # population var
+    exp_sem = float(np.sqrt(exp_var) / np.sqrt(values.size))
+
+    assert np.size(out.signal) == 1
+    assert out.rank_of_data == 0
+    np.testing.assert_allclose(out.signal, exp_mean, rtol=0, atol=1e-15)
+    assert "sem" in out.uncertainties
+    np.testing.assert_allclose(out.uncertainties["sem"], exp_sem, rtol=0, atol=1e-15)
+
+
+def test_prepare_static_scalar_accepts_scalar_weights_broadcasts():
+    values = np.array([1.0, 2.0, 3.0, 4.0], dtype=float).reshape(4, 1, 1, 1)
+    bd = BaseData(signal=values, units=ureg.m, rank_of_data=0)
+    bd.weights = np.array([1.0])  # scalar/size-1 weights
+
+    out = prepare_static_scalar(bd, require_units=ureg.m, uncertainty_key="sem")
+
+    exp_mean = float(np.mean(values))
+    flat = values.ravel()
+    exp_var = float(np.mean((flat - exp_mean) ** 2))
+    exp_sem = float(np.sqrt(exp_var) / np.sqrt(flat.size))
+
+    np.testing.assert_allclose(out.signal, exp_mean, rtol=0, atol=1e-15)
+    np.testing.assert_allclose(out.uncertainties["sem"], exp_sem, rtol=0, atol=1e-15)
+
+
+def test_prepare_static_scalar_accepts_broadcastable_weights():
+    values = np.array([10.0, 20.0, 30.0, 40.0], dtype=float).reshape(4, 1, 1, 1)
+    weights = np.array([1.0, 1.0, 2.0, 2.0], dtype=float).reshape(4, 1, 1, 1)
+    bd = BaseData(signal=values, units=ureg.m, rank_of_data=0)
+    bd.weights = weights
+
+    out = prepare_static_scalar(bd, require_units=ureg.m, uncertainty_key="sem")
+
+    x = values.ravel()
+    w = weights.ravel()
+    wsum = float(np.sum(w))
+    exp_mean = float(np.sum(w * x) / wsum)
+    n_eff = float((wsum**2) / np.sum(w**2))
+    exp_var = float(np.sum(w * (x - exp_mean) ** 2) / wsum)
+    exp_sem = float(np.sqrt(exp_var) / np.sqrt(n_eff))
+
+    np.testing.assert_allclose(out.signal, exp_mean, rtol=0, atol=1e-15)
+    np.testing.assert_allclose(out.uncertainties["sem"], exp_sem, rtol=0, atol=1e-15)
+
+
+def test_prepare_static_scalar_rejects_non_broadcastable_weights():
+    values = np.array([1.0, 2.0, 3.0, 4.0], dtype=float).reshape(4, 1, 1, 1)
+    bd = BaseData(signal=values, units=ureg.m, rank_of_data=0)
+    bd.weights = np.array([1.0, 2.0, 3.0])  # not broadcastable
+
+    with pytest.raises(ValueError, match="weights shape .* does not match signal shape"):
+        prepare_static_scalar(bd, require_units=ureg.m, uncertainty_key="sem")
+
+
+def test_prepare_static_scalar_rejects_wrong_units():
+    bd = BaseData(signal=np.array([1.0, 2.0, 3.0]), units=ureg.pixel, rank_of_data=0)
+    with pytest.raises(ValueError, match="Value must be in"):
+        prepare_static_scalar(bd, require_units=ureg.m)
+
+
+def test_prepare_static_scalar_rejects_nonpositive_weight_sum():
+    values = np.array([1.0, 2.0, 3.0], dtype=float)
+    bd = BaseData(signal=values, units=ureg.m, rank_of_data=0)
+    bd.weights = np.array([0.0, 0.0, 0.0])
+
+    with pytest.raises(ValueError, match="weights must sum to > 0"):
+        prepare_static_scalar(bd, require_units=ureg.m, uncertainty_key="sem")
+
+
+def test_prepare_static_scalar_signal_1d_weights_5_1_1_1_raises():
+    # signal is already squeezed to (5,)
+    x = np.array([2.50, 2.52, 2.48, 2.51, 2.49], dtype=float)  # shape (5,)
+
+    # weights come from a NeXus/HDF5-like dataset: shape (5,1,1,1)
+    w = np.array([1.0, 1.0, 2.0, 2.0, 4.0], dtype=float).reshape(5, 1, 1, 1)
+
+    bd = BaseData(signal=x, units=ureg.m, rank_of_data=0)
+    bd.weights = w
+
+    with pytest.raises(ValueError, match="weights shape .* does not match signal shape"):
+        _ = prepare_static_scalar(bd, require_units=ureg.m, uncertainty_key="sem")