modacor 1.0.0__py3-none-any.whl

modacor/tests/modules/base_modules/test_reduce_dimensionality.py

@@ -0,0 +1,358 @@
+# 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 pytest
+import logging
+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
+
+# adjust this import path to where you put the step:
+from modacor.modules.base_modules.reduce_dimensionality import ReduceDimensionality  # noqa: E402
+
+TEST_IO_SOURCES = IoSources()
+
+
+class TestReduceDimensionality(unittest.TestCase):
+    """Testing class for modacor/modules/base_modules/reduce_dim_weighted_average.py"""
+
+    def setUp(self):
+        # Simple 2x3 example so we can verify by hand:
+        #
+        # x = [[1, 2, 3],
+        #      [4, 5, 6]]
+        #
+        self.signal = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], dtype=float)
+
+        # absolute 1σ uncertainties = 0.1 everywhere
+        self.unc = 0.1 * np.ones_like(self.signal)
+
+        # weights: second row has weight 2, first row weight 1
+        # (broadcastable to signal.shape)
+        self.weights = np.array([[1.0], [2.0]], dtype=float)
+
+        self.test_processing_data = ProcessingData()
+        self.test_basedata = BaseData(
+            signal=self.signal,
+            units=ureg.Unit("count"),
+            uncertainties={"u": self.unc},
+            weights=self.weights,
+        )
+        self.test_data_bundle = DataBundle(signal=self.test_basedata)
+        self.test_processing_data["bundle"] = self.test_data_bundle
+
+    def tearDown(self):
+        pass
+
+    # ------------------------------------------------------------------
+    # Basic unweighted mean (use_weights=False, nan_policy='propagate')
+    # ------------------------------------------------------------------
+
+    def test_unweighted_mean_axis0(self):
+        """
+        Unweighted mean over axis=0 should match np.mean(signal, axis=0)
+        and propagate uncertainties as:
+            σ_mean = sqrt(σ1^2 + σ2^2) / N.
+        """
+        avg_step = ReduceDimensionality(io_sources=TEST_IO_SOURCES)
+        avg_step.modify_config_by_kwargs(
+            with_processing_keys=["bundle"],
+            axes=0,
+            use_weights=False,
+            nan_policy="propagate",
+        )
+        avg_step.processing_data = self.test_processing_data
+
+        avg_step.calculate()
+
+        result_bd: BaseData = self.test_processing_data["bundle"]["signal"]
+
+        # Expected mean
+        expected_mean = np.mean(self.signal, axis=0)
+        np.testing.assert_allclose(result_bd.signal, expected_mean)
+
+        # Expected uncertainty:
+        # Two points each with σ=0.1 -> σ_mean = sqrt(0.1^2 + 0.1^2) / 2
+        expected_sigma = np.sqrt(0.1**2 + 0.1**2) / 2.0
+        expected_u = np.full_like(expected_mean, expected_sigma)
+        np.testing.assert_allclose(result_bd.uncertainties["u"], expected_u)
+
+        # Units should be preserved
+        self.assertEqual(result_bd.units, ureg.Unit("count"))
+
+    # ------------------------------------------------------------------
+    # Weighted mean (use_weights=True)
+    # ------------------------------------------------------------------
+
+    def test_weighted_mean_axis0(self):
+        """
+        Weighted mean over axis=0 using BaseData.weights.
+
+        For each column:
+            μ = (1*x1 + 2*x2) / (1+2)
+            σ^2 = (1^2 σ1^2 + 2^2 σ2^2) / (1+2)^2
+        with σ1 = σ2 = 0.1.
+        """
+        avg_step = ReduceDimensionality(io_sources=TEST_IO_SOURCES)
+        avg_step.modify_config_by_kwargs(
+            with_processing_keys=["bundle"],
+            axes=0,
+            use_weights=True,
+            nan_policy="propagate",
+        )
+        avg_step.processing_data = self.test_processing_data
+
+        avg_step.calculate()
+
+        result_bd: BaseData = self.test_processing_data["bundle"]["signal"]
+
+        # Expected weighted mean along axis 0
+        w1, w2 = 1.0, 2.0
+        w_sum = w1 + w2
+        expected_mean = (w1 * self.signal[0, :] + w2 * self.signal[1, :]) / w_sum
+        np.testing.assert_allclose(result_bd.signal, expected_mean)
+
+        # Uncertainty:
+        # σ_μ^2 = (w1^2 σ1^2 + w2^2 σ2^2) / (w_sum^2)
+        sigma1 = sigma2 = 0.1
+        var_num = w1**2 * sigma1**2 + w2**2 * sigma2**2  # = (1 + 4)*0.01 = 0.05
+        expected_sigma = np.sqrt(var_num) / w_sum
+        expected_u = np.full_like(expected_mean, expected_sigma)
+        np.testing.assert_allclose(result_bd.uncertainties["u"], expected_u)
+
+        self.assertEqual(result_bd.units, ureg.Unit("count"))
+
+    def test_weighted_sum_axis0(self):
+        """
+        Weighted sum over axis=0 using BaseData.weights.
+
+        For each column:
+            S = Σ w_i x_i = 1*x1 + 2*x2
+            σ_S^2 = Σ w_i^2 σ_i^2 = (1^2 + 2^2) * σ^2
+        with σ = 0.1 everywhere.
+        """
+        avg_step = ReduceDimensionality(io_sources=TEST_IO_SOURCES)
+        avg_step.modify_config_by_kwargs(
+            with_processing_keys=["bundle"],
+            axes=0,
+            use_weights=True,
+            nan_policy="propagate",
+            reduction="sum",  # NEW
+        )
+        avg_step.processing_data = self.test_processing_data
+
+        avg_step.calculate()
+
+        result_bd: BaseData = self.test_processing_data["bundle"]["signal"]
+
+        # Expected weighted sum along axis 0
+        w1, w2 = 1.0, 2.0
+        expected_sum = w1 * self.signal[0, :] + w2 * self.signal[1, :]
+        np.testing.assert_allclose(result_bd.signal, expected_sum)
+
+        # Uncertainty:
+        # σ_S^2 = (w1^2 + w2^2) * σ^2
+        sigma = 0.1
+        var_factor = w1**2 + w2**2  # 1 + 4 = 5
+        expected_sigma = np.sqrt(var_factor * sigma**2)
+        expected_u = np.full_like(expected_sum, expected_sigma)
+        np.testing.assert_allclose(result_bd.uncertainties["u"], expected_u)
+
+        # Units preserved
+        self.assertEqual(result_bd.units, ureg.Unit("count"))
+
+    # ------------------------------------------------------------------
+    # nan_policy='omit'
+    # ------------------------------------------------------------------
+
+    def test_nanmean_omit(self):
+        """
+        When nan_policy='omit', NaNs in the signal are ignored.
+        For columns with only one finite value, the mean is that value
+        and the uncertainty is its σ.
+        """
+        # Introduce NaNs: one partial column, one fully NaN column
+        signal_nan = self.signal.copy()
+        signal_nan[0, 1] = np.nan  # second column: [NaN, 5]
+        signal_nan[:, 2] = np.nan  # third column: [NaN, NaN]
+
+        # Update processing data with this modified signal
+        bd_nan = BaseData(
+            signal=signal_nan,
+            units=ureg.Unit("count"),
+            uncertainties={"u": self.unc},  # still 0.1 everywhere
+            weights=self.weights,
+        )
+        self.test_processing_data["bundle"]["signal"] = bd_nan
+
+        avg_step = ReduceDimensionality(io_sources=TEST_IO_SOURCES)
+        avg_step.modify_config_by_kwargs(
+            with_processing_keys=["bundle"],
+            axes=0,
+            use_weights=False,
+            nan_policy="omit",
+        )
+        avg_step.processing_data = self.test_processing_data
+
+        avg_step.calculate()
+
+        result_bd: BaseData = self.test_processing_data["bundle"]["signal"]
+
+        # Column 0: mean of [1, 4]
+        expected_col0_mean = (1.0 + 4.0) / 2.0
+        # Column 1: mean of [5] (since NaN is omitted)
+        expected_col1_mean = 5.0
+        # Column 2: all NaN -> NaN
+        expected_mean = np.array([expected_col0_mean, expected_col1_mean, np.nan])
+        np.testing.assert_allclose(result_bd.signal, expected_mean, equal_nan=True)
+
+        # Uncertainties:
+        # Col0: two points with σ=0.1 -> σ_mean = sqrt(0.1^2+0.1^2)/2
+        col0_sigma = np.sqrt(0.1**2 + 0.1**2) / 2.0
+        # Col1: single finite point with σ=0.1 -> σ_mean = 0.1
+        col1_sigma = 0.1
+        # Col2: no finite points -> NaN
+        expected_u = np.array([col0_sigma, col1_sigma, np.nan])
+        np.testing.assert_allclose(result_bd.uncertainties["u"], expected_u, equal_nan=True)
+
+        self.assertEqual(result_bd.units, ureg.Unit("count"))
+
+    # ------------------------------------------------------------------
+    # Execution via __call__ shortcut
+    # ------------------------------------------------------------------
+
+    def test_weighted_average_execution_via_call(self):
+        """
+        Ensure the ProcessStep __call__ interface works, like for PoissonUncertainties.
+        """
+        avg_step = ReduceDimensionality(io_sources=TEST_IO_SOURCES)
+        avg_step.modify_config_by_kwargs(
+            with_processing_keys=["bundle"],
+            axes=0,
+            use_weights=True,
+            nan_policy="omit",
+        )
+
+        # Execute via __call__
+        avg_step(self.test_processing_data)
+
+        result_bd: BaseData = self.test_processing_data["bundle"]["signal"]
+
+        # Basic sanity checks: shape reduced along axis 0 → (3,)
+        self.assertEqual(result_bd.signal.shape, (3,))
+        # Units preserved
+        self.assertEqual(result_bd.units, ureg.Unit("count"))
+        # Uncertainty key still present
+        self.assertIn("u", result_bd.uncertainties)
+        # No unexpected NaNs for this simple case
+        self.assertFalse(np.isnan(result_bd.signal).any())
+        self.assertFalse(np.isnan(result_bd.uncertainties["u"]).any())
+
+
+def test_reduce_dimensionality_rank_and_axes_reduce_as_expected():
+    # 2D signal with matching axes metadata
+    sig = np.arange(12.0).reshape(3, 4)
+    bd = BaseData(signal=sig, units=ureg.dimensionless)
+
+    # original rank and axes
+    bd.rank_of_data = 2
+    axis0 = BaseData(signal=np.arange(3.0), units=ureg.dimensionless)
+    axis1 = BaseData(signal=np.arange(4.0), units=ureg.dimensionless)
+    bd.axes = [axis0, axis1]
+
+    # --- reduce over axis=1 -> shape (3,) ---
+    out_axis1 = ReduceDimensionality._weighted_mean_with_uncertainty(
+        bd=bd,
+        axis=1,
+        use_weights=False,
+        nan_policy="omit",
+        reduction="mean",
+    )
+
+    # shape reduced correctly
+    assert out_axis1.signal.shape == (3,)
+    # rank reduced: min(old_rank=2, new_ndim=1) -> 1
+    assert out_axis1.rank_of_data == 1
+    # axes: axis 1 removed, axis 0 preserved
+    assert len(out_axis1.axes) == 1
+    assert out_axis1.axes[0] is axis0
+
+    # --- reduce over all axes -> scalar ---
+    out_all = ReduceDimensionality._weighted_mean_with_uncertainty(
+        bd=bd,
+        axis=None,
+        use_weights=False,
+        nan_policy="omit",
+        reduction="mean",
+    )
+
+    # scalar output
+    assert out_all.signal.shape == ()
+    # rank cannot exceed new_ndim (0)
+    assert out_all.rank_of_data == 0
+    # axes should be empty for scalar
+    assert out_all.axes == []
+
+
+def test_reduce_dimensionality_emits_info_and_debug_logs(caplog):
+    """
+    Ensure that ReduceDimensionality.calculate() emits at least one INFO and
+    one DEBUG log record via the MessageHandler-backed logger.
+    """
+    signal = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], dtype=float)
+    unc = 0.1 * np.ones_like(signal)
+    weights = np.array([[1.0], [2.0]], dtype=float)
+
+    processing_data = ProcessingData()
+    bd = BaseData(
+        signal=signal,
+        units=ureg.Unit("count"),
+        uncertainties={"u": unc},
+        weights=weights,
+    )
+    bundle = DataBundle(signal=bd)
+    processing_data["bundle"] = bundle
+
+    step = ReduceDimensionality(io_sources=TEST_IO_SOURCES)
+    step.modify_config_by_kwargs(
+        with_processing_keys=["bundle"],
+        axes=0,
+        use_weights=True,
+        nan_policy="omit",
+        reduction="mean",
+    )
+    step.processing_data = processing_data
+
+    logger_name = "modacor.modules.base_modules.reduce_dimensionality"
+
+    with caplog.at_level(logging.DEBUG, logger=logger_name):
+        step.calculate()
+
+    # Sanity: output exists
+    assert "bundle" in processing_data
+    out_bd: BaseData = processing_data["bundle"]["signal"]
+    assert isinstance(out_bd, BaseData)
+
+    # Collect log records from expected logger
+    records = [rec for rec in caplog.records if rec.name == logger_name]
+    assert records, "Expected at least one log record from ReduceDimensionality logger."
+
+    levels = {rec.levelno for rec in records}
+    assert logging.INFO in levels, "Expected at least one INFO log from ReduceDimensionality."
+    assert logging.DEBUG in levels, "Expected at least one DEBUG log from ReduceDimensionality."

modacor/tests/modules/base_modules/test_sink_processing_data.py

@@ -0,0 +1,119 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# /usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from __future__ import annotations
+
+__coding__ = "utf-8"
+__authors__ = ["Brian R. Pauw"]
+__copyright__ = "Copyright 2026, The MoDaCor team"
+__date__ = "11/01/2026"
+__status__ = "Development"  # "Development", "Production"
+# end of header and standard imports
+
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+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_sinks import IoSinks
+from modacor.modules.base_modules.append_sink import AppendSink
+from modacor.modules.base_modules.sink_processing_data import SinkProcessingData
+
+
+@pytest.fixture
+def processing_data_1d() -> ProcessingData:
+    """
+    Minimal ProcessingData with a single DataBundle containing two 1D BaseData entries.
+    """
+    pd = ProcessingData()
+    b = DataBundle()
+
+    q = BaseData(signal=np.linspace(0.1, 1.0, 5), units=ureg.Unit("1/nm"))
+    i = BaseData(signal=np.array([10, 11, 12, 13, 14], dtype=float), units=ureg.dimensionless)
+
+    b["Q"] = q
+    b["signal"] = i
+    pd["sample"] = b
+    return pd
+
+
+def _register_csv_sink(io_sinks: IoSinks, out_file: Path) -> None:
+    """
+    Register a CSVSink via AppendSink.
+    """
+    step = AppendSink(io_sources=None, io_sinks=io_sinks)
+    step.modify_config_by_dict(
+        {
+            "sink_identifier": ["export_csv"],
+            "sink_location": [str(out_file)],
+            "iosink_module": "modacor.io.csv.csv_sink.CSVSink",
+            # simplified: delimiter (and any np.savetxt kwargs) live here
+            "iosink_method_kwargs": {"delimiter": ","},
+        }
+    )
+    step.calculate()
+
+
+def _run_sink_step(io_sinks: IoSinks, processing_data: ProcessingData, *, target: str, data_paths: list[str]):
+    step = SinkProcessingData(io_sources=None, io_sinks=io_sinks, processing_data=processing_data)
+    step.modify_config_by_dict({"target": target, "data_paths": data_paths})
+    return step.calculate()
+
+
+def test_sink_processing_data_writes_csv_numpy(tmp_path: Path, processing_data_1d: ProcessingData):
+    out_file = tmp_path / "export.csv"
+    io_sinks = IoSinks()
+    _register_csv_sink(io_sinks, out_file)
+
+    data_paths = ["/sample/Q/signal", "/sample/signal/signal"]
+    output = _run_sink_step(io_sinks, processing_data_1d, target="export_csv::", data_paths=data_paths)
+
+    assert output == {}
+    assert out_file.is_file()
+
+    lines = out_file.read_text(encoding="utf-8").splitlines()
+    assert len(lines) == 2 + 5  # 2 headers + 5 rows
+
+    # header row: names derived from data_paths
+    assert lines[0] == "sample/Q/signal,sample/signal/signal"
+
+    # units row: inferred from BaseData units
+    q_units = str(processing_data_1d["sample"]["Q"].units)
+    i_units = str(processing_data_1d["sample"]["signal"].units)
+    assert lines[1] == f"{q_units},{i_units}"  # noqa: E231
+
+    # first numeric row should match first entries
+    first_row = [float(x) for x in lines[2].split(",")]
+    assert first_row == [
+        float(processing_data_1d["sample"]["Q"].signal[0]),
+        float(processing_data_1d["sample"]["signal"].signal[0]),
+    ]
+
+
+def test_sink_processing_data_rejects_csv_subpath(tmp_path: Path, processing_data_1d: ProcessingData):
+    out_file = tmp_path / "export.csv"
+    io_sinks = IoSinks()
+    _register_csv_sink(io_sinks, out_file)
+
+    with pytest.raises(ValueError):
+        _run_sink_step(
+            io_sinks,
+            processing_data_1d,
+            target="export_csv::not_supported",
+            data_paths=["/sample/Q/signal"],
+        )
+
+
+def test_sink_processing_data_requires_explicit_leaf_path(tmp_path: Path, processing_data_1d: ProcessingData):
+    out_file = tmp_path / "export.csv"
+    io_sinks = IoSinks()
+    _register_csv_sink(io_sinks, out_file)
+
+    # Missing leaf (BaseData object root) -> CSVSink should refuse
+    with pytest.raises(ValueError):
+        _run_sink_step(io_sinks, processing_data_1d, target="export_csv::", data_paths=["/sample/Q"])

modacor/tests/modules/base_modules/test_subtract.py

@@ -0,0 +1,111 @@
+# 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
+
+import modacor.modules.base_modules.subtract as subtract_module
+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 import Subtract
+
+TEST_IO_SOURCES = IoSources()
+
+
+class TestSubtractProcessingStep(unittest.TestCase):
+    """Testing class for modacor/modules/base_modules/subtract.py"""
+
+    def setUp(self):
+        # 2x3 BaseData
+        signal = np.array([[10.0, 20.0, 30.0], [40.0, 50.0, 60.0]], dtype=float)
+        data_unc = 0.5 * np.ones_like(signal)
+
+        self.test_processing_data = ProcessingData()
+        self.base = BaseData(
+            signal=signal,
+            units=ureg.Unit("count"),
+            uncertainties={"u": data_unc},
+        )
+        self.test_data_bundle = DataBundle(signal=self.base)
+        self.test_processing_data["bundle"] = self.test_data_bundle
+
+        # Subtrahend: scalar BaseData with same units so subtraction is valid
+        self.subtrahend = BaseData(
+            signal=5.0,
+            units=ureg.Unit("count"),
+            uncertainties={"propagate_to_all": np.array(0.2, dtype=float)},
+        )
+
+        # Ground truth using BaseData.__sub__
+        self.expected_result = self.base - self.subtrahend
+
+        # Monkeypatch basedata_from_sources
+        self._orig_basedata_from_sources = subtract_module.basedata_from_sources
+        subtract_module.basedata_from_sources = self._fake_basedata_from_sources
+
+    def tearDown(self):
+        subtract_module.basedata_from_sources = self._orig_basedata_from_sources
+
+    def _fake_basedata_from_sources(self, io_sources, signal_source, units_source=None, uncertainty_sources=None):
+        """Fake basedata_from_sources that always returns self.subtrahend."""
+        return self.subtrahend
+
+    def test_subtract_calculation(self):
+        """
+        Subtract.calculate() should subtract the subtrahend from the DataBundle's BaseData,
+        using BaseData.__sub__ semantics.
+        """
+        step = Subtract(io_sources=TEST_IO_SOURCES)
+        step.modify_config_by_kwargs(
+            with_processing_keys=["bundle"],
+            subtrahend_source="dummy",  # ignored
+        )
+        step.processing_data = self.test_processing_data
+
+        step.calculate()
+
+        result_bd: BaseData = self.test_processing_data["bundle"]["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_subtract_execution_via_call(self):
+        """
+        Subtract.__call__ should run the step and update ProcessingData in-place.
+        """
+        step = Subtract(io_sources=TEST_IO_SOURCES)
+        step.modify_config_by_kwargs(
+            with_processing_keys=["bundle"],
+            subtrahend_source="dummy",
+        )
+
+        step(self.test_processing_data)
+
+        result_bd: BaseData = self.test_processing_data["bundle"]["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)