glycanPRMQuant 0.1.0__py3-none-any.whl

glycanPRMQuant/__init__.py

@@ -0,0 +1,17 @@
+"""
+glycanPRMQuant: A package for glycan PRM (Parallel Reaction Monitoring) quantification.
+
+This package provides tools for processing mass spectrometry data of glycans,
+including MS1/MS2 matching, fragmentation analysis, and quantification.
+"""
+
+__version__ = "0.1.0"
+__author__ = "Vishal Sandilya"
+__email__ = "vishal.sandilya@ttu.edu"
+
+__all__ = [
+    "matchMS1",
+    "matchMS2",
+    "process_mzml_pipeline",
+    "calculateAUC",
+]

glycanPRMQuant/calculateAUC.py

@@ -0,0 +1,260 @@
+import os
+import logging
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy.signal import find_peaks, peak_widths
+from scipy.ndimage import gaussian_filter1d
+from scipy.signal import savgol_filter
+
+plt.rcParams["pdf.fonttype"] = 42
+plt.rcParams["ps.fonttype"] = 42
+
+logger = logging.getLogger(__name__)
+
+def _smooth_signal(y, method: str, window: int):
+    if not window or window <= 0:
+        return y
+    method = (method or "gaussian").lower()
+    if method in ("gaussian", "gauss"):
+        return gaussian_filter1d(y, sigma=window, mode='nearest')
+    if method in ("savgol", "sav-gol", "savitzky-golay", "sg"):
+        n = len(y)
+        if n < 3:
+            return y
+        win = int(window)
+        if win % 2 == 0:
+            win += 1
+        if win < 3:
+            win = 3
+        if win > n:
+            win = n if n % 2 == 1 else n - 1
+            if win < 3:
+                return y
+        return savgol_filter(y, window_length=win, polyorder=2, mode='nearest')
+    return y
+
+def _resample_uniform(rt, y):
+    rt = np.asarray(rt, dtype=float)
+    y = np.asarray(y, dtype=float)
+    if rt.size < 3:
+        return rt, y
+    order = np.argsort(rt)
+    rt = rt[order]
+    y = y[order]
+    diffs = np.diff(rt)
+    step = np.median(diffs[diffs > 0]) if np.any(diffs > 0) else None
+    if step is None or step <= 0:
+        return rt, y
+    grid = np.arange(rt.min(), rt.max() + step * 0.5, step)
+    y_interp = np.interp(grid, rt, y)
+    return grid, y_interp
+
+def _find_width_at_height(y: np.ndarray, peak_idx: int, height: float):
+    y = np.asarray(y, dtype=float)
+    n = y.size
+    if n == 0:
+        return 0.0, float(max(n - 1, 0))
+    peak_idx = int(np.clip(peak_idx, 0, n - 1))
+    height = float(height)
+
+    left_candidates = np.where(y[:peak_idx + 1] <= height)[0]
+    if left_candidates.size == 0:
+        left_ip = 0.0
+    else:
+        li = left_candidates[-1]
+        if li == peak_idx:
+            left_ip = float(li)
+        else:
+            y1, y2 = y[li], y[li + 1]
+            if y2 == y1:
+                left_ip = float(li)
+            else:
+                frac = (height - y1) / (y2 - y1)
+                left_ip = li + float(frac)
+
+    right_candidates = np.where(y[peak_idx:] <= height)[0]
+    if right_candidates.size == 0:
+        right_ip = float(n - 1)
+    else:
+        ri = peak_idx + right_candidates[0]
+        if ri == peak_idx:
+            right_ip = float(ri)
+        else:
+            y1, y2 = y[ri - 1], y[ri]
+            if y2 == y1:
+                right_ip = float(ri)
+            else:
+                frac = (height - y1) / (y2 - y1)
+                right_ip = (ri - 1) + float(frac)
+
+    return left_ip, right_ip
+
+def calculateAUC(
+    ms2_input,
+    glycan_col: str = 'Glycan',
+    scan_col: str = 'scan_number',
+    rt_col: str = 'rt',
+    intensity_col: str = 'fragment_intensity',
+    adduct_col: str = 'Adduct',
+    rel_height: float = 0.7,
+    rel_height_mode: str = "prominence",
+    prominence: float = None,
+    smoothing_window: int = 30,
+    smoothing_method: str = "gaussian",
+    plot: bool = False,
+    save_path: str = None,
+    window = 0
+) -> pd.DataFrame:
+    """
+    Calculate AUC for each glycan/adduct by optionally smoothing the summed fragment-intensity
+    chromatogram, detecting the main peak, determining its boundaries at a relative height,
+    and integrating the (smoothed or raw) intensity between those boundaries. Also returns a
+    glycan-level total that sums AUCs across all adducts for that glycan.
+
+    smoothing_window <= 0 will skip smoothing.
+
+    Parameters
+    ----------
+    ms2_input : pd.DataFrame or str
+        Matched MS2 DataFrame or path to CSV/Excel.
+    glycan_col : str
+        Column name for glycan composition.
+    scan_col : str
+        Column name for scan number.
+    rt_col : str
+        Column name for retention time.
+    intensity_col : str
+        Column for fragment intensity.
+    rel_height : float
+        Relative height (0–1) for width calculation (e.g. 0.5 for half-height).
+    prominence : float or None
+        Minimum peak prominence passed to find_peaks.
+    smoothing_window : int
+        Smoothing window. For Gaussian, this is sigma. For Sav-Gol, this is window length.
+    smoothing_method : str
+        "gaussian" (default) or "savgol".
+    plot : bool
+        If True, plot smoothed vs raw chromatogram and integration window.
+
+    Returns
+    -------
+    tuple[pd.DataFrame, pd.DataFrame]
+        (per_adduct_df, total_df)
+        per_adduct_df columns: [glycan_col, adduct_col, 'peak_rt', 'start_rt', 'end_rt', 'AUC']
+        total_df      columns: [glycan_col, 'AUC'] (AUC summed across adducts per glycan)
+    """
+    # load data
+    if isinstance(ms2_input, str):
+        ext = os.path.splitext(ms2_input)[1].lower()
+        if ext == '.csv':
+            df = pd.read_csv(ms2_input)
+        elif ext in ('.xlsx', '.xls'):
+            df = pd.read_excel(ms2_input)
+        else:
+            raise ValueError("Unsupported file type.")
+    else:
+        df = ms2_input.copy()
+
+    # validate
+    missing = {glycan_col, scan_col, rt_col, intensity_col} - set(df.columns)
+    if missing:
+        raise ValueError(f"Missing columns: {missing}")
+
+    # If adduct column is absent, treat all signal as one pseudo-adduct so grouping works
+    if adduct_col not in df.columns:
+        df = df.copy()
+        df[adduct_col] = 'ALL'
+
+    # sum per scan for each glycan
+    summed = (
+        df.groupby([glycan_col, adduct_col, scan_col])
+          .agg(rt=(rt_col, 'first'),
+               summed_intensity=(intensity_col, 'sum'))
+          .reset_index()
+    )
+
+    results = []
+    for (glycan, adduct), sub in summed.groupby([glycan_col, adduct_col]):
+        sub = sub.sort_values('rt')
+        x = sub['rt'].to_numpy()
+        y = sub['summed_intensity'].to_numpy()
+
+        # apply smoothing if requested
+        if smoothing_window and smoothing_window > 0:
+            xg, yg = _resample_uniform(x, y)
+            y_smooth = _smooth_signal(yg, smoothing_method, smoothing_window)
+            x = xg
+        else:
+            y_smooth = y
+
+        # detect peaks on y_smooth
+        peaks, props = find_peaks(y_smooth, prominence=prominence)
+        if len(peaks) == 0:
+            main_idx = np.argmax(y_smooth)
+        else:
+            main_idx = peaks[np.argmax(y_smooth[peaks])]
+
+        # compute width at rel_height
+        mode = (rel_height_mode or "prominence").lower()
+        if mode in ("height", "peak", "absolute"):
+            peak_y = float(y_smooth[main_idx])
+            height_level = peak_y * (1.0 - float(rel_height))
+            left_ip, right_ip = _find_width_at_height(y_smooth, main_idx, height_level)
+        else:
+            widths, h_eval, left_ips, right_ips = peak_widths(
+                y_smooth, [main_idx], rel_height=rel_height
+            )
+            left_ip, right_ip = left_ips[0], right_ips[0]
+
+        # map to retention time
+        idxs = np.arange(len(x))
+        start_rt = np.interp(left_ip, idxs, x)
+        end_rt   = np.interp(right_ip, idxs, x)
+        peak_rt  = x[main_idx]
+
+        # Integrate with interpolated boundary points so narrow windows that
+        # fall between scans do not collapse to a single apex sample.
+        interior_mask = (x > start_rt) & (x < end_rt)
+        x_auc = np.concatenate(([start_rt], x[interior_mask], [end_rt]))
+        y_auc = np.interp(x_auc, x, y_smooth)
+        auc = np.trapezoid(y_auc, x_auc)
+
+        logger.info(
+            f"Glycan {glycan!r}: peak RT={peak_rt:.2f}, "
+            f"window=[{start_rt:.2f}, {end_rt:.2f}], AUC={auc:.2f}"
+        )
+        results.append({
+            glycan_col: glycan,
+            adduct_col: adduct,
+            'peak_rt': peak_rt,
+            'start_rt': start_rt,
+            'end_rt': end_rt,
+            'AUC': auc
+        })
+        plt.style.use(['science', 'no-latex'])
+        plt.rcParams['font.family'] = 'Arial'
+
+        if plot:
+            fig, ax = plt.subplots(figsize=(4.8, 4))
+            ax.plot(x, y_smooth, label=(
+                f'smoothed ({smoothing_method}, w={smoothing_window})'
+                if smoothing_window and smoothing_window > 0 else 'raw'
+            ))
+            ax.axvspan(start_rt, end_rt, color='red', alpha=0.1,
+                       label='integration window')
+            ax.set_xlabel('RT (min)')
+            ax.set_ylabel('Intensity')
+            plt.xlim(x.min()-window, x.max()+window)
+            plt.ylim(0, y_smooth.max() * 1.1)
+            ax.set_title(f"{glycan} ({adduct}): Integration Window")
+            plt.tight_layout()
+            if save_path:
+                plt.savefig(save_path, dpi=300)
+                logger.info(f"Saved plot to {save_path}")
+            else:
+                plt.show()
+
+    per_adduct_df = pd.DataFrame(results)
+    total_df = per_adduct_df.groupby(glycan_col, as_index=False)['AUC'].sum()
+    return per_adduct_df, total_df

glycanPRMQuant/calculate_mass.py

@@ -0,0 +1,42 @@
+"""
+Module for calculating the mass of glycans
+"""
+import logging
+
+from glypy.io import iupac
+from glypy.io.iupac import IUPACError
+from glypy.structure import ReducedEnd
+from glypy.composition.composition_transform import derivatize
+
+logger = logging.getLogger(__name__)
+
+
+def calculate_mass(glycan_str, derivatization="methyl", reduced_end=True, verbose=True):
+    """
+    Given an IUPAC string,
+calculate the mass of the glycan, optionally applying derivatization and setting a reduced end.
+    """
+    try:
+        glycan = iupac.loads(glycan_str, dialect="simple")
+    except IUPACError as e:
+        if verbose:
+            logger.error("Error parsing IUPAC string: %s", e)
+        return None
+
+    try:
+        if reduced_end:
+            glycan.set_reducing_end(ReducedEnd())
+        if derivatization:
+            derivatize(glycan, derivatization)
+        return glycan.mass()
+    except (KeyError, ValueError) as e:
+        if verbose:
+            logger.error("Error modifying glycan: %s", e)
+        return None
+
+if __name__ == "__main__":
+    # Example usage
+    glycan_str = "Man(a1-2)Man(a1-3)[Man(a1-3)[Man(a1-6)]Man(a1-6)]Man(b1-4)GlcNAc(b1-4)GlcNAc"
+    mass = calculate_mass(glycan_str, derivatization=None, reduced_end=False)
+    if mass is not None:
+        print(f"The mass of {glycan_str} is: {mass:.4f} Da")

glycanPRMQuant/centroidData.py

@@ -0,0 +1,54 @@
+import numpy as np
+import pandas as pd
+
+def gaussian_fit(data, mz_col='mz', intensity_col='intensity', resolution=120000):
+    """
+    Reconstruct a mass spectrum by fitting Gaussian peaks to each (m/z, intensity) pair.
+
+    Parameters
+    ----------
+    data : pandas.DataFrame
+        Must contain columns:
+        - scan_number
+        - <mz_col>           # name of the m/z column
+        - <intensity_col>    # name of the intensity column
+    mz_col : str, optional
+        Name of the column in `data` holding the m/z values. Default is 'mz'.
+    intensity_col : str, optional
+        Name of the column in `data` holding the peak intensities. Default is 'intensity'.
+    resolution : float, optional
+        Instrument resolution used to compute FWHM of peaks
+        (FWHM = mz / resolution). Default is 120000.
+
+    Returns
+    -------
+    pandas.DataFrame
+        Two columns:
+        - 'mz': uniformly spaced m/z grid
+        - 'intensity': reconstructed spectrum
+    """
+    # Check for required columns
+    required = {'scan_number', mz_col, intensity_col}
+    missing = required - set(data.columns)
+    if missing:
+        raise ValueError(f"Input DataFrame is missing columns: {missing}")
+
+    # Build the m/z grid
+    mz_min = data[mz_col].min() - 1
+    mz_max = data[mz_col].max() + 1
+    num_points = 20000
+    mz_grid = np.linspace(mz_min, mz_max, num_points)
+
+    # Initialize spectrum
+    reconstructed = np.zeros_like(mz_grid)
+
+    # Sum Gaussian peaks
+    for _, row in data.iterrows():
+        center = row[mz_col]
+        height = row[intensity_col]
+        fwhm = center / resolution
+        sigma = fwhm / (2 * np.sqrt(2 * np.log(2)))
+        peak = height * np.exp(-0.5 * ((mz_grid - center) / sigma) ** 2)
+        reconstructed += peak
+
+    return pd.DataFrame({'mz': mz_grid, 'intensity': reconstructed})

glycanPRMQuant/cli.py

@@ -0,0 +1,149 @@
+"""Command-line interface for glycanPRMQuant."""
+
+import argparse
+import logging
+import multiprocessing
+
+from glycanPRMQuant.logging_utils import configure_logging
+
+
+def _add_common_options(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--ppm-ms1-tol", type=float, default=10)
+    parser.add_argument("--mz-min", type=float, default=400)
+    parser.add_argument("--mz-max", type=float, default=2000)
+    parser.add_argument("--mz-offset", type=float, default=0.0)
+    parser.add_argument("--mass-offset", type=float, default=0.0)
+    parser.add_argument("--intensity-threshold", type=float, default=1e2)
+    parser.add_argument("--ppm-ms2-tol", type=float, default=10)
+    parser.add_argument("--mz-tol", type=float, default=0.02)
+    parser.add_argument("--fragment-ion-series", default="ABCXYZ")
+    parser.add_argument("--fragment-max-cleavages", type=int, default=2)
+    parser.add_argument("--smoothing-window", type=int, default=11)
+    parser.add_argument("--smoothing-method", choices=["gaussian", "savgol"], default="gaussian")
+    parser.add_argument("--disable-smoothing", action="store_true")
+    parser.add_argument("--rel-height", type=float, default=0.7)
+    parser.add_argument("--rel-height-mode", choices=["prominence", "height"], default="prominence")
+    parser.add_argument("--precursor-db-path")
+    parser.add_argument("--structure-db-path")
+    parser.add_argument("--skyline-transition", action="store_true")
+    parser.add_argument("--quiet", action="store_true")
+    parser.add_argument("-v", "--verbose", action="count", default=0)
+
+
+def _log_level(args: argparse.Namespace) -> int:
+    if args.quiet:
+        return logging.WARNING
+    if args.verbose >= 2:
+        return logging.DEBUG
+    return logging.INFO
+
+
+def _run_one(args: argparse.Namespace) -> int:
+    configure_logging(_log_level(args), force=True)
+    from glycanPRMQuant.processmzML import process_mzml_pipeline
+
+    process_mzml_pipeline(
+        mzml_file=args.mzml_file,
+        output_dir=args.output_dir,
+        ppm_ms1_tol=args.ppm_ms1_tol,
+        mz_min=args.mz_min,
+        mz_max=args.mz_max,
+        mz_offset=args.mz_offset,
+        mass_offset=args.mass_offset,
+        intensity_threshold=args.intensity_threshold,
+        ppm_ms2_tol=args.ppm_ms2_tol,
+        mz_tol=args.mz_tol,
+        smoothing_window=args.smoothing_window,
+        smoothing_method=args.smoothing_method,
+        enable_smoothing=not args.disable_smoothing,
+        rel_height=args.rel_height,
+        rel_height_mode=args.rel_height_mode,
+        skyline_transition=args.skyline_transition,
+        fragment_ion_series=args.fragment_ion_series,
+        fragment_max_cleavages=args.fragment_max_cleavages,
+        precursor_db_path=args.precursor_db_path,
+        structure_db_path=args.structure_db_path,
+    )
+    return 0
+
+
+def _run_batch(args: argparse.Namespace) -> int:
+    configure_logging(_log_level(args), force=True)
+    multiprocessing.freeze_support()
+    from glycanPRMQuant.parallelProcess import run_parallel_pipeline
+
+    run_parallel_pipeline(
+        input_dir=args.input_dir,
+        input_files=args.input_files,
+        output_root=args.output_root,
+        n_workers=args.workers,
+        ppm_ms1_tol=args.ppm_ms1_tol,
+        mz_min=args.mz_min,
+        mz_max=args.mz_max,
+        mz_offset=args.mz_offset,
+        mass_offset=args.mass_offset,
+        intensity_threshold=args.intensity_threshold,
+        ppm_ms2_tol=args.ppm_ms2_tol,
+        mz_tol=args.mz_tol,
+        fragment_ion_series=args.fragment_ion_series,
+        fragment_max_cleavages=args.fragment_max_cleavages,
+        smoothing_window=args.smoothing_window,
+        smoothing_method=args.smoothing_method,
+        enable_smoothing=not args.disable_smoothing,
+        rel_height=args.rel_height,
+        rel_height_mode=args.rel_height_mode,
+        skyline_transition=args.skyline_transition,
+        precursor_db_path=args.precursor_db_path,
+        structure_db_path=args.structure_db_path,
+        overwrite=args.overwrite,
+        dry_run=args.dry_run,
+    )
+    return 0
+
+
+def _run_gui(args: argparse.Namespace) -> int:
+    configure_logging(_log_level(args), force=True)
+    from glycanPRMQuant.pipelineGUI import PipelineGUI
+
+    app = PipelineGUI()
+    app.mainloop()
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="glycan-prmquant")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    run_parser = sub.add_parser("run", help="Process one mzML file")
+    run_parser.add_argument("mzml_file")
+    run_parser.add_argument("output_dir")
+    _add_common_options(run_parser)
+    run_parser.set_defaults(func=_run_one)
+
+    batch_parser = sub.add_parser("batch", help="Process multiple mzML files")
+    source = batch_parser.add_mutually_exclusive_group(required=True)
+    source.add_argument("--input-dir")
+    source.add_argument("--input-files", nargs="+")
+    batch_parser.add_argument("--output-root", required=True)
+    batch_parser.add_argument("--workers", type=int)
+    batch_parser.add_argument("--overwrite", action="store_true")
+    batch_parser.add_argument("--dry-run", action="store_true")
+    _add_common_options(batch_parser)
+    batch_parser.set_defaults(func=_run_batch)
+
+    gui_parser = sub.add_parser("gui", help="Launch the Tkinter GUI")
+    gui_parser.add_argument("--quiet", action="store_true")
+    gui_parser.add_argument("-v", "--verbose", action="count", default=0)
+    gui_parser.set_defaults(func=_run_gui)
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

glycanPRMQuant/consolidateAUC.py

@@ -0,0 +1,55 @@
+import os
+import pandas as pd
+
+def consolidate_auc_results(results_root: str, output_csv: str):
+    """
+    Consolidate all <mzML_basename>_auc_values.csv files under `results_root`
+    into one CSV file.
+
+    The output will have one row per glycan, a 'Glycan' column plus one column
+    per mzML file (named by the folder/mzML basename) containing its AUC values.
+
+    Parameters
+    ----------
+    results_root : str
+        Path to the directory containing per-file subfolders (each with *_auc_values.csv).
+    output_csv : str
+        Path to write the consolidated CSV file (e.g. "all_auc_summary.csv").
+    """
+    auc_dfs = []
+    for sub in sorted(os.listdir(results_root)):
+        subdir = os.path.join(results_root, sub)
+        if not os.path.isdir(subdir):
+            continue
+        auc_file = os.path.join(subdir, f"{sub}_auc_values.csv")
+        if not os.path.isfile(auc_file):
+            print(f"Warning: no AUC file found for {sub} (looking for {auc_file})")
+            continue
+
+        df = pd.read_csv(auc_file)
+        # Identify AUC column(s) (case-insensitive contains 'auc')
+        auc_cols = [c for c in df.columns if 'auc' in c.lower()]
+        if not auc_cols:
+            print(f"Warning: no AUC column found in {auc_file}")
+            continue
+        # Prefer exact 'AUC' match if present
+        auc_col = 'AUC' if 'AUC' in auc_cols else auc_cols[0]
+        # Rename that column to the sub (folder) name
+        df = df.rename(columns={auc_col: sub})
+        # Keep only Glycan and the renamed AUC column
+        df = df[['Glycan', sub]]
+        auc_dfs.append(df)
+
+    if not auc_dfs:
+        raise RuntimeError(f"No _auc_values.csv files found in {results_root}")
+
+    # Merge all on 'Glycan' using outer join
+    merged = auc_dfs[0]
+    for df in auc_dfs[1:]:
+        merged = pd.merge(merged, df, on='Glycan', how='outer')
+
+    merged = merged.sort_values('Glycan').reset_index(drop=True)
+
+    # Write to CSV
+    merged.to_csv(output_csv, index=False)
+    print(f"Wrote consolidated AUC summary to {output_csv}")

glycanPRMQuant/constants.py

@@ -0,0 +1,15 @@
+"""
+Shared constants for glycanPRMQuant package.
+
+This module contains all physical and chemical constants used throughout
+the package to ensure consistency across modules.
+"""
+
+from .resources import resource_path
+
+# Mass constants (in Daltons)
+PROTON_MASS = 1.007276
+NH4_MASS = 18.033826  # Ammonium adduct mass
+
+# Default file paths
+DEFAULT_PRECURSOR_DB = resource_path("database/N_glycan_db.csv")