Merge pull request #35 from BAMresearch/modifying_databundle_and_associates

change internal_units to signal_units and removing ingest and display…

Author: toqduj

src/modacor/dataclasses/basedata.py

@@ -4,10 +4,11 @@
 from typing import Dict, List, Optional, Self
 
 import numpy as np
-import pint
 from attrs import define, field
 from attrs import validators as v
 
+from modacor import ureg
+
 logger = logging.getLogger(__name__)
 
 
@@ -32,11 +33,6 @@ class BaseData:
     It is designed to be used as a base class for more specialized data classes.
     """
 
-    # Unit information using Pint units - required input (ingest, internal, and display)
-    ingest_units: pint.Unit = field(validator=v.instance_of(pint.Unit))
-    internal_units: pint.Unit = field(validator=v.instance_of(pint.Unit))
-    display_units: pint.Unit = field(validator=v.instance_of(pint.Unit))
-
     # Core data array stored as an xarray DataArray
     signal: np.ndarray = field(factory=np.ndarray, validator=[v.instance_of(np.ndarray)])
 
@@ -55,11 +51,16 @@ class BaseData:
     )
     normalization_factor: float = field(default=1.0, validator=v.instance_of(float))
     normalization_factor_variance: float = field(default=0.0, validator=v.instance_of(float))
-    normalization_units: pint.Unit = field(
-        default=pint.Unit("dimensionless"), validator=v.instance_of(pint.Unit)
+    # Unit information using Pint units - required input (ingest, internal, and display)
+    signal_units: ureg.Unit = field(
+        default=ureg.Unit("dimensionless"), validator=v.instance_of(ureg.Unit)
+    )
+
+    normalization_units: ureg.Unit = field(
+        default=ureg.Unit("dimensionless"), validator=v.instance_of(ureg.Unit)
     )
-    normalization_factor_units: pint.Unit = field(
-        default=pint.Unit("dimensionless"), validator=v.instance_of(pint.Unit)
+    normalization_factor_units: ureg.Unit = field(
+        default=ureg.Unit("dimensionless"), validator=v.instance_of(ureg.Unit)
     )
     # array with some normalization (exposure time, solid-angle ....)
 

src/modacor/modules/base_modules/multiply_by_variable.py

@@ -0,0 +1,61 @@
+__coding__ = "utf-8"
+__author__ = "Brian R. Pauw"
+__copyright__ = "MoDaCor team"
+__license__ = "BSD3"
+__date__ = "23/05/2025"
+__version__ = "20250523.1"
+__status__ = "Development"  # "Development", "Production"
+
+
+from pathlib import Path
+
+from modacor import ureg
+from modacor.dataclasses.databundle import DataBundle
+from modacor.dataclasses.process_step import ProcessStep
+from modacor.dataclasses.process_step_describer import ProcessStepDescriber
+from modacor.dataclasses.processingdata import ProcessingData
+from modacor.math.variance_calculations import divide
+
+
+class MultiplyByVariable(ProcessStep):
+    """
+    Adding Poisson uncertainties to the data
+    """
+
+    documentation = ProcessStepDescriber(
+        calling_name="Multiply by data source variable",
+        calling_id="MultiplyByVariable",
+        calling_module_path=Path(__file__),
+        calling_version=__version__,
+        required_data_keys=["signal"],
+        works_on={"signal": ["normalization_factor", "variances"]},
+        calling_arguments={"scalar": None, "scalar_units": None, "scalar_uncertainty": None},
+        step_keywords=["multiply", "variable", "scalar"],
+        step_doc="Multiply by a variable loaded from a data source",
+        step_reference="DOI 10.1088/0953-8984/25/38/383201",
+        step_note="""This loads a scalar (value, units and uncertainty)
+            from an IOSource and applies it to the data""",
+    )
+
+    def calculate(self) -> dict[str, DataBundle]:
+        """ """
+        self.processing_data: ProcessingData
+        key = self.configuration.get("with_processing_keys")
+        data: DataBundle = self.processing_data[key]
+
+        # apply factor to the data
+        f, v = divide(
+            data["signal"].normalization_factor,
+            data["signal"].normalization_factor_variances,
+            self.configuration.get("scalar"),
+            self.configuration.get("scalar_uncertainty", 0),
+        )
+        data["signal"].normalization_factor = f
+        # propagate uncertainties into normalization_factor_
+        data["signal"].normalization_factor_variances = v
+        # propagate units into normalization_factor_units
+        data["signal"].normalization_factor_units /= ureg.Unit(
+            self.configuration.get("units", "dimensionless")
+        )
+
+        return {key: data}