screamlab 0.3.0__tar.gz → 0.3.2__tar.gz

{screamlab-0.3.0/screamlab.egg-info → screamlab-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: screamlab
-Version: 0.3.0
+Version: 0.3.2
 Summary: Package for reproducible evaluation of SCREAM-DNP data.
 Home-page: https://github.com/FlorianTaube/screamlab
 Author: Florian Taube

screamlab-0.3.2/VERSION

@@ -0,0 +1 @@
+0.3.2

{screamlab-0.3.0 → screamlab-0.3.2}/screamlab/dataset.py

@@ -15,6 +15,7 @@ Classes:
 import sys
 from datetime import datetime
 import numpy as np
+from lmfit import Parameters
 from screamlab import io, utils, settings, functions
 
 
@@ -74,6 +75,10 @@ class Dataset:
             f"Start generating result files. ({self.props.output_folder})"
         )
         self._print_all()
+        print(
+            f"{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}: "
+            f"Finished with {self.props.path_to_experiment}"
+        )
 
     def _start_buildup_fit_from_spectra(self):
         """Starts buildup fitting using data imported from spectra CSV files."""
@@ -177,7 +182,11 @@ class Dataset:
             "biexponential_with_offset": utils.BiexpFitterWithOffset,
             "exponential": utils.ExpFitter,
             "exponential_with_offset": utils.ExpFitterWithOffset,
-            "streched_exponential": utils.StrechedExponentialFitter,
+            "stretched_exponential": utils.StretchedExponentialFitter,
+            "exponential_decay": utils.ExpDecayFitter,
+            "exponential_decay_with_offset": utils.ExpDecayFitterWithOffset,
+            "stretched_exponential_decay": utils.StretchedExponentialDecayFitter,
+            "biexponential_decay": utils.BiexponentialDecayFitter,
         }
 
         for b_type in self.props.buildup_types:
@@ -234,6 +243,21 @@ class Dataset:
                 if f"{peak.peak_label}_{lw}_0" in result.params
             }
 
+    def _transform_result_format(self, results):
+        print(results)
+        params_new = Parameters()
+        for result in results:
+            for name, par in result.params.items():
+                params_new.add(
+                    name,
+                    value=par.value,
+                    vary=par.vary,
+                    min=par.min,
+                    max=par.max,
+                    expr=par.expr,
+                )
+        return params_new
+
 
 class Spectra:
     """
@@ -286,7 +310,6 @@ class Peak:
 
         :return: A string describing the peak's attributes.
         """
-
         return (
             f"Peak center: {self.peak_center}\n"
             f"Peak label: {self.peak_label}\n"
@@ -301,6 +324,24 @@ class Peak:
         )
 
     def to_string(self, spectrum_fit_type):
+        """
+        Returns a string representation of the peak.
+
+        If `spectrum_fit_type` is "numint", detailed peak information
+        is returned, including center, label, sign, and integration range.
+        Otherwise, the default string representation of the object is returned.
+
+        Args:
+            spectrum_fit_type (str): The type of spectrum fitting.
+                Supports "numint" for numerical integration.
+
+        Returns
+        -------
+            str: A formatted string with peak information, or the default
+                string representation of the object.
+
+
+        """
         if spectrum_fit_type == "numint":
             return (
                 f"Peak center: {self.peak_center} ppm\n"
@@ -308,8 +349,7 @@ class Peak:
                 f"Peak sign: {self.peak_sign}\n"
                 f"Numerical integration range: {self.integration_range} ppm\n"
             )
-        else:
-            return str(self)
+        return str(self)
 
     def _format_fitting_range(self, fit_type):
         a_max = "0 and inf" if self.peak_sign == "+" else "-inf and 0"
@@ -376,12 +416,9 @@ class Peak:
         :param args: Tuple containing result and spectra.
         """
         result, spectra = args
-
         self._buildup_vals = BuildupList()
         if isinstance(result, dict):
-            self._buildup_vals.set_num_int_vals(
-                result[self], spectra, self.peak_label
-            )
+            self._buildup_vals.set_num_int_vals(result[self], spectra)
         else:
             self._buildup_vals.set_vals(result, spectra, self.peak_label)
 
@@ -668,7 +705,7 @@ class BuildupList:
         self._set_intensity(result, label, spectra)
         self._sort_lists()
 
-    def set_num_int_vals(self, result, spectra, label):
+    def set_num_int_vals(self, result, spectra):
         """
         Sets buildup values from numerical integration.
 
@@ -690,20 +727,26 @@ class BuildupList:
         last_digid = None
         self.intensity = []
         val_list = []
-        for param in result.params:
-            if label in param:
-                if last_digid != param.split("_")[-1]:
-                    if val_list:
-                        self.intensity.append(
-                            self._calc_integral(
-                                val_list, spectra[int(last_digid)]
+        res_list = []
+        if not isinstance(result, list):
+            res_list.append(result)
+        else:
+            res_list = result
+        for single_result in res_list:
+            for param in single_result.params:
+                if label in param:
+                    if last_digid != param.split("_")[-1]:
+                        if val_list:
+                            self.intensity.append(
+                                self._calc_integral(
+                                    val_list, spectra[int(last_digid)]
+                                )
                             )
-                        )
-                    last_digid = param.split("_")[-1]
-                    val_list = []
-                val_list.append(float(result.params[param].value))
-                if param.split("_")[-2] == "gamma":
-                    val_list.append("gamma")
+                        last_digid = param.split("_")[-1]
+                        val_list = []
+                    val_list.append(float(single_result.params[param].value))
+                    if param.split("_")[-2] == "gamma":
+                        val_list.append("gamma")
         self.intensity.append(
             self._calc_integral(val_list, spectra[int(last_digid)])
         )
@@ -724,6 +767,8 @@ class BuildupList:
         """
         simspec = [0 for _ in range(len(spectrum.x_axis))]
         simspec = functions.calc_peak(spectrum.x_axis, simspec, val_list)
+        if hasattr(np, "trapezoid"):
+            return np.trapezoid(simspec)
         return np.trapz(simspec)
 
     def _sort_lists(self):

{screamlab-0.3.0 → screamlab-0.3.2}/screamlab/functions.py

@@ -169,6 +169,95 @@ def calc_stretched_exponential(time_vals, param):
     )
 
 
+def calc_stretchedexpdecay(time_vals, param):
+    """
+    Compute values of a stretched exponential decay function over time.
+
+    The function models the equation:
+        I(t) = Af * exp((-t / tf)^beta)
+
+    where:
+        - I(t)  : The output value at time t
+        - A     : Amplitude (maximum value the function approaches)
+        - tf    : Time constant (controls the rate of growth)
+        - beta  : stretching exponent
+
+    Returns
+    -------
+        list: Stretched exponential profile evaluated at t.
+
+    """
+    return list(
+        param[0] * np.exp(-((np.asarray(time_vals) / param[1]) ** param[2]))
+    )
+
+
+def calc_biexpdecay(time_vals, param):
+    """
+    Compute values of a biexponential decay function over time.
+
+    The function models the equation:
+        I(t) = Af * exp(-t / tf)) + As * exp(-t / ts))
+
+    where:
+        - I(t)  : The output value at time t
+        - Af, As: Amplitudes (maximum value the function approaches)
+        - tf, ts: Time constants (controls the rate of growth)
+
+
+    Returns
+    -------
+        list: Biexponential profile evaluated at t.
+
+    """
+    return list(
+        param[0] * np.exp(-np.asarray(time_vals) / param[2])
+        + param[1] * np.exp(-np.asarray(time_vals) / param[3])
+    )
+
+
+def calc_expdecay(time_vals, param):
+    """
+    Compute values of an exponential growth function over time.
+
+    The function models the equation:
+        I(t) = A * exp(-t / t)
+
+    where:
+        - I(t)  : The output value at time t
+        - A     : Amplitude (maximum value the function approaches)
+        - t    : Time constant (controls the rate of decay)
+
+    Returns
+    -------
+        list: Exponential profile evaluated at t.
+
+    """
+    return list(param[0] * np.exp(-np.asarray(time_vals) / param[1]))
+
+
+def calc_expdecaywithoffset(time_vals, param):
+    """
+    Compute values of an exponential growth function over time.
+
+    The function models the equation:
+        I(t) = A * exp(-t / t) + I0
+
+    where:
+        - I(t)  : The output value at time t
+        - A     : Amplitude (maximum value the function approaches)
+        - t    : Time constant (controls the rate of decay)
+
+    Returns
+    -------
+        list: Exponential profile evaluated at t.
+
+    """
+    return list(
+        param[0] * np.exp(-np.asarray(time_vals) / param[1]) + param[2]
+    )
+
+
 def calc_biexponential(time_vals, param):
     """
     Compute values of a biexponential growth function over time.
@@ -245,7 +334,7 @@ def calc_biexponential_with_offset(time_vals, param):
     )
 
 
-def generate_spectra_param_dict(params):
+def generate_spectra_param_dict_global(params):
     """
     Generate a dictionary of spectral parameters from a list of parameter names.
 
@@ -278,6 +367,40 @@ def generate_spectra_param_dict(params):
     return param_dict
 
 
+def generate_spectra_param_dict_individual(params):
+    """
+    Generate a dictionary of spectral parameters from a list of parameter names.
+
+    :param params: Dictionary of parameter names and values.
+    :return: Dictionary of structured parameter values.
+    """
+    param_dict = {}
+    dict_index = -1
+    for list_element in params:
+        prefix, lastfix = None, None
+        param_value_list = []
+        for param in list_element.params:
+            parts = re.split(r"_(cen|amp|sigma|gamma)_", param)
+            if prefix != parts[0]:
+                if param_value_list:
+                    param_dict[dict_index].append(param_value_list)
+                prefix = parts[0]
+                param_value_list = []
+            if lastfix != parts[2]:
+                if param_value_list:
+                    param_dict[dict_index].append(param_value_list)
+                    param_value_list = []
+                lastfix = parts[2]
+                dict_index += 1
+            if dict_index not in param_dict:
+                param_dict[dict_index] = []
+            param_value_list.append(float(list_element.params[param].value))
+            if parts[1] == "gamma":
+                param_value_list.append("gam")
+        param_dict[dict_index].append(param_value_list)
+    return param_dict
+
+
 def calc_peak(x_axis, simspec, val):
     """Simulates spectra based on given parameters."""
     if len(val) == 5:
@@ -303,8 +426,9 @@ def format_mapping():
             "Sf",
             "---",
             "---",
+            "---",
         ],
-        "streched_exponential": [
+        "stretched_exponential": [
             "Af",
             "tf",
             "---",
@@ -315,6 +439,7 @@ def format_mapping():
             "Sf",
             "---",
             "beta",
+            "---",
         ],
         "exponential_with_offset": [
             "Af",
@@ -327,6 +452,7 @@ def format_mapping():
             "Sf",
             "---",
             "---",
+            "---",
         ],
         "biexponential": [
             "Af",
@@ -339,6 +465,7 @@ def format_mapping():
             "Sf",
             "Ss",
             "---",
+            "---",
         ],
         "biexponential_with_offset": [
             "Af",
@@ -351,6 +478,59 @@ def format_mapping():
             "Sf",
             "Ss",
             "---",
+            "---",
+        ],
+        "exponential_decay": [
+            "Af",
+            "tf",
+            "---",
+            "---",
+            "---",
+            "Rf",
+            "---",
+            "Sf",
+            "---",
+            "---",
+            "---",
+        ],
+        "exponential_decay_with_offset": [
+            "Af",
+            "tf",
+            "---",
+            "---",
+            "---",
+            "Rf",
+            "---",
+            "Sf",
+            "---",
+            "---",
+            "I0",
+        ],
+        "stretched_exponential_decay": [
+            "Af",
+            "tf",
+            "---",
+            "---",
+            "---",
+            "Rf",
+            "---",
+            "Sf",
+            "---",
+            "beta",
+            "---",
+        ],
+        "biexponential_decay": [
+            "Af",
+            "tf",
+            "As",
+            "ts",
+            "---",
+            "Rf",
+            "Rs",
+            "Sf",
+            "Ss",
+            "---",
+            "---",
         ],
     }
 
@@ -368,7 +548,8 @@ def buildup_header():
         "Rs / 1/s",
         "Sensitivity1 (Af/sqrt(tf))",
         "Sensitivity2 (As/sqrt(ts))",
-        "beta",
+        "beta / a.u.",
+        "I0 / a.u.",
     ]
 
 
@@ -395,7 +576,11 @@ def return_func_map():
         "biexponential": calc_biexponential,
         "exponential_with_offset": calc_exponential_with_offset,
         "biexponential_with_offset": calc_biexponential_with_offset,
-        "streched_exponential": calc_stretched_exponential,
+        "stretched_exponential": calc_stretched_exponential,
+        "exponential_decay": calc_expdecay,
+        "exponential_decay_with_offset": calc_expdecaywithoffset,
+        "stretched_exponential_decay": calc_stretchedexpdecay,
+        "biexponential_decay": calc_biexpdecay,
     }