funcnodes-span 0.3.0__tar.gz → 0.3.2__tar.gz

{funcnodes_span-0.3.0 → funcnodes_span-0.3.2}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: funcnodes-span
-Version: 0.3.0
-Summary: Spectral Peak ANalysis (SPAN) for funcnodes
+Version: 0.3.2
+Summary: SPectral ANalysis (SPAN) for funcnodes
 License: MIT
 Author: Kourosh Rezaei
 Author-email: kouroshrezaei90@gmail.com
@@ -25,5 +25,5 @@ Project-URL: source, https://github.com/Linkdlab/funcnodes_span
 Project-URL: tracker, https://github.com/Linkdlab/funcnodes_span/issues
 Description-Content-Type: text/markdown
 
-Spectral Peak ANalysis (SPAN) for funcnodes
+SPectral ANalysis (SPAN) for funcnodes
 

funcnodes_span-0.3.2/README.md

@@ -0,0 +1 @@
+SPectral ANalysis (SPAN) for funcnodes

{funcnodes_span-0.3.0 → funcnodes_span-0.3.2}/funcnodes_span/__init__.py

@@ -7,7 +7,7 @@ from .baseline import BASELINE_NODE_SHELF as BASELINE
 from funcnodes_lmfit import NODE_SHELF as LMFIT_NODE_SHELF
 from .curves import CURVES_NODE_SHELF
 
-__version__ = "0.3.0"
+__version__ = "0.3.2"
 
 NODE_SHELF = fn.Shelf(
     name="Spectral Analysis",

{funcnodes_span-0.3.0 → funcnodes_span-0.3.2}/funcnodes_span/_curves.py

@@ -47,7 +47,7 @@ def knee_point_detection(x, y) -> Tuple[int, float, float]:
 
 
 def estimate_noise(
-    x, y, is_baseline_region: Optional[np.ndarray] = None, std_factor=3
+    x, y, is_baseline_region: Optional[np.ndarray] = None, std_factor: float = 3
 ) -> float:
     """
     Estimate the noise level in a signal.

{funcnodes_span-0.3.0 → funcnodes_span-0.3.2}/funcnodes_span/curves.py

@@ -16,6 +16,6 @@ estimate_noise_node = fn.NodeDecorator(
 CURVES_NODE_SHELF = fn.Shelf(
     nodes=[knee_point_detection_node, estimate_noise_node],
     subshelves=[],
-    name="Smoothing",
-    description="Smoothing of the spectra",
+    name="Curves",
+    description="Analysis of curves and spectra",
 )

{funcnodes_span-0.3.0 → funcnodes_span-0.3.2}/funcnodes_span/fitting.py

@@ -5,6 +5,12 @@ from lmfit.model import ModelResult
 from lmfit.models import GaussianModel
 from .peaks import PeakProperties
 from funcnodes_lmfit.model import AUTOMODELMAP
+import funcnodes as fn
+
+AutoModelEnum = fn.DataEnum("AutoModelEnum", AUTOMODELMAP)
+# class AutoModelEnum(fn.DataEnum):
+#     GaussianModel = AUTOMODELMAP["GaussianModel"]
+#     LorentzianModel = AUTOMODELMAP["LorentzianModel"]
 
 
 def group_signals(
@@ -38,6 +44,7 @@ def group_signals(
     # Assign each peak to its respective group based on start and end indices
     for pi, p in enumerate(peaks):
         ingroup = (baseline_cut >= p.i_index) & (baseline_cut <= p.f_index)
+
         if ingroup.sum() == 0:
             ingroup[(baseline_cut >= p.i_index).argmax()] = True
 
@@ -57,6 +64,9 @@ def group_signals(
         else:
             current_peak_group.update(pg)
 
+    if len(current_peak_group) > 0:
+        connected_peaks.append(list(current_peak_group))
+
     # Return a list of grouped PeakProperties
     return [[peaks[pi] for pi in cp] for cp in connected_peaks if len(cp) > 0]
 
@@ -105,12 +115,11 @@ def fit_local_peak(
     Returns:
         Model: The fitted model for the peak.
     """
+    x = np.asarray(x)
+    y = np.asarray(y)
 
-    if isinstance(model_class, str):
-        model_class = AUTOMODELMAP[model_class]
-
-    if isinstance(incomplete_peak_model_class, str):
-        incomplete_peak_model_class = AUTOMODELMAP[incomplete_peak_model_class]
+    model_class = AutoModelEnum.v(model_class)
+    incomplete_peak_model_class = AutoModelEnum.v(incomplete_peak_model_class)
 
     pf = f"p{peak.id}_"
     model = model_class(prefix=pf)  # Initialize the model
@@ -129,16 +138,11 @@ def fit_local_peak(
     if peak.yfull is None:
         peak.yfull = y
 
-    if isinstance(model_class, str):
-        model_class = AUTOMODELMAP[model_class]
-
-    if isinstance(incomplete_peak_model_class, str):
-        incomplete_peak_model_class = AUTOMODELMAP[incomplete_peak_model_class]
-
     if np.abs(yf[-1] - yf[0]) > incomplete_threshold * (local_max - local_min):
         # Handle incomplete peak by extending the range and filling gaps
         m_complete = incomplete_peak_model_class()
         guess = m_complete.guess(data=yf, x=xf)
+        guess["center"].set(min=min(xf), max=max(xf))
         fr_complete = m_complete.fit(data=yf, x=xf, params=guess, iter_cb=iter_cb)
 
         fwhm = 2 * np.sqrt(2 * np.log(2)) * fr_complete.params["sigma"].value
@@ -226,11 +230,11 @@ def fit_peak_group(
         Model: The fitted model for the group of peaks.
     """
 
-    if isinstance(model_class, str):
-        model_class = AUTOMODELMAP[model_class]
+    x = np.asarray(x)
+    y = np.asarray(y)
 
-    if isinstance(incomplete_peak_model_class, str):
-        incomplete_peak_model_class = AUTOMODELMAP[incomplete_peak_model_class]
+    model_class = AutoModelEnum.v(model_class)
+    incomplete_peak_model_class = AutoModelEnum.v(incomplete_peak_model_class)
 
     groupmodel = None
     most_left = min([p.i_index for p in peaks])  # Find the leftmost index in the group
@@ -278,12 +282,12 @@ def fit_peaks(
     peaks: List[PeakProperties],
     x: np.ndarray,
     y: np.ndarray,
-    model_class: Type[Model] = GaussianModel,
+    model_class: AutoModelEnum = AutoModelEnum.GaussianModel,
     filter_negatives: bool = True,
     baseline_factor: float = 0.001,
     incomplete_threshold: float = 0.8,
     incomplete_x_extend: float = 2.0,
-    incomplete_peak_model_class: Type[Model] = GaussianModel,
+    incomplete_peak_model_class: AutoModelEnum = AutoModelEnum.GaussianModel,
     iter_cb=None,
 ) -> Tuple[List[PeakProperties], Model, ModelResult]:
     """
@@ -337,21 +341,24 @@ def fit_peaks(
     Returns:
         Model: The fitted model for the global signal.
     """
-    if isinstance(model_class, str):
-        model_class = AUTOMODELMAP[model_class]
-
-    if isinstance(incomplete_peak_model_class, str):
-        incomplete_peak_model_class = AUTOMODELMAP[incomplete_peak_model_class]
+    model_class = AutoModelEnum.v(model_class)
+    incomplete_peak_model_class = AutoModelEnum.v(incomplete_peak_model_class)
+    x = np.asarray(x)
+    y = np.asarray(y)
 
     if len(peaks) == 0:
         raise ValueError("No peaks provided for fitting.")
 
     # Group peaks based on the baseline factor
     connected_peaks = group_signals(x, y, peaks, baseline_factor=baseline_factor)
+    if len(connected_peaks) == 0:
+        raise ValueError("No peaks after grouping.")
 
     global_model = None
     # Fit each peak group
     for pg in connected_peaks:
+        if len(pg) == 0:
+            continue
         m = fit_peak_group(
             x,
             y,
@@ -369,6 +376,9 @@ def fit_peaks(
             # Combine models for all peak groups
             global_model += m
 
+    if global_model is None:
+        raise ValueError("No model created")
+
     # Fit the global model to the full data
     global_fit = global_model.fit(data=y, x=x, iter_cb=iter_cb)
 
@@ -381,3 +391,25 @@ def fit_peaks(
         peak.model = get_submodel_by_prefix(global_model, f"p{peak.id}_")
 
     return peaks, global_model, global_fit
+
+
+def peaks_from_fitted(fitted_peaks: List[PeakProperties]) -> List[PeakProperties]:
+    peaks = []
+    from .peak_analysis import peak_finder  # noaq Avoid circular import
+
+    for p in fitted_peaks:
+        model = p.model
+        mparams = model.make_params()
+        y = model.eval(x=p.xfull, params=mparams)
+        pf: List[PeakProperties] = peak_finder.o_func(y=y, x=p.xfull)[0]
+        if len(pf) != 1:
+            raise ValueError("Expected one peak")
+        pf = pf[0]
+        pf._id = f"fitted_{p.id}"
+        pf.model = model
+        p.add_serializable_property("model", str(model))
+        for k, v in mparams.items():
+            p.add_serializable_property(k.replace(model.prefix, ""), v.value)
+        peaks.append(pf)
+
+    return peaks

{funcnodes_span-0.3.0 → funcnodes_span-0.3.2}/funcnodes_span/peak_analysis.py

@@ -2,7 +2,7 @@ from funcnodes import NodeDecorator, Shelf
 import funcnodes as fn
 import numpy as np
 from exposedfunctionality import controlled_wrapper
-from typing import Optional, List, Tuple, Union
+from typing import Optional, List, Tuple
 from scipy.signal import find_peaks
 from scipy.stats import norm
 from scipy import signal, interpolate
@@ -12,7 +12,13 @@ import plotly.graph_objs as go
 from .normalization import density_normalization
 from .peaks import PeakProperties
 
-from .fitting import fit_peaks, AUTOMODELMAP, fit_local_peak
+from .fitting import fit_peaks, AUTOMODELMAP, fit_local_peak, peaks_from_fitted
+
+# make enum from AUTOMODELMAP
+AutoModelEnum = fn.DataEnum(
+    "AutoModelEnum",
+    AUTOMODELMAP,
+)
 
 
 @NodeDecorator(
@@ -217,32 +223,32 @@ def interpolation_1d(
 def force_peak_finder(
     x: np.array,
     y: np.array,
-    basic_peaks: Union[List[PeakProperties], PeakProperties],
+    basic_peak: PeakProperties,
 ) -> List[PeakProperties]:
-    # """
-    # Identify and return the two peaks around the main peak in the given peaks dictionary.
-
-    # Parameters:
-    # - peaks (dict): A dictionary containing peak information.
-    #                 It should have the keys 'peaks' and 'data'.
-    #                 'peaks' should contain a list of dictionaries with keys 'Initial index', 'Index',
-    #                  and 'Ending index'.
-    #                 'data' should contain arrays 'x' and 'y'.
-
-    # Returns:
-    # - dict: A dictionary containing information about the two identified peaks.
-    # """
-    if isinstance(basic_peaks, (list, np.ndarray, tuple)):
-        if len(basic_peaks) != 1:
-            raise ValueError(
-                "This method accepts one and only one main peak as an input."
-            )
-        basic_peaks = basic_peaks[0]
+    """
+    Breaks down a given main peak into two individual peaks.
+
+    The function works by calculating the first and second derivatives of the signal and
+    finding the local maxima and minima of the derivatives. It then determines which peak
+    is on the left and right side of the main peak by comparing the distance between the
+    main peak and the closest peak on either side.
+
+    Parameters:
+    - x (np.array): The x-values of the signal.
+    - y (np.array): The y-values of the signal.
+    - basic_peak (PeakProperties): The main peak.
+
+    Returns:
+    - List[PeakProperties]: A list of two PeakProperties objects, one for each of the
+      individual peaks.
+    """
+    if not isinstance(basic_peak, PeakProperties):
+        raise TypeError("The basic peak must be a single PeakProperties object.")
 
-    peaks = copy.deepcopy(basic_peaks)
-    main_peak_i_index = peaks.i_index
-    main_peak_r_index = peaks.index
-    main_peak_f_index = peaks.f_index
+    peak = copy.deepcopy(basic_peak)
+    main_peak_i_index = peak.i_index
+    main_peak_r_index = peak.index
+    main_peak_f_index = peak.f_index
     y_array = y
     x_array = x
     # Calculate first and second derivatives
@@ -260,9 +266,9 @@ def force_peak_finder(
     max_pp = signal.argrelmax(y_array_pp)[0]
     # min_pp = signal.argrelmin(y_array_pp)[0]
 
-    # main_peak_i_index = peaks.i_index
-    # main_peak_r_index = peaks.index
-    # main_peak_f_index = peaks.f_index
+    # main_peak_i_index = peak.i_index
+    # main_peak_r_index = peak.index
+    # main_peak_f_index = peak.f_index
 
     # Determine which peak is on the left and right side of the main peak
     if (
@@ -300,10 +306,11 @@ def force_peak_finder(
     peak_lst = []
     peak_lst.append([peak1["I.Index"], peak1["R.Index"], peak1["F.Index"]])
     peak_lst.append([peak2["I.Index"], peak2["R.Index"], peak2["F.Index"]])
+
     peak_properties_list = []
     for peak_nr, peak in enumerate(peak_lst):
         peak_properties = PeakProperties(
-            id=basic_peaks.id + f"_{peak_nr + 1}",
+            id=basic_peak.id + f"_{peak_nr + 1}",
             i_index=peak[0],
             index=peak[1],
             f_index=peak[2],
@@ -547,18 +554,47 @@ fit_peak_node = fn.NodeDecorator(
     id="span.peaks.fit_peak",
     name="Fit Peak",
     outputs=[{"name": "fitted_peak"}, {"name": "model"}, {"name": "fit_result"}],
-    # separate_process=True,
+    separate_process=True,
 )(fit_local_peak)
 
+
 fit_peaks_node = fn.NodeDecorator(
     id="span.peaks.fit_peaks",
     name="Fit Peaks",
     outputs=[{"name": "fitted_peaks"}, {"name": "model"}, {"name": "fit_results"}],
-    default_io_options={
-        "modelname": {"value_options": {"options": list(AUTOMODELMAP.keys())}},
-    },
-    separate_process=True,
+    # separate_process=True,
 )(fit_peaks)
+# @fn.controlled_wrapper(fit_peaks, wrapper_attribute="__fnwrapped__")
+# def fit_peaks_node(
+#     peaks: List[PeakProperties],
+#     x: np.ndarray,
+#     y: np.ndarray,
+#     model_class: AutoModelEnum = AutoModelEnum.v("GaussianModel"),
+#     filter_negatives: bool = True,
+#     baseline_factor: float = 0.001,
+#     incomplete_threshold: float = 0.8,
+#     incomplete_x_extend: float = 2.0,
+#     incomplete_peak_model_class: AutoModelEnum = AutoModelEnum.v("GaussianModel"),
+# ) -> Tuple[List[PeakProperties], Model, ModelResult]:
+#     return fit_peaks(
+#         peaks,
+#         x,
+#         y,
+#         model_class=AutoModelEnum.v(model_class),
+#         filter_negatives=filter_negatives,
+#         baseline_factor=baseline_factor,
+#         incomplete_threshold=incomplete_threshold,
+#         incomplete_x_extend=incomplete_x_extend,
+#         incomplete_peak_model_class=AutoModelEnum.v(incomplete_peak_model_class),
+#     )
+
+
+peaks_from_fitted_node = fn.NodeDecorator(
+    id="span.peaks.peaks_from_fitted",
+    name="Peaks from fitted",
+    description="converts the fit data in peaks to regular peaks",
+    outputs=[{"name": "peaks"}],
+)(peaks_from_fitted)
 
 PEAKS_NODE_SHELF = Shelf(
     nodes=[
@@ -568,6 +604,7 @@ PEAKS_NODE_SHELF = Shelf(
         plot_peaks,
         fit_peaks_node,
         fit_peak_node,
+        peaks_from_fitted_node,
         plot_fitted_peaks,
         plot_peak,
     ],

{funcnodes_span-0.3.0 → funcnodes_span-0.3.2}/funcnodes_span/smoothing.py

@@ -93,12 +93,14 @@ def _smooth(
 
     if mode not in _SMOOTHING_MAPPER.keys():
         raise ValueError(f"Unsupported smoothing mode: {mode}")
-
+    y = np.asarray(y)
     if x is not None:
+        x = np.asarray(x)
         med_xdiff = np.nanmedian(np.diff(x))
         window = window / med_xdiff
     window = int(window)
-
+    if window == 0:
+        return y.copy()
     return _SMOOTHING_MAPPER[mode](y, window)
 
 

{funcnodes_span-0.3.0 → funcnodes_span-0.3.2}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "funcnodes-span"
-version = "0.3.0"
-description = "Spectral Peak ANalysis (SPAN) for funcnodes"
+version = "0.3.2"
+description = "SPectral ANalysis (SPAN) for funcnodes"
 authors = ["Kourosh Rezaei <kouroshrezaei90@gmail.com>"]
 readme = "README.md"
 license = "MIT"
@@ -28,7 +28,7 @@ funcnodes-lmfit = "*"
 [tool.poetry.group.dev.dependencies]
 pytest = "*"
 pre-commit = "*"
-funcnodes-module = "*"
+funcnodes-module = "^0.1.19"
 pooch = "*"
 
 

funcnodes_span-0.3.0/README.md

@@ -1 +0,0 @@
-Spectral Peak ANalysis (SPAN) for funcnodes