MoleditPy 2.2.0a1__py3-none-any.whl → 2.2.0a3__py3-none-any.whl

moleditpy/plugins/Analysis/ms_spectrum_neo.py

@@ -1,919 +0,0 @@
-# -*- coding: utf-8 -*-
-import sys
-import math
-from PyQt6.QtWidgets import QDialog, QVBoxLayout, QHBoxLayout, QLabel, QWidget, QMessageBox, QPushButton, QFileDialog, QCheckBox, QDoubleSpinBox
-from PyQt6.QtGui import QPainter, QPen, QBrush, QColor, QFont, QPalette, QLinearGradient, QGradient
-from PyQt6.QtCore import Qt, QRectF, QPointF
-
-try:
-    from rdkit import Chem
-    from rdkit.Chem import Descriptors
-except ImportError:
-    Chem = None
-
-__version__="2025.12.18"
-__author__="HiroYokoyama"
-
-PLUGIN_NAME = "MS Spectrum Simulation Neo"
-
-class MSSpectrumDialog(QDialog):
-    def __init__(self, mol, parent=None):
-        super().__init__(parent)
-        self.setWindowTitle("MS Spectrum Simulation Neo")
-        self.resize(500, 550) 
-        self.mol = mol
-        
-        # Clean white look
-        self.setStyleSheet("""
-            QDialog {
-                background-color: #ffffff;
-                color: #000000;
-            }
-            QLabel {
-                color: #333333;
-                font-size: 14px;
-                font-family: 'Segoe UI', sans-serif;
-            }
-            QGroupBox {
-                border: 1px solid #dddddd;
-                border-radius: 4px;
-                margin-top: 20px;
-                padding-top: 10px;
-            }
-            QGroupBox::title {
-                subcontrol-origin: margin;
-                subcontrol-position: top center;
-                padding: 0 5px;
-                color: #555555;
-            }
-        """)
-
-        layout = QVBoxLayout(self)
-        layout.setContentsMargins(10, 10, 10, 10)
-        
-        # --- Settings Panel ---
-        from PyQt6.QtWidgets import QGroupBox, QFormLayout, QLineEdit, QComboBox, QSpinBox
-        
-        settings_group = QGroupBox("Configuration")
-        settings_layout = QFormLayout(settings_group)
-        
-        # 1. Formula Input
-        self.formula_input = QLineEdit()
-        if self.mol:
-            self.formula_input.setText(Chem.rdMolDescriptors.CalcMolFormula(self.mol))
-        settings_layout.addRow("Formula:", self.formula_input)
-        
-        # 2. Charge (Signed)
-        self.charge_spin = QSpinBox()
-        self.charge_spin.setRange(-10, 10)
-        self.charge_spin.setValue(1) # Default +1
-        # Prevent 0
-        self.charge_spin.valueChanged.connect(self.on_charge_changed)
-        settings_layout.addRow("Charge (z):", self.charge_spin)
-        
-        # 3. Adduct Species
-        self.adduct_combo = QComboBox()
-        self.update_adduct_options() # Populate initial
-        settings_layout.addRow("Adduct:", self.adduct_combo)
-
-        layout.addWidget(settings_group)
-
-        # Gaussian Options
-        self.gauss_check = QCheckBox("Gaussian Broadening")
-        self.gauss_check.setChecked(False)
-        self.gauss_check.stateChanged.connect(self.recalc_peaks)
-        
-        self.width_spin = QDoubleSpinBox()
-        self.width_spin.setRange(0.001, 5.0)
-        self.width_spin.setSingleStep(0.01)
-        self.width_spin.setValue(0.04)
-        self.width_spin.setSuffix(" Da")
-        self.width_spin.setToolTip("Peak width (Sigma)")
-        self.width_spin.valueChanged.connect(self.recalc_peaks)
-        
-        # Layout for Gaussian
-        gauss_layout = QHBoxLayout()
-        gauss_layout.addWidget(self.gauss_check)
-        gauss_layout.addWidget(QLabel("Width:"))
-        gauss_layout.addWidget(self.width_spin)
-        gauss_layout.addStretch()
-        layout.addLayout(gauss_layout)
-        
-        # --- Info Labels ---
-        info_layout = QHBoxLayout()
-        self.lbl_mw = QLabel("Neutral Avg Mass: -")
-        self.lbl_em = QLabel("Neutral Exact Mass: -")
-        self.lbl_ion = QLabel("Monoisotopic m/z: -")
-        info_layout.addWidget(self.lbl_mw)
-        info_layout.addWidget(self.lbl_em)
-        info_layout.addWidget(self.lbl_ion)
-        layout.addLayout(info_layout)
-        
-        # --- Plot ---
-        plot_container = QWidget()
-        plot_container.setStyleSheet("background-color: #ffffff; border: 1px solid #cccccc; border-radius: 4px;")
-        plot_layout = QVBoxLayout(plot_container)
-        plot_layout.setContentsMargins(1, 1, 1, 1)
-        
-        self.plot_widget = HistogramWidget([]) # Init empty
-        plot_layout.addWidget(self.plot_widget)
-        layout.addWidget(plot_container, 1)
-
-        # Export Button
-        btn_layout = QHBoxLayout()
-        btn_layout.addStretch()
-        self.export_btn = QPushButton("Export to Image")
-        self.export_btn.clicked.connect(self.export_image)
-        btn_layout.addWidget(self.export_btn)
-
-        self.btn_export_csv = QPushButton("Export CSV")
-        self.btn_export_csv.clicked.connect(self.export_csv)
-        btn_layout.addWidget(self.btn_export_csv)
-
-        layout.addLayout(btn_layout)
-
-        # Signals
-        # Signals
-        self.formula_input.textChanged.connect(lambda: self.recalc_peaks(reset=True))
-        self.adduct_combo.currentIndexChanged.connect(lambda: self.recalc_peaks(reset=True))
-        self.charge_spin.valueChanged.connect(lambda: self.recalc_peaks(reset=True))
-        
-        # Gaussian changes should NOT reset view (keep zoom)
-        self.gauss_check.stateChanged.connect(lambda: self.recalc_peaks(reset=False))
-        self.width_spin.valueChanged.connect(lambda: self.recalc_peaks(reset=False))
-        
-        # Initial Calc
-        self.recalc_peaks(reset=True)
-
-    def export_image(self):
-        filename, _ = QFileDialog.getSaveFileName(self, "Save Spectrum Image", "spectrum.png", "Images (*.png *.jpg)")
-        if filename:
-            pixmap = self.plot_widget.grab()
-            if pixmap.save(filename):
-                QMessageBox.information(self, "Success", f"Image saved to {filename}")
-            else:
-                QMessageBox.critical(self, "Error", "Failed to save image.")
-
-    def on_charge_changed(self, val):
-        # Allow 0
-        
-        # Always update options to reflect new charge in strings
-        # Always update options to reflect new charge in strings
-        self.update_adduct_options()
-        # Recalc is triggered by signals if values change, but charge spin change
-        # manually connected? No, above we connected charge_spin.valueChanged.
-        # But wait, update_adduct_options clears combo?
-        # Let's rely on signals.
-        # self.recalc_peaks() -> Will be called by signal.
-
-    def to_superscript(self, txt):
-        mapping = {
-            '0': '⁰', '1': '¹', '2': '²', '3': '³', '4': '⁴',
-            '5': '⁵', '6': '⁶', '7': '⁷', '8': '⁸', '9': '⁹',
-            '+': '⁺', '-': '⁻'
-        }
-        return "".join(mapping.get(c, c) for c in str(txt))
-
-    def to_subscript(self, txt):
-        mapping = {
-            '0': '₀', '1': '₁', '2': '₂', '3': '₃', '4': '₄',
-            '5': '₅', '6': '₆', '7': '₇', '8': '₈', '9': '₉'
-        }
-        return "".join(mapping.get(c, c) for c in str(txt))
-
-    def update_adduct_options(self):
-        # Save current choice
-        current_idx = self.adduct_combo.currentIndex()
-        if current_idx < 0: current_idx = 0
-        
-        self.adduct_combo.blockSignals(True)
-        self.adduct_combo.clear()
-        
-        charge_val = self.charge_spin.value()
-        z = abs(charge_val)
-        
-        if charge_val == 0:
-            items = [
-                "M (Neutral) [M]",
-                "None"
-            ]
-            self.adduct_combo.addItems(items)
-            self.adduct_combo.blockSignals(False)
-            return
-
-        sign = "⁺" if charge_val > 0 else "⁻"
-        
-        # Format Charge Superscript (e.g. ²⁺ or ⁺)
-        z_super = self.to_superscript(z) if z > 1 else ""
-        charge_str = f"{z_super}{sign}"
-        
-        # Format Count (coefficient) (e.g. 2 or "")
-        n_str = str(z) if z > 1 else ""
-        
-        if charge_val > 0: # Positive
-            items = [
-                f"M [M]{charge_str}",
-                f"H (Proton) [M+{n_str}H]{charge_str}", 
-                f"Na (Sodium) [M+{n_str}Na]{charge_str}", 
-                f"K (Potassium) [M+{n_str}K]{charge_str}", 
-                f"NH4 (Ammonium) [M+{n_str}NH{self.to_subscript(4)}]{charge_str}", 
-                f"CH3CN+H (Acetonitrile) [M+{n_str}H+{n_str}CH{self.to_subscript(3)}CN]{charge_str}"
-            ]
-        else: # Negative
-            items = [
-                f"M [M]{charge_str}",
-                f"H (Deprotonation) [M-{n_str}H]{charge_str}", 
-                f"Cl (Chloride) [M+{n_str}Cl]{charge_str}", 
-                f"HCOO (Formate) [M+{n_str}HCOO]{charge_str}", 
-                f"CH3COO (Acetate) [M+{n_str}CH{self.to_subscript(3)}COO]{charge_str}"
-            ]
-        
-        self.adduct_combo.addItems(items)
-        
-        # Restore index if safe, else 0
-        if current_idx < self.adduct_combo.count():
-            self.adduct_combo.setCurrentIndex(current_idx)
-        else:
-             self.adduct_combo.setCurrentIndex(0)
-             
-        self.adduct_combo.blockSignals(False)
-
-    def parse_formula_str(self, formula):
-        import re
-        # Tokenize: Elements (e.g., "Na", "C"), Numbers, Parentheses
-        tokens = re.findall(r"([A-Z][a-z]*|\d+|\(|\))", formula)
-        
-        stack = [{}]
-        
-        i = 0
-        while i < len(tokens):
-            token = tokens[i]
-            
-            if token == '(':
-                stack.append({})
-                i += 1
-            elif token == ')':
-                # Check for multiplier after parenthesis
-                multiplier = 1
-                if i + 1 < len(tokens) and tokens[i+1].isdigit():
-                    multiplier = int(tokens[i+1])
-                    i += 1 # Consume number
-                
-                # Pop and merge
-                if len(stack) > 1:
-                    top = stack.pop()
-                    for el, count in top.items():
-                        stack[-1][el] = stack[-1].get(el, 0) + count * multiplier
-                i += 1
-            elif token.isdigit():
-                # Should have been handled, but ignore if standalone
-                i += 1
-            elif token[0].isalpha(): # Element
-                element = token
-                count = 1
-                if i + 1 < len(tokens) and tokens[i+1].isdigit():
-                    count = int(tokens[i+1])
-                    i += 1 # Consume number
-                
-                stack[-1][element] = stack[-1].get(element, 0) + count
-                i += 1
-                
-        # Merge any remaining stack items
-        while len(stack) > 1:
-             top = stack.pop()
-             for el, count in top.items():
-                 stack[-1][el] = stack[-1].get(el, 0) + count
-                 
-        return stack[0]
-
-    def get_adduct_delta(self, species_idx, mode, charge):
-        # Map index to species logic
-        # Positive: 0:M, 1:H, 2:Na, 3:K, 4:NH4, 5:CH3CN+H
-        # Negative: 0:M, 1:H(-), 2:Cl, 3:HCOO, 4:CH3COO
-        
-        delta = {}
-        
-        # NOTE: Indices shifted because M is now 0
-        if mode == "Positive":
-            if species_idx == 0: # M
-                 pass
-            elif species_idx == 1: # H
-                 delta = {'H': 1 * charge}
-            elif species_idx == 2: # Na
-                 delta = {'Na': 1 * charge}
-            elif species_idx == 3: # K
-                 delta = {'K': 1 * charge}
-            elif species_idx == 4: # NH4
-                 delta = {'N': 1 * charge, 'H': 4 * charge}
-            elif species_idx == 5: # CH3CN+H
-                 delta = {'C': 2 * charge, 'H': 4 * charge, 'N': 1 * charge}
-            
-        else: # Negative
-            if species_idx == 0: # M
-                 pass
-            elif species_idx == 1: # H (Deprotonation -H)
-                 delta = {'H': -1 * charge}
-            elif species_idx == 2: # Cl
-                 delta = {'Cl': 1 * charge}
-            elif species_idx == 3: # HCOO
-                 delta = {'C': 1 * charge, 'H': 1 * charge, 'O': 2 * charge}
-            elif species_idx == 4: # CH3COO
-                 delta = {'C': 2 * charge, 'H': 3 * charge, 'O': 2 * charge}
-
-        return delta
-
-    def export_csv(self):
-        filename, _ = QFileDialog.getSaveFileName(self, "Save Spectrum CSV", "spectrum.csv", "CSV Files (*.csv)")
-        if not filename: return
-        
-        try:
-            with open(filename, 'w') as f:
-                f.write("m/z,Intensity\n")
-                data = self.plot_widget.peaks
-                for m, i in data:
-                    f.write(f"{m:.5f},{i:.5f}\n")
-            QMessageBox.information(self, "Success", f"Saved to {filename}")
-        except Exception as e:
-            QMessageBox.critical(self, "Error", f"Failed to save CSV: {e}")
-
-    def recalc_peaks(self, reset=True):
-        peaks, final_mw, neutral_exact_mw, ion_mz = self._calculate_peaks()
-        
-        # Apply Gaussian if checked
-        if self.gauss_check.isChecked() and peaks:
-            sigma = self.width_spin.value()
-            display_peaks = self.apply_gaussian_broadening(peaks, sigma)
-            self.plot_widget.draw_mode = "profile"
-        else:
-            display_peaks = peaks
-            self.plot_widget.draw_mode = "stick"
-
-        self.peaks = display_peaks
-        self.plot_widget.peaks = display_peaks
-        self.plot_widget.stick_peaks = peaks # Save theoretical peaks for labels
-        
-        if reset:
-             self.plot_widget.reset_view()
-        else:
-             self.plot_widget.update()
-             
-        # Prepare Info Text for Graph
-        formula_raw = self.formula_input.text().strip()
-        
-        # Format formula (C6H6 -> C₆H₆)
-        sub_map = str.maketrans("0123456789", "₀₁₂₃₄₅₆₇₈₉")
-        formula_formatted = formula_raw.translate(sub_map)
-        
-        full_adduct_str = self.adduct_combo.currentText()
-        import re
-        match = re.search(r"\[.*?\][⁰¹²³⁴⁵⁶⁷⁸⁹⁺⁻˙]*", full_adduct_str)
-        if match:
-             adduct_display = match.group(0)
-        else:
-             adduct_display = full_adduct_str
-        
-        adduct_display = adduct_display.replace("M", formula_formatted)
-
-        if self.charge_spin.value() == 0:
-             adduct_display = "Neutral"
-             self.plot_widget.info_text = f"{formula_formatted}\n{adduct_display}"
-        else:
-             self.plot_widget.info_text = f"{adduct_display}"
-
-        self.plot_widget.update()
-        
-        # Update Info
-        try:
-            self.lbl_ion.setText(f"<b>Monoisotopic m/z:</b> {ion_mz:.4f}")
-            self.lbl_mw.setText(f"<b>Neutral Avg Mass:</b> {final_mw:.4f}")
-            self.lbl_em.setText(f"<b>Neutral Exact Mass:</b> {neutral_exact_mw:.4f}")
-        except:
-            pass
-
-    def apply_gaussian_broadening(self, peaks, sigma):
-        import math
-        if not peaks: return []
-        
-        # Dynamic margin to avoid clipping wide peaks
-        margin = max(2.0, 6.0 * sigma)
-        min_mz = min(p[0] for p in peaks) - margin
-        max_mz = max(p[0] for p in peaks) + margin
-        
-        # Grid - Finer resolution to minimize peak shift artifacts
-        import numpy as np
-        # 10 points per sigma is better for appearance, 20 is good for peak top approx
-        step = min(0.005, sigma / 10.0) 
-        x_vals = np.arange(min_mz, max_mz, step)
-        y_vals = np.zeros_like(x_vals)
-        
-        # Sum Gaussians
-        for center, intensity in peaks:
-            indices = np.where((x_vals >= center - 5*sigma) & (x_vals <= center + 5*sigma))
-            if len(indices[0]) == 0: continue
-            
-            xs = x_vals[indices]
-            ys = intensity * np.exp( - (xs - center)**2 / (2 * sigma**2) )
-            y_vals[indices] += ys
-            
-        if np.max(y_vals) > 0:
-            y_vals = (y_vals / np.max(y_vals)) * 100.0
-            
-        return list(zip(x_vals, y_vals))
-
-    def _calculate_peaks(self):
-        formula_str = self.formula_input.text().strip()
-        if not formula_str:
-            return [], 0.0, 0.0, 0.0
-
-        # 1. Base composition
-        base_counts = self.parse_formula_str(formula_str)
-        if not base_counts:
-             return [], 0.0, 0.0, 0.0
-
-        # 2. Adduct adjustments
-        charge_val = self.charge_spin.value() # Signed
-        charge = abs(charge_val)
-        mode = "Positive" if charge_val > 0 else "Negative"
-        species_idx = self.adduct_combo.currentIndex()
-        
-        delta = self.get_adduct_delta(species_idx, mode, charge)
-        
-        # Merge counts
-        final_counts = base_counts.copy()
-        for el, count in delta.items():
-            final_counts[el] = final_counts.get(el, 0) + count
-            
-        # Remove elements with <= 0 count
-        final_counts = {k: v for k, v in final_counts.items() if v > 0}
-        
-        if not final_counts:
-            return [], 0.0, 0.0, 0.0
-
-        # 3. Dynamic Isotope Calc
-        pt = Chem.GetPeriodicTable()
-        current_dist = [(0.0, 1.0)]
-        electron_mass = 0.00054858
-        
-        total_mw = 0.0 # Neutral average mass
-
-        for sym, count in final_counts.items():
-            # Special handling for Deuterium
-            if sym == "D":
-                 mass_d = 2.0141017781
-                 total_mw += mass_d * count
-                 atom_iso_dist = [(mass_d, 1.0)]
-            else:
-                try:
-                    base_mass = pt.GetAtomicWeight(sym) # Average weight
-                    total_mw += base_mass * count
-                    
-                    atomic_num = pt.GetAtomicNumber(sym)
-                    atom_iso_dist = []
-                    center_mass = pt.GetMostCommonIsotope(atomic_num)
-                    # Scan a range
-                    for m in range(max(1, center_mass - 5), center_mass + 10):
-                        try:
-                            abundance = pt.GetAbundanceForIsotope(atomic_num, m)
-                            if abundance > 0.00001:
-                                exact_mass = pt.GetMassForIsotope(atomic_num, m)
-                                atom_iso_dist.append((exact_mass, abundance))
-                        except RuntimeError: pass
-                    
-                    # Normalize
-                    total_p = sum(p for m, p in atom_iso_dist)
-                    if total_p == 0: continue
-                    atom_iso_dist = [(m, p / total_p) for m, p in atom_iso_dist]
-                except:
-                    # Ignore unknown elements
-                    continue
-
-            # Convolve 'count' times
-            for _ in range(count):
-                new_peaks = {}
-                for m1, p1 in current_dist:
-                    if p1 < 1e-5: continue
-                    for m2, p2 in atom_iso_dist:
-                        m = m1 + m2
-                        p = p1 * p2
-                        m_bin = round(m, 6)
-                        new_peaks[m_bin] = new_peaks.get(m_bin, 0) + p
-                
-                sorted_p = sorted(new_peaks.items())
-                
-                merged = []
-                if sorted_p:
-                    curr_m, curr_p = sorted_p[0]
-                    for m, p in sorted_p[1:]:
-                        if m - curr_m < 0.005:
-                            total = curr_p + p
-                            curr_m = (curr_m * curr_p + m * p) / total
-                            curr_p = total
-                        else:
-                            merged.append((curr_m, curr_p))
-                            curr_m, curr_p = m, p
-                    merged.append((curr_m, curr_p))
-                
-                max_p = max(p for m, p in merged) if merged else 1
-                current_dist = [x for x in merged if x[1] > max_p * 0.001]
-                if len(current_dist) > 200:
-                        current_dist.sort(key=lambda x: x[1], reverse=True)
-                        current_dist = current_dist[:200]
-
-        # Calculate EXACT NEUTRAL MASS (Always needed)
-        exact_mass_sum = 0.0
-        for sym, count in final_counts.items():
-            if sym == "D":
-                 exact_mass_sum += 2.0141017781 * count
-            else:
-                 try:
-                     anum = pt.GetAtomicNumber(sym)
-                     m_iso = pt.GetMostCommonIsotope(anum)
-                     mass_iso = pt.GetMassForIsotope(anum, m_iso)
-                     exact_mass_sum += mass_iso * count
-                 except: pass
-
-        neutral_exact_mass = exact_mass_sum
-
-        # 4. Adjust for Charge (m/z)
-        if charge_val == 0:
-            # Neutral Mode: Hide Spectrum
-            # Return empty peaks, but valid neutral masses
-            return [], total_mw, neutral_exact_mass, 0.0
-
-        # Apply electron mass correction
-        total_ion_mass_dist = []
-        
-        e_params = 0
-        if mode == "Positive":
-             e_params = -1 * charge * electron_mass
-        else:
-             e_params = +1 * charge * electron_mass
-             
-        for m, p in current_dist:
-            ion_mass = m + e_params
-            if ion_mass <= 0: continue
-            mz = ion_mass / charge
-            total_ion_mass_dist.append((mz, p))
-            
-        if not total_ion_mass_dist:
-            return [], total_mw, neutral_exact_mass, 0.0
-
-        max_intensity = max(p for m, p in total_ion_mass_dist)
-        final_peaks = [(m, (p / max_intensity) * 100.0) for m, p in total_ion_mass_dist]
-        final_peaks.sort(key=lambda x: x[0])
-        
-        if mode == "Positive":
-             exact_mass_sum += (-1 * charge * electron_mass)
-        else:
-             exact_mass_sum += (+1 * charge * electron_mass)
-             
-        exact_mz = exact_mass_sum / charge if charge != 0 else 0
-
-        return [p for p in final_peaks if p[1] > 0.05], total_mw, neutral_exact_mass, exact_mz
-
-
-class HistogramWidget(QWidget):
-    def __init__(self, peaks):
-        super().__init__()
-        self.peaks = peaks # list of (mass, intensity) - used for drawing (stick or profile)
-        self.stick_peaks = [] # Always holds the theoretical stick peaks for labeling
-        self.info_text = ""
-        self.draw_mode = "stick" # "stick" or "profile"
-        self.setBackgroundRole(QPalette.ColorRole.Base)
-        self.setAutoFillBackground(False)
-        self.setAttribute(Qt.WidgetAttribute.WA_OpaquePaintEvent)
-        
-        # View State
-        self.view_min = None
-        self.view_max = None
-        self.last_mouse_x = None
-
-    def reset_view(self):
-        # Auto-scale based on stick peaks (stable) or actual peaks
-        if self.stick_peaks:
-            masses = [p[0] for p in self.stick_peaks]
-        elif self.peaks:
-            masses = [p[0] for p in self.peaks]
-        else:
-            masses = []
-
-        if masses:
-            min_m, max_m = min(masses), max(masses)
-            if max_m == min_m:
-                 min_m -= 5.0
-                 max_m += 5.0
-            else:
-                 padding = 5.0
-                 min_m -= padding
-                 max_m += padding
-            self.view_min = min_m
-            self.view_max = max_m
-        else:
-            self.view_min = 0.0
-            self.view_max = 100.0
-        
-        self.update()
-
-    def wheelEvent(self, event):
-        if self.view_min is None or self.view_max is None: return
-        
-        # Current Range
-        current_range = self.view_max - self.view_min
-        if current_range <= 0: return
-
-        # Zoom Factor
-        angle = event.angleDelta().y()
-        factor = 0.9 if angle > 0 else 1.1
-        
-        # Mouse Position Ratio (0.0 to 1.0) relative to plot area
-        w = self.width()
-        ml, mr = 60, 40
-        plot_w = w - ml - mr
-        if plot_w <= 0: return
-        
-        mouse_x = event.position().x()
-        ratio = (mouse_x - ml) / plot_w
-        # Clamp ratio
-        ratio = max(0.0, min(1.0, ratio))
-        
-        # Calculate new range
-        new_range = current_range * factor
-        
-        # Limit zoom (e.g. max range 2000, min range 1.0)
-        if new_range > 5000: new_range = 5000
-        if new_range < 1.0: new_range = 1.0
-        
-        # Adjust min/max keeping ratio point fixed
-        change = new_range - current_range
-        
-        self.view_min -= change * ratio
-        self.view_max += change * (1.0 - ratio)
-        
-        self.update()
-
-    def mousePressEvent(self, event):
-        if event.button() == Qt.MouseButton.LeftButton:
-            self.last_mouse_x = event.position().x()
-
-    def mouseMoveEvent(self, event):
-        if self.last_mouse_x is not None and self.view_min is not None:
-             dx = event.position().x() - self.last_mouse_x
-             
-             w = self.width()
-             ml, mr = 60, 40
-             plot_w = w - ml - mr
-             
-             if plot_w > 0:
-                 current_range = self.view_max - self.view_min
-                 # Pixels to Mass Units
-                 mass_shift = (dx / plot_w) * current_range
-                 
-                 self.view_min -= mass_shift
-                 self.view_max -= mass_shift
-                 self.update()
-             
-             self.last_mouse_x = event.position().x()
-
-    def mouseReleaseEvent(self, event):
-        if event.button() == Qt.MouseButton.LeftButton:
-            self.last_mouse_x = None
-
-    def mouseDoubleClickEvent(self, event):
-        if event.button() == Qt.MouseButton.LeftButton:
-            self.reset_view()
-
-
-
-    def paintEvent(self, event):
-        painter = QPainter(self)
-        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
-        
-        w = self.width()
-        h = self.height()
-        
-        # 1. Background White
-        painter.fillRect(0, 0, w, h, QColor("#ffffff"))
-        
-        # Margins (Increased Top Margin for Labels)
-        ml, mt, mr, mb = 60, 60, 40, 50
-
-
-        
-        if not self.peaks:
-            painter.setPen(QColor("#999999"))
-            font = painter.font()
-            font.setPointSize(12)
-            font.setBold(False)
-            painter.setFont(font)
-            painter.drawText(self.rect(), Qt.AlignmentFlag.AlignCenter, "No Data")
-            return
-
-        plot_w = w - ml - mr
-        plot_h = h - mt - mb
-        
-        if self.view_min is None or self.view_max is None:
-             self.reset_view()
-
-        min_mass = self.view_min
-        max_mass = self.view_max
-            
-        mass_range = max_mass - min_mass
-        max_intensity = 110.0 
-
-        # 2. Draw Grid & Y-Axis Labels
-        painter.setPen(QPen(QColor("#eeeeee"), 1, Qt.PenStyle.SolidLine))
-        font = painter.font()
-        font.setPixelSize(10)
-        font.setBold(False)
-        painter.setFont(font)
-        
-        # Grid lines and Y Labels
-        for i in range(0, 6): # 0 to 5 (0, 20, 40, 60, 80, 100)
-            val = i * 20
-            ratio = val / max_intensity
-            y = (h - mb) - (ratio * plot_h)
-            
-            # Grid Line
-            if i > 0: # Don't draw over X axis
-                painter.setPen(QPen(QColor("#eeeeee"), 1, Qt.PenStyle.SolidLine))
-                painter.drawLine(ml, int(y), w - mr, int(y))
-            
-            # Label
-            painter.setPen(QColor("#000000"))
-            painter.drawText(QRectF(0, y - 10, ml - 5, 20), Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter, str(val))
-
-        # 3. Draw Axes
-        axis_pen = QPen(QColor("#000000"), 2)
-        painter.setPen(axis_pen)
-        # Y axis
-        painter.drawLine(ml, mt, ml, h - mb)
-        # X axis
-        painter.drawLine(ml, h - mb, w - mr, h - mb)
-        
-        # X-Axis Ticks
-        n_ticks = 5
-        tick_step = mass_range / n_ticks
-        import math
-        mag = 10**math.floor(math.log10(tick_step)) if tick_step > 0 else 1
-        nice_step = round(tick_step / mag) * mag
-        if nice_step == 0: nice_step = tick_step
-        
-        start_tick = math.ceil(min_mass / nice_step) * nice_step
-        
-        painter.setPen(QColor("#000000"))
-        curr_tick = start_tick
-        while curr_tick <= max_mass:
-            x_ratio = (curr_tick - min_mass) / mass_range if mass_range > 0 else 0.5
-            x = ml + x_ratio * plot_w
-            
-            if ml <= x <= w - mr:
-                painter.drawLine(int(x), h - mb, int(x), h - mb + 5)
-                painter.drawText(QRectF(x - 30, h - mb + 5, 60, 20), Qt.AlignmentFlag.AlignCenter, f"{curr_tick:.1f}")
-            
-            curr_tick += nice_step
-        
-        # 4. Draw Peaks
-
-
-        font.setPixelSize(11)
-        painter.setFont(font)
-        
-        base_y = h - mb
-
-        if self.draw_mode == "profile":
-            # 1. Draw Profile Curve (CLIPPED)
-            painter.save()
-            painter.setClipRect(ml, mt, plot_w, plot_h)
-            
-            path_points = []
-            first_mass = self.peaks[0][0]
-            first_x_ratio = (first_mass - min_mass) / mass_range if mass_range > 0 else 0.5
-            first_x = ml + first_x_ratio * plot_w
-            path_points.append(QPointF(first_x, base_y))
-            
-            # Use self.peaks (profile data) for Curve
-            for mass, intensity in self.peaks:
-                x_ratio = (mass - min_mass) / mass_range if mass_range > 0 else 0.5
-                y_ratio = intensity / max_intensity
-                
-                x_pos = ml + x_ratio * plot_w
-                y_pos = (h - mb) - (y_ratio * plot_h)
-                path_points.append(QPointF(x_pos, y_pos))
-            
-            last_mass = self.peaks[-1][0]
-            last_x_ratio = (last_mass - min_mass) / mass_range if mass_range > 0 else 0.5
-            last_x = ml + last_x_ratio * plot_w
-            path_points.append(QPointF(last_x, base_y))
-            
-            profile_pen = QPen(QColor("#007bff"), 2)
-            painter.setPen(profile_pen)
-            painter.drawPolyline(path_points)
-            
-            painter.restore() # Unclip for labels
-
-            # 2. Peak Labels (Theoretical Stick Peaks) - UNCLIPPED
-            painter.setPen(QPen(QColor("#007bff")))
-
-            if self.stick_peaks:
-                for s_mass, s_int in self.stick_peaks:
-                    # Filter very low intensity theoretical peaks
-                    if s_int < 0.05: continue 
-                    
-                    if s_mass < min_mass or s_mass > max_mass: continue
-
-                    x_ratio = (s_mass - min_mass) / mass_range if mass_range > 0 else 0.5
-                    y_ratio = s_int / max_intensity
-                    
-                    x_pos = ml + x_ratio * plot_w
-                    y_pos = (h - mb) - (y_ratio * plot_h)
-                    
-                    if not (ml <= x_pos <= w - mr): continue
-                    
-                    # Mass Label - Higher Position over stick peak
-                    # NOTE: We draw label at STICK height, not PROFILE height
-                    label_rect = QRectF(x_pos - 40, y_pos - 25, 80, 20)
-                    painter.setPen(QColor("#000000"))
-                    painter.drawText(label_rect, Qt.AlignmentFlag.AlignCenter, f"{s_mass:.4f}")
-
-        else:
-            # STICK MODE
-            
-            # 1. Draw Sticks (CLIPPED)
-            painter.save()
-            painter.setClipRect(ml, mt, plot_w, plot_h)
-            
-            stick_pen = QPen(QColor("#007bff"), 3) 
-            stick_pen.setCapStyle(Qt.PenCapStyle.RoundCap)
-            painter.setPen(stick_pen)
-            
-            for mass, intensity in self.peaks:
-                x_ratio = (mass - min_mass) / mass_range if mass_range > 0 else 0.5
-                y_ratio = intensity / max_intensity
-                
-                x_pos = ml + x_ratio * plot_w
-                y_pos = (h - mb) - (y_ratio * plot_h)
-
-                painter.drawLine(QPointF(x_pos, base_y), QPointF(x_pos, y_pos))
-                
-            painter.restore() # Unclip for labels
-
-            # 2. Draw Labels (UNCLIPPED)
-            for mass, intensity in self.peaks:
-                x_ratio = (mass - min_mass) / mass_range if mass_range > 0 else 0.5
-                y_ratio = intensity / max_intensity
-                
-                x_pos = ml + x_ratio * plot_w
-                y_pos = (h - mb) - (y_ratio * plot_h)
-                
-                if x_pos < ml or x_pos > w - mr: continue # Simple visibility check
-
-                painter.setPen(QPen(QColor("#000000")))
-                
-                # Mass Label (Line 1)
-                label_rect = QRectF(x_pos - 40, y_pos - 35, 80, 15) 
-                painter.drawText(label_rect, Qt.AlignmentFlag.AlignCenter, f"{mass:.4f}")
-                
-                # Intensity Label (Line 2)
-                painter.setPen(QPen(QColor("#007bff")))
-                int_rect = QRectF(x_pos - 40, y_pos - 20, 80, 15)
-                painter.drawText(int_rect, Qt.AlignmentFlag.AlignCenter, f"{int(intensity)}%")
-        
-        # Axis Labels
-        painter.setPen(QColor("#000000"))
-        font.setBold(True)
-        painter.setFont(font)
-        painter.drawText(QRectF(0, h - 30, w, 20), Qt.AlignmentFlag.AlignCenter, "m/z")
-
-        # Draw Info Text (Top Right) - Drawn Last to be on top of Grid
-        if self.info_text:
-             painter.setPen(QColor("#333333"))
-             font = painter.font()
-             font.setPointSize(14)
-             font.setBold(True)
-             painter.setFont(font)
-             
-             rect = QRectF(w - 250 - mr, mt, 250, 60)
-             # Optional: White background for text to strictly hide grid? 
-             # User just said "change drawing order", implying text on top is enough.
-             # If grid is black and text is black, it might collide.
-             # But usually text on top is standard.
-             # Let's add a slight semi-transparent white bg if needed? 
-             # No, user said "Revert", so let's go back to original simple text but drawn last.
-             painter.drawText(rect, Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignTop, self.info_text)
-        
-        save_state = painter.save()
-        painter.translate(20, h / 2)
-        painter.rotate(-90)
-        painter.drawText(QRectF(-100, -100, 200, 20), Qt.AlignmentFlag.AlignCenter, "Relative Intensity (%)")
-        painter.restore()
-
-def run(mw):
-    if Chem is None:
-        QMessageBox.critical(mw, "MS Plugin", "RDKit is not available.")
-        return
-
-    # Allow launching without a molecule (start empty)
-    dialog = MSSpectrumDialog(mw.current_mol, mw)
-    dialog.exec()
-
-# initialize removed as it only registered the analysis tool