masster 0.3.11__py3-none-any.whl → 0.3.12__py3-none-any.whl

masster/sample/helpers.py

@@ -92,9 +92,6 @@ def get_dda_stats(self):
     return ms1
 
 
-# TODO
-
-
 def get_feature(self, feature_uid):
     # get the feature with feature_uid == feature_uid
     feature = self.features_df.filter(pl.col("feature_uid") == feature_uid)
@@ -284,7 +281,59 @@ def select_closest_scan(
     return scan
 
 
-# TODO the variables here do not follow the rest (mz, rt being tuples, etc.)
+def get_eic(self, mz, mz_tol=0.01):
+    """
+    Extract an extracted ion chromatogram (EIC) from `ms1_df` for a target m/z ± mz_tol.
+
+    The function filters `self.ms1_df` for rows with `mz` within the tolerance, aggregates
+    intensities per retention time (summing intensities for the same `rt`), sorts by `rt`,
+    stores the resulting chromatogram in `self.chrom_df` and returns it.
+
+    Parameters:
+        mz (float): target m/z value
+        mz_tol (float): tolerance around mz (default 0.01)
+
+    Returns:
+        polars.DataFrame or None: chromatogram with columns ['rt', 'inty'] or None if not available
+    """
+    # Validate ms1_df
+    if not hasattr(self, "ms1_df") or self.ms1_df is None:
+        if hasattr(self, "logger"):
+            self.logger.warning("No ms1_df available to build EIC.")
+        return None
+
+    try:
+        # Filter by mz window
+        mz_min = mz - mz_tol
+        mz_max = mz + mz_tol
+        matches = self.ms1_df.filter((pl.col("mz") >= mz_min) & (pl.col("mz") <= mz_max))
+
+        if len(matches) == 0:
+            if hasattr(self, "logger"):
+                self.logger.debug(f"No ms1 points found for mz={mz} ± {mz_tol}.")
+            # ensure chrom_df is None when nothing found
+            self.chrom_df = None
+            return None
+
+        # Aggregate intensities per retention time. Use sum in case multiple points per rt.
+        chrom = (
+            matches.group_by("rt")
+            .agg([pl.col("inty").sum().alias("inty")])
+            .sort("rt")
+        )
+
+        # Attach to Sample
+        self.chrom_df = chrom
+
+        if hasattr(self, "logger"):
+            self.logger.debug(f"Built EIC for mz={mz} ± {mz_tol}: {len(chrom)} points.")
+
+        return chrom
+
+    except Exception as e:
+        if hasattr(self, "logger"):
+            self.logger.error(f"Error building EIC for mz={mz}: {e}")
+        return None
 
 
 def select(

masster/sample/plot.py

@@ -56,6 +56,7 @@ from bokeh.models import HoverTool
 from holoviews import dim
 from holoviews.plotting.util import process_cmap
 from matplotlib.colors import rgb2hex
+from masster.chromatogram import Chromatogram
 
 # Parameters removed - using hardcoded defaults
 
@@ -1966,19 +1967,102 @@ def plot_tic(
     title=None,
     filename=None,
 ):
-    # get all ms_level ==1 scans from sefl.scans_df
-    scans = self.scans_df.filter(pl.col("ms_level") == 1)
-    # select rt, scan_uid and inty_tot, convert to pandas
-    data = scans[["rt", "scan_uid", "inty_tot"]].to_pandas()
-    # sort by rt
-    data = data.sort_values("rt")
-
-    # plot using hv.Curve
-    tic = hv.Curve(data, kdims=["rt"], vdims=["inty_tot"])
-    tic.opts(
-        title=title,
-        xlabel="Retention Time (min)",
-        ylabel="TIC",
-        height=250,
-        width=100,
-    )
+    """
+    Plot Total Ion Chromatogram (TIC) by summing MS1 peak intensities at each retention time.
+
+    Uses `self.ms1_df` (Polars DataFrame) and aggregates intensities by `rt` (sum).
+    Creates a `Chromatogram` object and uses its `plot()` method to display the result.
+    """
+    if self.ms1_df is None:
+        self.logger.error("No MS1 data available.")
+        return
+
+    # Import helper locally to avoid circular imports
+    from masster.study.helpers import get_tic
+
+    # Delegate TIC computation to study helper which handles ms1_df and scans_df fallbacks
+    try:
+        chrom = get_tic(self, label=title)
+    except Exception as e:
+        self.logger.exception("Failed to compute TIC via helper: %s", e)
+        return
+
+    if filename is not None:
+        try:
+            chrom.plot(width=1000, height=250)
+        except Exception:
+            import matplotlib.pyplot as plt
+
+            plt.figure(figsize=(10, 3))
+            plt.plot(chrom.rt, chrom.inty, color="black")
+            plt.xlabel("Retention time (s)")
+            plt.ylabel("Intensity")
+            if title:
+                plt.title(title)
+            plt.tight_layout()
+            plt.savefig(filename)
+        return None
+
+    chrom.plot(width=1000, height=250)
+    return None
+
+
+def plot_bpc(
+    self,
+    title=None,
+    filename=None,
+    rt_unit="s",
+):
+    """
+    Plot Base Peak Chromatogram (BPC) using MS1 data.
+
+    Aggregates MS1 points by retention time and selects the maximum intensity (base peak)
+    at each time point. Uses `self.ms1_df` (Polars DataFrame) as the source of MS1 peaks.
+
+    Parameters:
+        title (str, optional): Plot title.
+        filename (str, optional): If provided and ends with `.html` saves an interactive html,
+            otherwise saves a png. If None, returns a displayable object for notebooks.
+        rt_unit (str, optional): Unit label for the x-axis, default 's' (seconds).
+
+    Returns:
+        None or notebook display object (via _display_plot)
+    """
+    if self.ms1_df is None:
+        self.logger.error("No MS1 data available.")
+        return
+
+    # Import helper locally to avoid circular imports
+    from masster.study.helpers import get_bpc
+
+    # Delegate BPC computation to study helper
+    try:
+        chrom = get_bpc(self, rt_unit=rt_unit, label=title)
+    except Exception as e:
+        self.logger.exception("Failed to compute BPC via helper: %s", e)
+        return
+
+    # If filename was requested, save a static png using bokeh export via the chromatogram plotting
+    if filename is not None:
+        # chromatogram.plot() uses bokeh to show the figure; to save as png we rely on holoviews/hv.save
+        # Create a bokeh figure by plotting to an offscreen axis
+        try:
+            # Use Chromatogram.plot to generate and show the figure (will open in notebook/browser)
+            chrom.plot(width=1000, height=250)
+        except Exception:
+            # Last-resort: create a simple matplotlib plot and save
+            import matplotlib.pyplot as plt
+
+            plt.figure(figsize=(10, 3))
+            plt.plot(chrom.rt, chrom.inty, color="black")
+            plt.xlabel(f"Retention time ({rt_unit})")
+            plt.ylabel("Intensity")
+            if title:
+                plt.title(title)
+            plt.tight_layout()
+            plt.savefig(filename)
+        return None
+
+    # No filename: display using the chromatogram's built-in plotting (bokeh)
+    chrom.plot(width=1000, height=250)
+    return None

masster/sample/sample.py

@@ -62,6 +62,7 @@ from masster.sample.helpers import select_closest_scan
 from masster.sample.helpers import get_dda_stats
 from masster.sample.helpers import get_feature
 from masster.sample.helpers import get_scan
+from masster.sample.helpers import get_eic
 from masster.sample.helpers import set_source
 from masster.sample.load import _load_featureXML
 from masster.sample.load import _load_ms2data
@@ -80,6 +81,8 @@ from masster.sample.plot import plot_feature_stats
 from masster.sample.plot import plot_ms2_cycle
 from masster.sample.plot import plot_ms2_eic
 from masster.sample.plot import plot_ms2_q1
+from masster.sample.plot import plot_bpc
+from masster.sample.plot import plot_tic
 from masster.sample.processing import _clean_features_df
 from masster.sample.processing import _features_deisotope
 from masster.sample.processing import _get_ztscan_stats
@@ -229,6 +232,9 @@ class Sample:
     plot_ms2_cycle = plot_ms2_cycle
     plot_ms2_eic = plot_ms2_eic
     plot_ms2_q1 = plot_ms2_q1
+    plot_bpc = plot_bpc
+    plot_tic = plot_tic
+    get_eic = get_eic
     get_feature = get_feature
     get_scan = get_scan
     get_dda_stats = get_dda_stats

masster/sample/sample5_schema.json

@@ -1,80 +1,89 @@
 {
   "features_df": {
     "columns": {
-      "adduct": {
-        "dtype": "pl.Utf8"
-      },
-      "adduct_group": {
+      "feature_uid": {
         "dtype": "pl.Int64"
       },
-      "adduct_mass": {
-        "dtype": "pl.Float64"
+      "feature_id": {
+        "dtype": "pl.Utf8"
       },
-      "charge": {
+      "sample_uid": {
         "dtype": "pl.Int32"
       },
-      "chrom": {
-        "dtype": "pl.Object"
+      "mz": {
+        "dtype": "pl.Float64"
       },
-      "chrom_coherence": {
+      "rt": {
         "dtype": "pl.Float64"
       },
-      "chrom_height_scaled": {
+      "rt_original": {
         "dtype": "pl.Float64"
       },
-      "chrom_prominence": {
+      "rt_start": {
         "dtype": "pl.Float64"
       },
-      "chrom_prominence_scaled": {
+      "rt_end": {
         "dtype": "pl.Float64"
       },
-      "feature_id": {
-        "dtype": "pl.Utf8"
+      "rt_delta": {
+        "dtype": "pl.Float64"
       },
-      "feature_uid": {
-        "dtype": "pl.Int64"
+      "mz_start": {
+        "dtype": "pl.Float64"
+      },
+      "mz_end": {
+        "dtype": "pl.Float64"
       },
       "inty": {
         "dtype": "pl.Float64"
       },
+      "quality": {
+        "dtype": "pl.Float64"
+      },
+      "charge": {
+        "dtype": "pl.Int32"
+      },
       "iso": {
         "dtype": "pl.Int64"
       },
       "iso_of": {
         "dtype": "pl.Int64"
       },
-      "ms2_scans": {
-        "dtype": "pl.Object"
-      },
-      "ms2_specs": {
-        "dtype": "pl.Object"
+      "adduct": {
+        "dtype": "pl.Utf8"
       },
-      "mz": {
+      "adduct_mass": {
         "dtype": "pl.Float64"
       },
-      "mz_end": {
-        "dtype": "pl.Float64"
+      "adduct_group": {
+        "dtype": "pl.Int64"
       },
-      "mz_start": {
-        "dtype": "pl.Float64"
+      "chrom": {
+        "dtype": "pl.Object"
       },
-      "quality": {
-        "dtype": "pl.Float64"
+      "filled": {
+        "dtype": "pl.Boolean"
       },
-      "rt": {
+      "chrom_area": {
         "dtype": "pl.Float64"
       },
-      "rt_delta": {
+      "chrom_coherence": {
         "dtype": "pl.Float64"
       },
-      "rt_end": {
+      "chrom_prominence": {
         "dtype": "pl.Float64"
       },
-      "rt_original": {
+      "chrom_prominence_scaled": {
         "dtype": "pl.Float64"
       },
-      "rt_start": {
+      "chrom_height_scaled": {
         "dtype": "pl.Float64"
+      },
+      "ms2_scans": {
+        "dtype": "pl.Object"
+      },
+      "ms2_specs": {
+        "dtype": "pl.Object"
       }
     }
   },

masster/study/defaults/align_def.py

@@ -49,9 +49,9 @@ class align_defaults:
         LOWESS_extrapolation_type (str): Method for extrapolation outside data range. Default is "four-point-linear".
     """
 
-    rt_max_diff: float = 60.0
-    mz_max_diff: float = 0.02
-    rt_pair_distance_frac: float = 0.2
+    rt_max_diff: float = 5.0
+    mz_max_diff: float = 0.01
+    rt_pair_distance_frac: float = 0.5
     mz_pair_max_distance: float = 0.01
     num_used_points: int = 1000
     save_features: bool = False
@@ -88,16 +88,16 @@ class align_defaults:
             "rt_max_diff": {
                 "dtype": float,
                 "description": "Maximum retention time difference for alignment (seconds)",
-                "default": 60.0,
+                "default": 5.0,
                 "min_value": 1.0,
-                "max_value": 300.0,
+                "max_value": 30.0,
             },
             "mz_max_diff": {
                 "dtype": float,
                 "description": "Maximum m/z difference for alignment (Da)",
                 "default": 0.01,
                 "min_value": 0.001,
-                "max_value": 1.0,
+                "max_value": 0.05,
             },
             "rt_pair_distance_frac": {
                 "dtype": float,
@@ -111,24 +111,24 @@ class align_defaults:
                 "description": "Maximum m/z pair distance (Da)",
                 "default": 0.01,
                 "min_value": 0.001,
-                "max_value": 0.1,
+                "max_value": 0.2,
             },
             "num_used_points": {
                 "dtype": int,
                 "description": "Number of points used for alignment",
                 "default": 1000,
                 "min_value": 10,
-                "max_value": 100000,
+                "max_value": 10000,
             },
             "save_features": {
                 "dtype": bool,
                 "description": "Whether to save features after alignment",
-                "default": True,
+                "default": False,
             },
             "skip_blanks": {
                 "dtype": bool,
                 "description": "Whether to skip blank samples during alignment",
-                "default": True,
+                "default": False,
             },
             "algo": {
                 "dtype": str,