screamlab 0.1.0__tar.gz → 0.3.1__tar.gz

{screamlab-0.1.0/screamlab.egg-info → screamlab-0.3.1}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: screamlab
-Version: 0.1.0
+Version: 0.3.1
 Summary: Package for reproducible evaluation of SCREAM-DNP data.
 Home-page: https://github.com/FlorianTaube/screamlab
 Author: Florian Taube
 Author-email: florian.taube@uni-rostock.de
 License: BSD
-Project-URL: Documentation, https://github.com/FlorianTaube/screamlab/docs
+Project-URL: Documentation, https://screamlab.readthedocs.io
 Project-URL: Source, https://github.com/FlorianTaube/screamlab/screamlab
 Keywords: Buildup Time Calculator,NMR,DNP,SCREAM_DNP,TopspinExport
 Classifier: Programming Language :: Python :: 3

screamlab-0.3.1/VERSION

@@ -0,0 +1 @@
+0.3.1

{screamlab-0.1.0 → screamlab-0.3.1}/screamlab/dataset.py

@@ -12,8 +12,10 @@ Classes:
 
 """
 
+import sys
 from datetime import datetime
 import numpy as np
+from lmfit import Parameters
 from screamlab import io, utils, settings, functions
 
 
@@ -66,12 +68,17 @@ class Dataset:
         print(
             f"{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}: Start buildup fit."
         )
+
         self._start_buildup_fit()
         print(
             f"{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}: "
             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."""
@@ -86,6 +93,7 @@ class Dataset:
         fitting_type="voigt",
         peak_sign="-",
         line_broadening=None,
+        integration_range=None,
     ):
         """
         Adds a peak to the ds.
@@ -94,7 +102,7 @@ class Dataset:
         ----------
             center_of_peak (float): Peak position in ppm (chemical shift).
             peak_label (str, optional): Custom label. Defaults to "Peak_at_<ppm>_ppm".
-            fitting_type (str, optional): Peak shape: "gauss", "lorentz", or "voigt" (default).
+            fitting_type (str, optional): Peak shape:  "gauss", "lorentz", or "voigt" (default).
             peak_sign (str, optional): "+" for upward, "-" for downward peaks. Defaults to "+".
             line_broadening (dict, optional): Dict with "sigma" and "gamma" keys for line width.
                 Defaults to {"sigma": {"min": 0, "max": 3}, "gamma": {"min": 0, "max": 3}}.
@@ -109,6 +117,7 @@ class Dataset:
         peak.fitting_type = fitting_type
         peak.peak_sign = peak_sign
         peak.line_broadening = line_broadening
+        peak.integration_range = integration_range
 
     def _read_in_data_from_topspin(self):
         """Reads and imports data from TopSpin."""
@@ -132,7 +141,7 @@ class Dataset:
 
     def _calculate_peak_intensities(self):
         """Calculates peak intensities based on fitting methods."""
-        if self.props.prefit:
+        if self.props.prefit and self.props.spectrum_fit_type != "numint":
             print(
                 f"{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}: Start prefit."
             )
@@ -148,7 +157,7 @@ class Dataset:
             result = self.fitter.fit()
             self.lmfit_result_handler.global_fit = result
             self._get_intensities(result)
-        if "global" == self.props.spectrum_fit_type:
+        elif "global" == self.props.spectrum_fit_type:
             print(
                 f"{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}: Start global fit."
             )
@@ -156,6 +165,15 @@ class Dataset:
             result = self.fitter.fit()
             self.lmfit_result_handler.global_fit = result
             self._get_intensities(result)
+        elif "numint" == self.props.spectrum_fit_type:
+            print(
+                f"{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}: Start integration."
+            )
+            self._set_integration_calc()
+            result = self.fitter.fit()
+            self._get_intensities(result)
+        else:
+            sys.exit()
 
     def _start_buildup_fit(self):
         """Performs buildup fitting using the appropriate fitter classes."""
@@ -164,7 +182,9 @@ class Dataset:
             "biexponential_with_offset": utils.BiexpFitterWithOffset,
             "exponential": utils.ExpFitter,
             "exponential_with_offset": utils.ExpFitterWithOffset,
-            "streched_exponential": utils.StrechedExponentialFitter,
+            "stretched_exponential": utils.StrechedExponentialFitter,
+            "exponential_decay": utils.ExpDecayFitter,
+            "exponential_decay_with_offset": utils.ExpDecayFitterWithOffset,
         }
 
         for b_type in self.props.buildup_types:
@@ -187,10 +207,18 @@ class Dataset:
         """Sets up a global fitter for all spectra."""
         self.fitter = utils.GlobalFitter(self)
 
+    def _set_integration_calc(self):
+        self.fitter = utils.NumericalIntegration(self)
+
     def _get_intensities(self, result):
         """Extracts intensity values from the fitting results."""
         if isinstance(
-            self.fitter, (utils.IndependentFitter, utils.GlobalFitter)
+            self.fitter,
+            (
+                utils.IndependentFitter,
+                utils.GlobalFitter,
+                utils.NumericalIntegration,
+            ),
         ):
             for peak in self.peak_list:
                 peak.buildup_vals = (result, self.spectra)
@@ -213,6 +241,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:
     """
@@ -257,6 +300,7 @@ class Peak:
         self._line_broadening = None
         self._line_broadening_init = None
         self._buildup_vals = None
+        self._integration_range = None
 
     def __str__(self):
         """
@@ -277,6 +321,34 @@ class Peak:
             f" {self._format_fitting_range('')}"
         )
 
+    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"
+                f"Peak label: {self.peak_label}\n"
+                f"Peak sign: {self.peak_sign}\n"
+                f"Numerical integration range: {self.integration_range} ppm\n"
+            )
+        return str(self)
+
     def _format_fitting_range(self, fit_type):
         a_max = "0 and inf" if self.peak_sign == "+" else "-inf and 0"
         lb = ""
@@ -297,6 +369,34 @@ class Peak:
             f"{lb}"
         )
 
+    @property
+    def integration_range(self) -> list:
+        """
+        Gets the integration range.
+
+        :return:
+        """
+        return self._integration_range
+
+    @integration_range.setter
+    def integration_range(self, args):
+        """
+        Sets the integration range.
+
+        :param args: List containing the integration range for numerical integragtion.
+        """
+        if args is not None:
+            if (
+                not isinstance(args, list)
+                or len(args) != 2
+                or not all(isinstance(e, (int, float)) for e in args)
+            ):
+                raise TypeError(
+                    "Integration range must be a list of two numbers or None."
+                )
+
+        self._integration_range = args
+
     @property
     def buildup_vals(self) -> list:
         """
@@ -315,7 +415,10 @@ class Peak:
         """
         result, spectra = args
         self._buildup_vals = BuildupList()
-        self._buildup_vals.set_vals(result, spectra, self.peak_label)
+        if isinstance(result, dict):
+            self._buildup_vals.set_num_int_vals(result[self], spectra)
+        else:
+            self._buildup_vals.set_vals(result, spectra, self.peak_label)
 
     @property
     def line_broadening(self) -> str:
@@ -600,6 +703,21 @@ class BuildupList:
         self._set_intensity(result, label, spectra)
         self._sort_lists()
 
+    def set_num_int_vals(self, result, spectra):
+        """
+        Sets buildup values from numerical integration.
+
+        Attributes
+        ----------
+            result (list): Intensity values
+            spectra (list): Spectrum objects used with result to compute buildup.
+            label (str): Peak label used to filter relevant parameters in result.
+
+        """
+        self._set_tpol(spectra)
+        self.intensity = result
+        self._sort_lists()
+
     def _set_tpol(self, spectra):
         self.tpol = [s.tpol for s in spectra]
 
@@ -607,20 +725,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)])
         )
@@ -641,6 +765,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.1.0 → screamlab-0.3.1}/screamlab/functions.py

@@ -169,6 +169,48 @@ def calc_stretched_exponential(time_vals, param):
     )
 
 
+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 +287,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 +320,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 +379,9 @@ def format_mapping():
             "Sf",
             "---",
             "---",
+            "---",
         ],
-        "streched_exponential": [
+        "stretched_exponential": [
             "Af",
             "tf",
             "---",
@@ -315,6 +392,7 @@ def format_mapping():
             "Sf",
             "---",
             "beta",
+            "---",
         ],
         "exponential_with_offset": [
             "Af",
@@ -327,6 +405,7 @@ def format_mapping():
             "Sf",
             "---",
             "---",
+            "---",
         ],
         "biexponential": [
             "Af",
@@ -339,6 +418,7 @@ def format_mapping():
             "Sf",
             "Ss",
             "---",
+            "---",
         ],
         "biexponential_with_offset": [
             "Af",
@@ -351,6 +431,33 @@ def format_mapping():
             "Sf",
             "Ss",
             "---",
+            "---",
+        ],
+        "exponential_decay": [
+            "Af",
+            "tf",
+            "---",
+            "---",
+            "---",
+            "Rf",
+            "---",
+            "Sf",
+            "---",
+            "---",
+            "---",
+        ],
+        "exponential_decay_with_offset": [
+            "Af",
+            "tf",
+            "---",
+            "---",
+            "---",
+            "Rf",
+            "---",
+            "Sf",
+            "---",
+            "---",
+            "I0",
         ],
     }
 
@@ -368,7 +475,8 @@ def buildup_header():
         "Rs / 1/s",
         "Sensitivity1 (Af/sqrt(tf))",
         "Sensitivity2 (As/sqrt(ts))",
-        "beta",
+        "beta / a.u.",
+        "I0 / a.u.",
     ]
 
 
@@ -395,7 +503,9 @@ 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,
     }