modacor 1.0.0__py3-none-any.whl

modacor/tests/modules/base_modules/test_divide.py

@@ -0,0 +1,140 @@
+# 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.divide as divide_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
+
+# The processing step under test
+from modacor.modules.base_modules.divide import Divide
+
+TEST_IO_SOURCES = IoSources()
+
+
+class TestDivideProcessingStep(unittest.TestCase):
+    """Testing class for modacor/modules/base_modules/divide.py"""
+
+    def setUp(self):
+        # Small test signal: shape (2, 3) to avoid trivial broadcasting bugs
+        signal = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], dtype=float)
+
+        # absolute 1σ uncertainties on the data
+        data_unc = 0.1 * np.ones_like(signal)
+
+        self.test_processing_data = ProcessingData()
+        self.test_basedata = BaseData(
+            signal=signal,
+            units=ureg.Unit("count"),
+            uncertainties={"u": data_unc},
+        )
+        self.test_data_bundle = DataBundle(signal=self.test_basedata)
+        self.test_processing_data["bundle"] = self.test_data_bundle
+
+        # Divisor: scalar BaseData with uncertainty
+        # (propagate_to_all for reuse with any key)
+        self.divisor = BaseData(
+            signal=2.0,
+            units=ureg.Unit("second"),
+            uncertainties={"propagate_to_all": np.array(0.2, dtype=float)},
+        )
+
+        # Ground truth result using the already-tested BaseData.__truediv__
+        self.expected_result = self.test_basedata / self.divisor
+
+        # Monkeypatch basedata_from_sources to return our known divisor
+        self._orig_basedata_from_sources = divide_module.basedata_from_sources
+        divide_module.basedata_from_sources = self._fake_basedata_from_sources
+
+    def tearDown(self):
+        # Restore original helper to avoid leaking the patch to other tests
+        divide_module.basedata_from_sources = self._orig_basedata_from_sources
+
+    # ------------------------------------------------------------------ #
+    # Helper used for monkeypatch
+    # ------------------------------------------------------------------ #
+
+    def _fake_basedata_from_sources(self, io_sources, signal_source, units_source=None, uncertainty_sources=None):
+        """
+        Fake basedata_from_sources that ignores its inputs and returns
+        the pre-constructed self.divisor.
+        """
+        return self.divisor
+
+    # ------------------------------------------------------------------ #
+    # Actual tests
+    # ------------------------------------------------------------------ #
+
+    def test_divide_calculation(self):
+        """
+        Divide.calculate() should divide the DataBundle's BaseData by the divisor
+        returned from basedata_from_sources, using BaseData.__truediv__ semantics.
+        """
+        divide_step = Divide(io_sources=TEST_IO_SOURCES)
+        divide_step.modify_config_by_kwargs(
+            with_processing_keys=["bundle"],
+            divisor_source="dummy",  # ignored by our fake basedata_from_sources
+        )
+        divide_step.processing_data = self.test_processing_data
+
+        divide_step.calculate()
+
+        result_bd: BaseData = self.test_processing_data["bundle"]["signal"]
+
+        # Signal should match the pre-computed expected_result
+        np.testing.assert_allclose(result_bd.signal, self.expected_result.signal)
+
+        # Uncertainties per key should also match
+        for key in self.expected_result.uncertainties:
+            np.testing.assert_allclose(
+                result_bd.uncertainties[key],
+                self.expected_result.uncertainties[key],
+            )
+
+        # Units should be derived via pint from count / second
+        self.assertEqual(result_bd.units, self.expected_result.units)
+        # double-check as I'm having issues..
+        self.assertEqual(result_bd.units, ureg.Unit("count / second"))
+
+    def test_divide_execution_via_call(self):
+        """
+        Divide.__call__ should behave like in other ProcessSteps:
+        calling the object with ProcessingData runs the step and updates in-place.
+        """
+        divide_step = Divide(io_sources=TEST_IO_SOURCES)
+        divide_step.modify_config_by_kwargs(
+            with_processing_keys=["bundle"],
+            divisor_source="dummy",
+        )
+
+        # Execute via __call__
+        divide_step(self.test_processing_data)
+
+        result_bd: BaseData = self.test_processing_data["bundle"]["signal"]
+
+        # Same checks as in test_divide_calculation
+        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)

modacor/tests/modules/base_modules/test_find_scale_factor1d.py

@@ -0,0 +1,220 @@
+# 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__ = "12/12/2025"
+__status__ = "Development"  # "Development", "Production"
+# end of header and standard imports
+
+import numpy as np
+import pytest
+
+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.find_scale_factor1d import FindScaleFactor1D
+
+
+def _make_1d_bd(
+    arr: np.ndarray,
+    *,
+    units: str,
+    sigma: float | np.ndarray = 0.02,
+    weights: float | np.ndarray = 1.0,
+    rank_of_data: int = 1,
+) -> BaseData:
+    arr = np.asarray(arr, dtype=float)
+
+    if np.isscalar(sigma):
+        sig_arr = np.full_like(arr, float(sigma), dtype=float)
+    else:
+        sig_arr = np.asarray(sigma, dtype=float)
+        if sig_arr.size == 1:
+            sig_arr = np.full_like(arr, float(sig_arr.ravel()[0]), dtype=float)
+
+    if np.isscalar(weights):
+        w_arr = np.full_like(arr, float(weights), dtype=float)
+    else:
+        w_arr = np.asarray(weights, dtype=float)
+        if w_arr.size == 1:
+            w_arr = np.full_like(arr, float(w_arr.ravel()[0]), dtype=float)
+
+    return BaseData(
+        signal=arr,
+        units=units,
+        uncertainties={"propagate_to_all": sig_arr} if rank_of_data == 1 else {},
+        weights=w_arr,
+        axes=[],
+        rank_of_data=rank_of_data,
+    )
+
+
+def _make_curve_bundle(
+    x: np.ndarray,
+    y: np.ndarray,
+    *,
+    x_units: str = "1/nm",
+    y_units: str = "dimensionless",
+    sigma_y: float | np.ndarray = 0.02,
+    weights_y: float | np.ndarray = 1.0,
+) -> DataBundle:
+    """
+    Build a DataBundle compatible with FindScaleFactor1D's new contract:
+      - independent axis as databundle key "Q"
+      - dependent as databundle key "signal"
+    """
+    x_bd = BaseData(signal=np.asarray(x, dtype=float), units=x_units, rank_of_data=1)
+    y_bd = BaseData(
+        signal=np.asarray(y, dtype=float),
+        units=y_units,
+        uncertainties=(
+            {"propagate_to_all": np.full_like(y, float(sigma_y))}
+            if np.isscalar(sigma_y)
+            else {"propagate_to_all": np.asarray(sigma_y, dtype=float)}
+        ),
+        weights=np.full_like(y, float(weights_y)) if np.isscalar(weights_y) else np.asarray(weights_y, dtype=float),
+        rank_of_data=1,
+    )
+    return DataBundle({"signal": y_bd, "Q": x_bd})
+
+
+def _run_step(pd: ProcessingData, cfg: dict) -> None:
+    step = FindScaleFactor1D(io_sources=IoSources())
+    step.modify_config_by_dict(cfg)
+    step.execute(pd)
+
+
+def test_find_scale_factor_scale_only_perfect_overlap():
+    x = np.linspace(0.0, 10.0, 500)
+    y_work = np.sin(x) + 0.2
+    true_scale = 2.5
+    y_ref = true_scale * y_work
+
+    pd = ProcessingData()
+    pd["work"] = _make_curve_bundle(x, y_work, sigma_y=0.01)
+    pd["ref"] = _make_curve_bundle(x, y_ref, sigma_y=0.01)
+
+    _run_step(
+        pd,
+        {
+            "with_processing_keys": ["work", "ref"],
+            "fit_background": False,
+            "fit_min_val": 2.0,
+            "fit_max_val": 8.0,
+            "fit_val_units": "1/nm",
+            "require_overlap": True,
+            "robust_loss": "linear",
+            "use_basedata_weights": True,
+            "independent_axis_key": "Q",
+            "signal_key": "signal",
+        },
+    )
+
+    sf_bd = pd["work"]["scale_factor"]
+    sf = float(sf_bd.signal.item())
+    assert sf == pytest.approx(true_scale, rel=1e-3, abs=1e-3)
+
+    assert "propagate_to_all" in sf_bd.uncertainties
+    assert sf_bd.uncertainties["propagate_to_all"].size == 1
+
+
+def test_find_scale_factor_scale_and_background_mismatched_axes_robust():
+    x_w = np.linspace(0.0, 10.0, 700)
+    x_r = np.linspace(1.0, 9.0, 400)
+
+    base = np.exp(-0.2 * x_w) + 0.1 * np.cos(3 * x_w)
+    true_scale = 1.7
+    true_bg = 0.35
+
+    y_work_on_ref = np.interp(x_r, x_w, base)
+    y_ref = true_scale * y_work_on_ref + true_bg
+
+    y_ref_noisy = y_ref.copy()
+    y_ref_noisy[50] += 5.0
+    y_ref_noisy[120] -= 4.0
+
+    pd = ProcessingData()
+    pd["work"] = _make_curve_bundle(x_w, base, sigma_y=0.02)
+    pd["ref"] = _make_curve_bundle(x_r, y_ref_noisy, sigma_y=0.02)
+
+    _run_step(
+        pd,
+        {
+            "with_processing_keys": ["work", "ref"],
+            "fit_background": True,
+            "fit_min_val": 2.0,
+            "fit_max_val": 8.0,
+            "fit_val_units": "1/nm",
+            "require_overlap": True,
+            "interpolation_kind": "linear",
+            "robust_loss": "huber",
+            "robust_fscale": 1.0,
+            "use_basedata_weights": True,
+            "independent_axis_key": "Q",
+            "signal_key": "signal",
+        },
+    )
+
+    sf = float(pd["work"]["scale_factor"].signal.item())
+    bg = float(pd["work"]["scale_background"].signal.item())
+
+    assert sf == pytest.approx(true_scale, rel=3e-2, abs=3e-2)
+    assert bg == pytest.approx(true_bg, rel=3e-2, abs=3e-2)
+
+
+def test_find_scale_factor_raises_on_no_overlap_when_required():
+    x_w = np.linspace(0.0, 1.0, 200)
+    x_r = np.linspace(2.0, 3.0, 200)
+
+    pd = ProcessingData()
+    pd["work"] = _make_curve_bundle(x_w, np.ones_like(x_w), sigma_y=0.01)
+    pd["ref"] = _make_curve_bundle(x_r, np.ones_like(x_r) * 2.0, sigma_y=0.01)
+
+    with pytest.raises(ValueError, match="No overlap"):
+        _run_step(
+            pd,
+            {
+                "with_processing_keys": ["work", "ref"],
+                "require_overlap": True,
+                "independent_axis_key": "Q",
+                "signal_key": "signal",
+            },
+        )
+
+
+def test_find_scale_factor_weights_have_effect():
+    x = np.linspace(0.0, 10.0, 600)
+    y_work = 0.5 + np.sin(x)
+    true_scale = 3.0
+    y_ref = true_scale * y_work
+
+    weights_ref = np.ones_like(x)
+    weights_ref[x > 5.0] = 0.1
+
+    pd = ProcessingData()
+    pd["work"] = _make_curve_bundle(x, y_work, sigma_y=0.01, weights_y=1.0)
+    pd["ref"] = _make_curve_bundle(x, y_ref, sigma_y=0.01, weights_y=weights_ref)
+
+    _run_step(
+        pd,
+        {
+            "with_processing_keys": ["work", "ref"],
+            "fit_background": False,
+            "fit_min_val": 0.5,
+            "fit_max_val": 9.5,
+            "fit_val_units": "1/nm",
+            "robust_loss": "linear",
+            "use_basedata_weights": True,
+            "independent_axis_key": "Q",
+            "signal_key": "signal",
+        },
+    )
+
+    sf = float(pd["work"]["scale_factor"].signal.item())
+    assert sf == pytest.approx(true_scale, rel=1e-3, abs=1e-3)

modacor/tests/modules/base_modules/test_multiply.py

@@ -0,0 +1,113 @@
+# 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.multiply as multiply_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.multiply import Multiply
+
+TEST_IO_SOURCES = IoSources()
+
+
+class TestMultiplyProcessingStep(unittest.TestCase):
+    """Testing class for modacor/modules/base_modules/multiply.py"""
+
+    def setUp(self):
+        # Simple 2x3 BaseData
+        signal = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], dtype=float)
+        data_unc = 0.1 * 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
+
+        # Factor: scalar BaseData with its own unit + uncertainty
+        self.factor = BaseData(
+            signal=2.0,
+            units=ureg.Unit("second"),
+            uncertainties={"propagate_to_all": np.array(0.2, dtype=float)},
+        )
+
+        # Ground truth using BaseData.__mul__
+        self.expected_result = self.base * self.factor
+
+        # Monkeypatch basedata_from_sources
+        self._orig_basedata_from_sources = multiply_module.basedata_from_sources
+        multiply_module.basedata_from_sources = self._fake_basedata_from_sources
+
+    def tearDown(self):
+        # Restore original helper
+        multiply_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.factor."""
+        return self.factor
+
+    def test_multiply_calculation(self):
+        """
+        Multiply.calculate() should multiply the DataBundle's BaseData by the factor
+        returned from basedata_from_sources, using BaseData.__mul__ semantics.
+        """
+        step = Multiply(io_sources=TEST_IO_SOURCES)
+        step.modify_config_by_kwargs(
+            with_processing_keys=["bundle"],
+            multiplier_source="dummy",  # ignored by fake basedata_from_sources
+        )
+        step.processing_data = self.test_processing_data
+
+        step.calculate()
+
+        result_bd: BaseData = self.test_processing_data["bundle"]["signal"]
+
+        # Compare with ground truth
+        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_multiply_execution_via_call(self):
+        """
+        Multiply.__call__ should run the step and update ProcessingData in-place.
+        """
+        step = Multiply(io_sources=TEST_IO_SOURCES)
+        step.modify_config_by_kwargs(
+            with_processing_keys=["bundle"],
+            multiplier_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)

modacor/tests/modules/base_modules/test_multiply_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__ = "12/12/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.multiply_databundles import MultiplyDatabundles
+
+TEST_IO_SOURCES = IoSources()
+
+
+class TestMultiplyDatabundles(unittest.TestCase):
+    """Testing class for modacor/modules/base_modules/multiply_databundles.py"""
+
+    def setUp(self):
+        # Two simple 2x3 BaseData objects to multiply
+        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.__mul__
+        self.expected_result = self.bd1 * self.bd2
+
+    def tearDown(self):
+        pass
+
+    # ------------------------------------------------------------------ #
+    # Tests
+    # ------------------------------------------------------------------ #
+
+    def test_multiply_databundles_calculation(self):
+        """
+        MultiplyDatabundles.calculate() should multiply the second DataBundle's
+        signal with the first, using BaseData.__mul__ semantics.
+        """
+        step = MultiplyDatabundles(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 multiplicand 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_multiply_databundles_execution_via_call(self):
+        """
+        MultiplyDatabundles.__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 = MultiplyDatabundles(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):
+        """
+        MultiplyDatabundles should assert if 'with_processing_keys' does not
+        contain exactly two keys.
+        """
+        step = MultiplyDatabundles(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_poisson_uncertainties.py

@@ -0,0 +1,61 @@
+# 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__ = "15/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.poisson_uncertainties import PoissonUncertainties
+
+# import h5py
+
+TEST_IO_SOURCES = IoSources()
+
+
+class TestPoissonUncertainties(unittest.TestCase):
+    """Testing class for modacor/modules/base_modules/poisson_uncertainties.py"""
+
+    def setUp(self):
+        self.test_processing_data = ProcessingData()
+        self.test_data = BaseData(signal=np.arange(0, 100).reshape((10, 10)), units=ureg.Unit("count"))
+        self.test_data_bundle = DataBundle(signal=self.test_data)
+        self.test_processing_data["bundle"] = self.test_data_bundle
+
+    def tearDown(self):
+        pass
+
+    def test_poisson_calculation(self):
+        poisson_uncertainties = PoissonUncertainties(io_sources=TEST_IO_SOURCES)
+        poisson_uncertainties.modify_config_by_kwargs(with_processing_keys=["bundle"])
+        poisson_uncertainties.processing_data = self.test_processing_data
+        poisson_uncertainties.calculate()
+        assert "Poisson" in self.test_processing_data["bundle"]["signal"].variances.keys()
+
+    def test_poisson_execution(self):
+        poisson_uncertainties = PoissonUncertainties(io_sources=TEST_IO_SOURCES)
+        poisson_uncertainties.modify_config_by_kwargs(with_processing_keys=["bundle"])
+        poisson_uncertainties(self.test_processing_data)
+        assert "Poisson" in self.test_processing_data["bundle"]["signal"].variances.keys()
+
+    def test_poisson_result_values(self):
+        poisson_uncertainties = PoissonUncertainties(io_sources=TEST_IO_SOURCES)
+        poisson_uncertainties.modify_config_by_kwargs(with_processing_keys=["bundle"])
+        poisson_uncertainties(self.test_processing_data)
+        expected_variances = np.arange(0, 100).reshape((10, 10)).astype(float).clip(min=1)
+        actual_variances = self.test_processing_data["bundle"]["signal"].variances["Poisson"]
+        np.testing.assert_allclose(expected_variances, actual_variances)