pyTRACTnmr 0.1.1b1__py3-none-any.whl

pyTRACTnmr/__init__.py

@@ -0,0 +1 @@
+# Init tract_gui package

pyTRACTnmr/main.py

@@ -0,0 +1,15 @@
+import sys
+from PySide6.QtWidgets import QApplication
+try:
+    from .window import TractApp
+except ImportError:
+    from window import TractApp
+
+def main():
+    app = QApplication(sys.argv)
+    window = TractApp()
+    window.show()
+    sys.exit(app.exec())
+
+if __name__ == "__main__":
+    main()

pyTRACTnmr/processing.py

@@ -0,0 +1,243 @@
+import os
+import numpy as np
+import nmrglue as ng  # type: ignore
+from scipy.optimize import curve_fit
+from typing import Optional, Tuple, List, Dict
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class TractBruker:
+    """
+    Process Bruker TRACT NMR data for 15N relaxation analysis.
+    """
+
+    # Physical constants (CODATA 2018 values)
+    PLANCK = 6.62607015e-34
+    VACUUM_PERMEABILITY = 1.25663706212e-6
+    GAMMA_1H = 267.52218744e6
+    GAMMA_15N = -27.126e6
+    NH_BOND_LENGTH = 1.02e-10
+    CSA_15N = 160e-6
+    CSA_BOND_ANGLE = 17 * np.pi / 180
+
+    def __init__(self, exp_folder: str, delay_list: Optional[str] = None) -> None:
+        logger.info(f"Initializing TractBruker with folder: {exp_folder}")
+
+        try:
+            self.attributes, self.fids = ng.bruker.read(exp_folder)
+            try:
+                self.phc0 = self.attributes["procs"]["PHC0"]
+                self.phc1 = self.attributes["procs"]["PHC1"]
+            except KeyError:
+                self.phc0 = 0.0
+                self.phc1 = 0.0
+        except Exception as e:
+            raise ValueError(f"Could not load Bruker data: {e}")
+
+        # Handle delays
+        if delay_list and os.path.exists(delay_list):
+            self.delays = self._read_delays(delay_list)
+        else:
+            # Try standard 'vdlist' in folder
+            vdlist_path = os.path.join(exp_folder, "vdlist")
+            if os.path.exists(vdlist_path):
+                self.delays = self._read_delays(vdlist_path)
+            else:
+                logger.warning("No delay list found. Using dummy delays.")
+                # Assuming interleaved alpha/beta, so 2 FIDs per delay point
+                n_delays = self.fids.shape[1] // 2
+                self.delays = np.linspace(0.01, 1.0, n_delays)
+
+        self.alpha_spectra: List[np.ndarray] = []
+        self.beta_spectra: List[np.ndarray] = []
+        # self.alpha_integrals: np.ndarray | None = None
+        # self.beta_integrals: np.ndarray | None = None
+        self.unit_converter = None
+
+    def _read_delays(self, file: str) -> np.ndarray:
+        with open(file, "r") as list_file:
+            delays = list_file.read()
+        delays = delays.replace("u", "e-6").replace("m", "e-3")
+        return np.array([float(x) for x in delays.splitlines() if x.strip()])
+
+    def process_first_trace(
+        self,
+        p0: float,
+        p1: float,
+        points: int = 2048,
+        off: float = 0.35,
+        end: float = 0.98,
+        pow: float = 2.0,
+    ) -> np.ndarray:
+        """Process first FID for interactive phase correction."""
+        fid = self.fids[0, 0]
+        # Apply apodization
+        data = ng.proc_base.sp(fid, off=off, end=end, pow=pow)
+        # Zero filling
+        data = ng.proc_base.zf_size(data, points)
+        # Fourier transform
+        data = ng.proc_base.fft(data)
+        # Remove digital filter
+        data = ng.bruker.remove_digital_filter(self.attributes, data, post_proc=True)
+        # Apply phase correction
+        data = ng.proc_base.ps(data, p0=p0, p1=p1)
+        # Discard imaginary part
+        data = ng.proc_base.di(data)
+        # Reverse spectrum
+        data = ng.proc_base.rev(data)
+
+        # Set up unit converter
+        udic = ng.bruker.guess_udic(self.attributes, data)
+        self.unit_converter = ng.fileiobase.uc_from_udic(udic)
+        return data
+
+    def split_process(
+        self,
+        p0: float,
+        p1: float,
+        points: int = 2048,
+        off: float = 0.35,
+        end: float = 0.98,
+        pow: float = 2.0,
+    ) -> None:
+        """Process all FIDs and split into alpha/beta."""
+        self.phc0 = p0
+        self.phc1 = p1
+        self.alpha_spectra = []
+        self.beta_spectra = []
+
+        for i in range(self.fids.shape[0]):
+            for j in range(self.fids[i].shape[0]):
+                data = self.fids[i][j]
+                data = ng.proc_base.sp(data, off=off, end=end, pow=pow)
+                data = ng.proc_base.zf_size(data, points)
+                data = ng.proc_base.fft(data)
+                data = ng.bruker.remove_digital_filter(
+                    self.attributes, data, post_proc=True
+                )
+                data = ng.proc_base.ps(data, p0=p0, p1=p1)
+                data = ng.proc_base.di(data)
+                data = ng.proc_bl.baseline_corrector(data)
+                data = ng.proc_base.rev(data)
+
+                if j % 2 == 0:
+                    self.beta_spectra.append(data)
+                else:
+                    self.alpha_spectra.append(data)
+
+        # Unit converter from first spectrum
+        if self.beta_spectra:
+            udic = ng.bruker.guess_udic(self.attributes, self.beta_spectra[0])
+            self.unit_converter = ng.fileiobase.uc_from_udic(udic)
+
+    def integrate_indices(self, start_idx: int, end_idx: int) -> None:
+        """Integrate using point indices."""
+        if not self.alpha_spectra or not self.beta_spectra:
+            raise RuntimeError("No spectra available. Run split_process() first.")
+
+        self.alpha_integrals: np.ndarray = np.array(
+            [s[start_idx:end_idx].sum() for s in self.alpha_spectra]
+        )
+        self.beta_integrals: np.ndarray = np.array(
+            [s[start_idx:end_idx].sum() for s in self.beta_spectra]
+        )
+
+    def integrate_ppm(self, start_ppm: float, end_ppm: float) -> None:
+        """Integrate using ppm range."""
+        if self.unit_converter is None:
+            raise RuntimeError("Unit converter not initialized.")
+
+        idx1 = self.unit_converter(start_ppm, "ppm")
+        idx2 = self.unit_converter(end_ppm, "ppm")
+
+        start = int(min(idx1, idx2))
+        end = int(max(idx1, idx2))
+        self.integrate_indices(start, end)
+
+    @staticmethod
+    def _relax(x, a, r):
+        return a * np.exp(-r * x)
+
+    def calc_relaxation(self) -> None:
+        if self.alpha_integrals is None or self.beta_integrals is None:
+            raise RuntimeError("Must call integrate() before calc_relaxation()")
+
+        # Truncate delays if mismatch
+        n_pts = min(len(self.alpha_integrals), len(self.delays))
+        delays: np.ndarray = self.delays[:n_pts]
+        alpha_ints = self.alpha_integrals[:n_pts]
+        beta_ints = self.beta_integrals[:n_pts]
+
+        # Normalize
+        alpha_norm = alpha_ints / alpha_ints[0]
+        beta_norm = beta_ints / beta_ints[0]
+
+        try:
+            self.popt_alpha, self.pcov_alpha = curve_fit(
+                self._relax, delays, alpha_norm, p0=[1.0, 5.0], maxfev=5000
+            )
+            self.popt_beta, self.pcov_beta = curve_fit(
+                self._relax, delays, beta_norm, p0=[1.0, 5.0], maxfev=5000
+            )
+        except Exception as e:
+            raise RuntimeError(f"Fitting failed: {e}")
+
+        self.Ra: float = self.popt_alpha[1]
+        self.Rb: float = self.popt_beta[1]
+        self.err_Ra: float = np.sqrt(np.diag(self.pcov_alpha))[1]
+        self.err_Rb: float = np.sqrt(np.diag(self.pcov_beta))[1]
+
+    def _tc_equation(self, w_N: float, c: float, S2: float = 1.0) -> float:
+        t1 = (5 * c) / (24 * S2)
+        A = 336 * (S2**2) * (w_N**2)
+        B = 25 * (c**2) * (w_N**4)
+        C = 125 * (c**3) * (w_N**6)
+        D = 625 * (S2**2) * (c**4) * (w_N**10)
+        E = 3025 * (S2**4) * (c**2) * (w_N**8)
+        F = 21952 * (S2**6) * (w_N**6)
+        G = 1800 * c * (w_N**4)
+        term_sqrt = np.sqrt(D - E + F)
+        term_cbrt = (C + 24 * np.sqrt(3) * term_sqrt + G * S2**2) ** (1 / 3)
+        t2 = (A - B) / (24 * (w_N**2) * S2 * term_cbrt)
+        t3 = term_cbrt / (24 * S2 * w_N**2)
+        return t1 - t2 + t3
+
+    def calc_tc(
+        self, B0: Optional[float] = None, S2: float = 1.0, n_bootstrap: int = 1000
+    ) -> None:
+        if not hasattr(self, "Ra"):
+            self.calc_relaxation()
+        if B0 is None:
+            B0 = self.attributes["acqus"]["SFO1"]
+        B_0 = B0 * 1e6 * 2 * np.pi / self.GAMMA_1H
+        p = (
+            self.VACUUM_PERMEABILITY * self.GAMMA_1H * self.GAMMA_15N * self.PLANCK
+        ) / (16 * np.pi**2 * np.sqrt(2) * self.NH_BOND_LENGTH**3)
+        dN = self.GAMMA_15N * B_0 * self.CSA_15N / (3 * np.sqrt(2))
+        w_N = B_0 * self.GAMMA_15N
+        Ra_samples: np.ndarray = np.random.normal(self.Ra, self.err_Ra, n_bootstrap)
+        Rb_samples: np.ndarray = np.random.normal(self.Rb, self.err_Rb, n_bootstrap)
+        c_samples = (Rb_samples - Ra_samples) / (
+            2 * dN * p * (3 * np.cos(self.CSA_BOND_ANGLE) ** 2 - 1)
+        )
+        tau_samples: np.ndarray = (
+            np.array(
+                [self._tc_equation(w_N, c, S2) for c in c_samples if not np.isnan(c)]
+            )
+            * 1e9
+        )
+        self.tau_c = np.mean(tau_samples)
+        self.err_tau_c = np.std(tau_samples)
+
+    def get_fit_data(
+        self,
+    ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+        n_pts = min(len(self.alpha_integrals), len(self.delays))
+        x = self.delays[:n_pts]
+        y_a = self.alpha_integrals[:n_pts] / self.alpha_integrals[0]
+        y_b = self.beta_integrals[:n_pts] / self.beta_integrals[0]
+        return x, y_a, y_b, self.popt_alpha, self.popt_beta

pyTRACTnmr/widgets.py

@@ -0,0 +1,86 @@
+from PySide6.QtWidgets import (
+    QFontDialog,
+    QInputDialog,
+    QFileDialog,
+    QMessageBox,
+    QWidget,
+)
+from matplotlib.backends.backend_qtagg import FigureCanvasQTAgg, NavigationToolbar2QT
+import matplotlib.pyplot as plt
+from matplotlib.figure import Figure
+from typing import Optional
+
+
+class CustomNavigationToolbar(NavigationToolbar2QT):
+    def __init__(
+        self, canvas: FigureCanvasQTAgg, parent: QWidget, coordinates: bool = True
+    ) -> None:
+        super().__init__(canvas, parent, coordinates)
+        self.addSeparator()
+        self.addAction("Font", self.change_font)
+        self.addAction("Export", self.export_figure)
+
+    def export_figure(self) -> None:
+        dpi, ok = QInputDialog.getInt(
+            self, "Export Settings", "DPI:", value=300, minValue=72, maxValue=1200
+        )
+        if not ok:
+            return
+        fname, _ = QFileDialog.getSaveFileName(
+            self, "Save Figure", "", "PNG (*.png);;PDF (*.pdf);;SVG (*.svg)"
+        )
+        if fname:
+            try:
+                self.canvas.figure.savefig(fname, dpi=dpi, bbox_inches="tight")
+            except Exception as e:
+                QMessageBox.critical(self, "Error", f"Could not save figure: {e}")
+
+    def change_font(self) -> None:
+        ok, font = QFontDialog.getFont(self)
+        if ok:
+            size = font.pointSize()
+            family = font.family()
+
+            # Update rcParams for future plots
+            plt.rcParams.update(
+                {
+                    "font.size": size,
+                    "font.family": family,
+                    "axes.labelsize": size,
+                    "axes.titlesize": size + 2,
+                    "xtick.labelsize": size,
+                    "ytick.labelsize": size,
+                    "legend.fontsize": size,
+                }
+            )
+
+            # Update current figure elements
+            for ax in self.canvas.figure.axes:
+                for item in (
+                    [ax.title, ax.xaxis.label, ax.yaxis.label]
+                    + ax.get_xticklabels()
+                    + ax.get_yticklabels()
+                ):
+                    item.set_fontsize(size)
+                    item.set_fontfamily(family)
+
+                legend = ax.get_legend()
+                if legend:
+                    for text in legend.get_texts():
+                        text.set_fontsize(size)
+                        text.set_fontfamily(family)
+
+            self.canvas.draw()
+
+
+class MplCanvas(FigureCanvasQTAgg):
+    def __init__(
+        self,
+        parent: Optional[QWidget] = None,
+        width: float = 5,
+        height: float = 4,
+        dpi: int = 100,
+    ) -> None:
+        self.fig = Figure(figsize=(width, height), dpi=dpi)
+        self.axes = self.fig.add_subplot(111)
+        super().__init__(self.fig)

pyTRACTnmr/window.py

@@ -0,0 +1,628 @@
+import os
+import csv
+import numpy as np
+from typing import List, Dict, Any, Optional
+from PySide6.QtWidgets import (
+    QMainWindow,
+    QWidget,
+    QVBoxLayout,
+    QHBoxLayout,
+    QPushButton,
+    QLabel,
+    QLineEdit,
+    QFileDialog,
+    QSplitter,
+    QTabWidget,
+    QFormLayout,
+    QGroupBox,
+    QMessageBox,
+    QTableWidget,
+    QTableWidgetItem,
+    QHeaderView,
+    QMenu,
+    QSlider,
+)
+from PySide6.QtGui import QAction
+from PySide6.QtCore import Qt, QPoint
+
+from matplotlib.widgets import SpanSelector
+try:
+    from .widgets import MplCanvas, CustomNavigationToolbar
+    from . import processing
+except ImportError:
+    from widgets import MplCanvas, CustomNavigationToolbar
+    import processing
+
+
+class TractApp(QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("TRACT Analysis GUI")
+        self.resize(1200, 800)
+
+        # Data State
+        self.dic = None
+        self.data = None
+        self.proc_data = None
+        self.time_points = None
+        self.datasets: List[Dict[str, Any]] = []
+        self.current_idx: int = -1
+        self.selector: Optional[SpanSelector] = None
+
+        self.init_ui()
+
+    def init_ui(self) -> None:
+        main_widget = QWidget()
+        self.setCentralWidget(main_widget)
+        main_layout = QHBoxLayout(main_widget)
+
+        # --- Panel 1: Data Loading ---
+        panel1 = QGroupBox("Experiment Info")
+        layout1 = QVBoxLayout()
+
+        self.btn_load = QPushButton("Load Bruker Directory")
+        self.btn_load.clicked.connect(self.load_data)
+
+        self.current_experiment = QLineEdit()
+        self.current_experiment.setPlaceholderText("Current Experiment")
+        self.current_experiment.setReadOnly(True)
+
+        self.table_data = QTableWidget()
+        self.table_data.setColumnCount(9)
+        self.table_data.setHorizontalHeaderLabels(
+            ["Experiment", "Temperature (K)", "Delays", "Ra (Hz)", "Rb (Hz)", "Tau_C (ns)", "Err Ra", "Err Rb", "Err Tau_C"]
+        )
+        self.table_data.horizontalHeader().setSectionResizeMode(
+            QHeaderView.ResizeMode.Stretch
+        )
+        self.table_data.setSelectionBehavior(QTableWidget.SelectionBehavior.SelectRows)
+        self.table_data.setEditTriggers(
+            QTableWidget.EditTrigger.DoubleClicked
+            | QTableWidget.EditTrigger.EditKeyPressed
+        )
+        self.table_data.cellDoubleClicked.connect(self.on_table_double_click)
+        self.table_data.itemChanged.connect(self.on_table_item_changed)
+        self.table_data.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
+        self.table_data.customContextMenuRequested.connect(self.show_context_menu)
+
+        layout1.addWidget(QLabel("Load Data:"))
+        layout1.addWidget(self.btn_load)
+        layout1.addSpacing(10)
+        layout1.addWidget(QLabel("Current Experiment:"))
+        layout1.addWidget(self.current_experiment)
+        layout1.addSpacing(10)
+        layout1.addWidget(self.table_data)
+        layout1.addStretch()
+        panel1.setLayout(layout1)
+
+        # --- Panel 2: Visualization ---
+        splitter_center = QSplitter(Qt.Orientation.Vertical)
+
+        # Top: Spectrum
+        self.canvas_spec = MplCanvas(self)
+        self.toolbar_spec = CustomNavigationToolbar(self.canvas_spec, self)
+        widget_spec = QWidget()
+        layout_spec = QVBoxLayout()
+        lbl_spec = QLabel("<b>Processed Spectrum (Phase Check)</b>")
+        lbl_spec.setFixedHeight(30)
+        layout_spec.addWidget(lbl_spec)
+        layout_spec.addWidget(self.toolbar_spec)
+        layout_spec.addWidget(self.canvas_spec)
+        widget_spec.setLayout(layout_spec)
+
+        # Bottom: Fits
+        self.canvas_fit = MplCanvas(self)
+        self.toolbar_fit = CustomNavigationToolbar(self.canvas_fit, self)
+        widget_fit = QWidget()
+        layout_fit = QVBoxLayout()
+        lbl_fit = QLabel("<b>Relaxation Fits</b>")
+        lbl_fit.setFixedHeight(30)
+        layout_fit.addWidget(lbl_fit)
+        layout_fit.addWidget(self.toolbar_fit)
+        layout_fit.addWidget(self.canvas_fit)
+        widget_fit.setLayout(layout_fit)
+
+        splitter_center.addWidget(widget_spec)
+        splitter_center.addWidget(widget_fit)
+
+        # --- Panel 3: Controls ---
+        panel3 = QTabWidget()
+
+        # Tab 1: Processing
+        tab1 = QWidget()
+        layout_t1 = QFormLayout()
+
+        self.slider_p0_coarse = QSlider(Qt.Orientation.Horizontal)
+        self.slider_p0_coarse.setRange(-180, 180)
+        self.slider_p0_coarse.setValue(0)
+        self.slider_p0_coarse.valueChanged.connect(self.process_data)
+
+        self.slider_p0_fine = QSlider(Qt.Orientation.Horizontal)
+        self.slider_p0_fine.setRange(-50, 50)
+        self.slider_p0_fine.setValue(0)
+        self.slider_p0_fine.valueChanged.connect(self.process_data)
+        self.input_p0 = QLineEdit("0.0")
+        self.input_p0.setFixedWidth(50)
+        self.input_p0.editingFinished.connect(self.update_phase_from_text)
+
+        self.slider_p1_coarse = QSlider(Qt.Orientation.Horizontal)
+        self.slider_p1_coarse.setRange(-360, 360)
+        self.slider_p1_coarse.setValue(0)
+        self.slider_p1_coarse.valueChanged.connect(self.process_data)
+
+        self.slider_p1_fine = QSlider(Qt.Orientation.Horizontal)
+        self.slider_p1_fine.setRange(-50, 50)
+        self.slider_p1_fine.setValue(0)
+        self.slider_p1_fine.valueChanged.connect(self.process_data)
+        self.input_p1 = QLineEdit("0.0")
+        self.input_p1.setFixedWidth(50)
+        self.input_p1.editingFinished.connect(self.update_phase_from_text)
+
+        self.input_points = QLineEdit("2048")
+        self.input_points.editingFinished.connect(self.process_data)
+
+        self.input_off = QLineEdit("0.35")
+        self.input_off.editingFinished.connect(self.process_data)
+
+        self.input_end = QLineEdit("0.98")
+        self.input_end.editingFinished.connect(self.process_data)
+
+        self.input_pow = QLineEdit("2.0")
+        self.input_pow.editingFinished.connect(self.process_data)
+
+        self.input_int_start = QLineEdit("9.5")
+        self.input_int_start.editingFinished.connect(self.process_data)
+        self.input_int_end = QLineEdit("7.5")
+        self.input_int_end.editingFinished.connect(self.process_data)
+
+        layout_t1.addRow("P0 Coarse:", self.slider_p0_coarse)
+        layout_t1.addRow(
+            "P0 Fine (+/- 5):",
+            self.create_slider_layout(self.slider_p0_fine, self.input_p0),
+        )
+        layout_t1.addRow("P1 Coarse:", self.slider_p1_coarse)
+        layout_t1.addRow(
+            "P1 Fine (+/- 5):",
+            self.create_slider_layout(self.slider_p1_fine, self.input_p1),
+        )
+        layout_t1.addRow(QLabel("<b>Apodization & ZF</b>"))
+        layout_t1.addRow("Points (ZF):", self.input_points)
+        layout_t1.addRow("Sine Offset:", self.input_off)
+        layout_t1.addRow("Sine End:", self.input_end)
+        layout_t1.addRow("Sine Power:", self.input_pow)
+        layout_t1.addRow(QLabel("<b>Integration Range</b>"))
+        layout_t1.addRow("Start (ppm):", self.input_int_start)
+        layout_t1.addRow("End (ppm):", self.input_int_end)
+        tab1.setLayout(layout_t1)
+
+        # Tab 2: Fitting
+        tab2 = QWidget()
+        layout_t2 = QFormLayout()
+        self.input_field = QLineEdit("600")
+        self.input_csa = QLineEdit("160")
+        self.input_angle = QLineEdit("17")
+        self.input_s2 = QLineEdit("1.0")
+        self.input_bootstraps = QLineEdit("1000")
+        self.btn_fit = QPushButton("Calculate Tau_c")
+        self.btn_fit.clicked.connect(self.run_fitting)
+        self.lbl_results = QLabel("Results will appear here.")
+        self.lbl_results.setWordWrap(True)
+
+        layout_t2.addRow("Field Strength (MHz):", self.input_field)
+        layout_t2.addRow("CSA (ppm):", self.input_csa)
+        layout_t2.addRow("CSA Angle (deg):", self.input_angle)
+        layout_t2.addRow("Order Parameter (S2):", self.input_s2)
+        layout_t2.addRow("Bootstraps:", self.input_bootstraps)
+        layout_t2.addRow(self.btn_fit)
+        layout_t2.addRow(self.lbl_results)
+        tab2.setLayout(layout_t2)
+
+        panel3.addTab(tab1, "Processing")
+        panel3.addTab(tab2, "Fitting")
+
+        main_splitter = QSplitter(Qt.Orientation.Horizontal)
+        main_splitter.addWidget(panel1)
+        main_splitter.addWidget(splitter_center)
+        main_splitter.addWidget(panel3)
+        main_splitter.setSizes([400, 500, 300])
+        main_layout.addWidget(main_splitter)
+
+    def create_slider_layout(self, slider: QSlider, label: QWidget) -> QWidget:
+        widget = QWidget()
+        layout = QHBoxLayout(widget)
+        layout.addWidget(slider)
+        layout.addWidget(label)
+        layout.setContentsMargins(0, 0, 0, 0)
+        return widget
+
+    def update_phase_from_text(self) -> None:
+        try:
+            p0 = float(self.input_p0.text())
+            p1 = float(self.input_p1.text())
+
+            self.slider_p0_coarse.blockSignals(True)
+            self.slider_p0_fine.blockSignals(True)
+            self.slider_p1_coarse.blockSignals(True)
+            self.slider_p1_fine.blockSignals(True)
+
+            self.slider_p0_coarse.setValue(int(p0))
+            self.slider_p0_fine.setValue(int(round((p0 - int(p0)) * 10)))
+
+            self.slider_p1_coarse.setValue(int(p1))
+            self.slider_p1_fine.setValue(int(round((p1 - int(p1)) * 10)))
+
+            self.slider_p0_coarse.blockSignals(False)
+            self.slider_p0_fine.blockSignals(False)
+            self.slider_p1_coarse.blockSignals(False)
+            self.slider_p1_fine.blockSignals(False)
+
+            self.process_data()
+        except ValueError:
+            pass
+
+    def load_data(self) -> None:
+        folder = QFileDialog.getExistingDirectory(self, "Select Bruker Directory")
+        if folder:
+            try:
+                delay_list = None
+                if not os.path.exists(os.path.join(folder, "vdlist")):
+                    delay_list, _ = QFileDialog.getOpenFileName(
+                        self, "vdlist not found. Select delay list file:", folder
+                    )
+
+                tb = processing.TractBruker(folder, delay_list=delay_list)
+                name = os.path.basename(folder)
+                dataset = {
+                    "name": name,
+                    "path": folder,
+                    "handler": tb,
+                    "p0": tb.phc0,
+                    "p1": tb.phc1,
+                }
+                self.datasets.append(dataset)
+                self.update_table()
+                self.switch_dataset(len(self.datasets) - 1)
+            except Exception as e:
+                QMessageBox.critical(self, "Error", f"Failed to load data: {str(e)}")
+
+    def process_data(self) -> None:
+        if self.current_idx < 0:
+            return
+        try:
+            p0 = self.slider_p0_coarse.value() + (self.slider_p0_fine.value() / 10.0)
+            p1 = self.slider_p1_coarse.value() + (self.slider_p1_fine.value() / 10.0)
+
+            self.input_p0.setText(f"{p0:.1f}")
+            self.input_p1.setText(f"{p1:.1f}")
+
+            points = int(self.input_points.text())
+            off = float(self.input_off.text())
+            end = float(self.input_end.text())
+            pow_val = float(self.input_pow.text())
+
+            if self.current_idx >= 0:
+                self.datasets[self.current_idx]["p0"] = p0
+                self.datasets[self.current_idx]["p1"] = p1
+
+            tb = self.datasets[self.current_idx]["handler"]
+            trace = tb.process_first_trace(
+                p0, p1, points=points, off=off, end=end, pow=pow_val
+            )
+
+            self.canvas_spec.axes.clear()
+            if tb.unit_converter:
+                ppm_scale = tb.unit_converter.ppm_scale()
+                self.canvas_spec.axes.plot(ppm_scale, trace, label="First Plane")
+                self.canvas_spec.axes.invert_xaxis()
+                self.canvas_spec.axes.set_xlabel(r"$^{1}H (ppm)$")
+                self.canvas_spec.axes.set_ylabel("Intensity")
+            else:
+                self.canvas_spec.axes.plot(trace, label="First Plane")
+            self.canvas_spec.axes.legend()
+
+            self.selector = SpanSelector(
+                self.canvas_spec.axes,
+                self.on_span_select,
+                "horizontal",
+                useblit=True,
+                props=dict(alpha=0.2, facecolor="green"),
+                interactive=True,
+                drag_from_anywhere=True,
+            )
+            try:
+                s = float(self.input_int_start.text())
+                e = float(self.input_int_end.text())
+                self.selector.extents = (min(s, e), max(s, e))
+            except ValueError:
+                pass
+
+            self.canvas_spec.draw()
+        except Exception as e:
+            QMessageBox.critical(self, "Processing Error", str(e))
+
+    def run_fitting(self) -> None:
+        if self.current_idx < 0:
+            return
+        try:
+            tb = self.datasets[self.current_idx]["handler"]
+            p0 = self.slider_p0_coarse.value() + (self.slider_p0_fine.value() / 10.0)
+            p1 = self.slider_p1_coarse.value() + (self.slider_p1_fine.value() / 10.0)
+
+            points = int(self.input_points.text())
+            off = float(self.input_off.text())
+            end_param = float(self.input_end.text())
+            pow_val = float(self.input_pow.text())
+            start_ppm = float(self.input_int_start.text())
+            end_ppm = float(self.input_int_end.text())
+
+            # Update physics constants
+            tb.CSA_15N = float(self.input_csa.text()) * 1e-6
+            tb.CSA_BOND_ANGLE = float(self.input_angle.text()) * np.pi / 180
+            s2_val = float(self.input_s2.text())
+
+            try:
+                n_boot = int(self.input_bootstraps.text())
+                if n_boot < 10:
+                    n_boot = 10
+                    self.input_bootstraps.setText("10")
+            except ValueError:
+                n_boot = 1000
+                self.input_bootstraps.setText("1000")
+
+            tb.split_process(p0, p1, points=points, off=off, end=end_param, pow=pow_val)
+            tb.integrate_ppm(start_ppm, end_ppm)
+            tb.calc_relaxation()
+
+            b0 = float(self.input_field.text()) if self.input_field.text() else None
+            tb.calc_tc(B0=b0, S2=s2_val, n_bootstrap=n_boot)
+
+            x, y_a, y_b, popt_a, popt_b = tb.get_fit_data()
+
+            self.canvas_fit.axes.clear()
+            self.canvas_fit.axes.plot(x, y_a, "bo", label=r"$\alpha -spin\ state$")
+            self.canvas_fit.axes.plot(x, y_b, "ro", label=r"$\beta -spin\ state$")
+            self.canvas_fit.axes.plot(
+                x, processing.TractBruker._relax(x, *popt_a), "b-"
+            )
+            self.canvas_fit.axes.plot(
+                x, processing.TractBruker._relax(x, *popt_b), "r-"
+            )
+            self.canvas_fit.axes.set_xlabel("Delay (s)")
+            self.canvas_fit.axes.set_ylabel(r"$I/I_0$")
+
+            res_text = (
+                f"Ra: {tb.Ra:.2f} +/- {tb.err_Ra:.2f} Hz\n"
+                f"Rb: {tb.Rb:.2f} +/- {tb.err_Rb:.2f} Hz\n"
+                f"Tau_c: {tb.tau_c:.2f} +/- {tb.err_tau_c:.2f} ns"
+            )
+            self.lbl_results.setText(res_text)
+
+            self.canvas_fit.axes.legend()
+            self.canvas_fit.draw()
+
+            self.update_table()
+        except Exception as e:
+            QMessageBox.critical(self, "Fit Error", str(e))
+
+    def export_table_to_csv(self) -> None:
+        path, _ = QFileDialog.getSaveFileName(self, "Save CSV", "", "CSV Files (*.csv)")
+        if not path:
+            return
+        try:
+            with open(path, 'w', newline='') as f:
+                writer = csv.writer(f)
+                headers = []
+                for col in range(self.table_data.columnCount()):
+                    item = self.table_data.horizontalHeaderItem(col)
+                    headers.append(item.text() if item else "")
+                writer.writerow(headers)
+                for row in range(self.table_data.rowCount()):
+                    row_data = [self.table_data.item(row, col).text() if self.table_data.item(row, col) else "" for col in range(self.table_data.columnCount())]
+                    writer.writerow(row_data)
+        except Exception as e:
+            QMessageBox.critical(self, "Export Error", str(e))
+
+    def update_table(self) -> None:
+        self.table_data.blockSignals(True)
+        self.table_data.setRowCount(len(self.datasets))
+        for i, ds in enumerate(self.datasets):
+            # Experiment Name (Editable)
+            item_name = QTableWidgetItem(ds["name"])
+            item_name.setFlags(item_name.flags() | Qt.ItemFlag.ItemIsEditable)
+            self.table_data.setItem(i, 0, item_name)
+
+            # Temperature
+            try:
+                temp = ds["handler"].attributes["acqus"]["TE"]
+            except (KeyError, TypeError):
+                temp = "N/A"
+            item_temp = QTableWidgetItem(str(temp))
+            item_temp.setFlags(item_temp.flags() & ~Qt.ItemFlag.ItemIsEditable)
+            self.table_data.setItem(i, 1, item_temp)
+
+            # Delays
+            n_delays = (
+                len(ds["handler"].delays) if ds["handler"].delays is not None else 0
+            )
+            item_delays = QTableWidgetItem(str(n_delays))
+            item_delays.setFlags(item_delays.flags() & ~Qt.ItemFlag.ItemIsEditable)
+            self.table_data.setItem(i, 2, item_delays)
+
+            # Helper for values
+            def get_val(attr):
+                if hasattr(ds["handler"], attr):
+                    return f"{getattr(ds['handler'], attr):.2f}"
+                return "N/A"
+
+            # Ra
+            item_ra = QTableWidgetItem(get_val("Ra"))
+            item_ra.setFlags(item_ra.flags() & ~Qt.ItemFlag.ItemIsEditable)
+            self.table_data.setItem(i, 3, item_ra)
+
+            # Rb
+            item_rb = QTableWidgetItem(get_val("Rb"))
+            item_rb.setFlags(item_rb.flags() & ~Qt.ItemFlag.ItemIsEditable)
+            self.table_data.setItem(i, 4, item_rb)
+
+            # Tau_C
+            item_tau = QTableWidgetItem(get_val("tau_c"))
+            item_tau.setFlags(item_tau.flags() & ~Qt.ItemFlag.ItemIsEditable)
+            self.table_data.setItem(i, 5, item_tau)
+
+            # Errors
+            for col, attr in enumerate(["err_Ra", "err_Rb", "err_tau_c"], start=6):
+                item_err = QTableWidgetItem(get_val(attr))
+                item_err.setFlags(item_err.flags() & ~Qt.ItemFlag.ItemIsEditable)
+                self.table_data.setItem(i, col, item_err)
+
+        self.table_data.blockSignals(False)
+
+    def on_table_double_click(self, row: int, col: int) -> None:
+        if col == 0:
+            return
+        self.switch_dataset(row)
+
+    def on_table_item_changed(self, item: QTableWidgetItem) -> None:
+        if item.column() == 0:
+            row = item.row()
+            new_name = item.text()
+            if row < len(self.datasets):
+                self.datasets[row]["name"] = new_name
+                if row == self.current_idx:
+                    self.current_experiment.setText(new_name)
+
+    def switch_dataset(self, index: int) -> None:
+        if index < 0 or index >= len(self.datasets):
+            return
+        self.current_idx = index
+        ds = self.datasets[index]
+        tb = ds["handler"]
+
+        self.current_experiment.setText(ds["name"])
+
+        # Update Field Strength from parameters
+        try:
+            self.input_field.setText("{:.2f}".format(tb.attributes["acqus"]["SFO1"]))
+        except (KeyError, AttributeError):
+            pass
+
+        self.slider_p0_coarse.blockSignals(True)
+        self.slider_p0_fine.blockSignals(True)
+        self.slider_p1_coarse.blockSignals(True)
+        self.slider_p1_fine.blockSignals(True)
+
+        p0 = ds["p0"]
+        self.slider_p0_coarse.setValue(int(p0))
+        self.slider_p0_fine.setValue(round((p0 - int(p0)) * 10))
+        self.input_p0.setText(f"{p0:.1f}")
+
+        p1 = ds["p1"]
+        self.slider_p1_coarse.setValue(int(p1))
+        self.slider_p1_fine.setValue(round((p1 - int(p1)) * 10))
+        self.input_p1.setText(f"{p1:.1f}")
+
+        self.slider_p0_coarse.blockSignals(False)
+        self.slider_p0_fine.blockSignals(False)
+        self.slider_p1_coarse.blockSignals(False)
+        self.slider_p1_fine.blockSignals(False)
+
+        self.process_data()
+
+        # Update fit display
+        self.canvas_fit.axes.clear()
+        self.lbl_results.setText("Results will appear here.")
+
+        if hasattr(tb, "Ra") and hasattr(tb, "popt_alpha"):
+            try:
+                x, y_a, y_b, popt_a, popt_b = tb.get_fit_data()
+                self.canvas_fit.axes.plot(x, y_a, "bo", label="Alpha (Anti-TROSY)")
+                self.canvas_fit.axes.plot(x, y_b, "ro", label="Beta (TROSY)")
+                self.canvas_fit.axes.plot(
+                    x, processing.TractBruker._relax(x, *popt_a), "b-"
+                )
+                self.canvas_fit.axes.plot(
+                    x, processing.TractBruker._relax(x, *popt_b), "r-"
+                )
+
+                tau_c_val = getattr(tb, "tau_c", 0.0)
+                err_tau_c_val = getattr(tb, "err_tau_c", 0.0)
+                res_text = (
+                    f"Ra: {tb.Ra:.2f} +/- {tb.err_Ra:.2f} Hz\n"
+                    f"Rb: {tb.Rb:.2f} +/- {tb.err_Rb:.2f} Hz\n"
+                    f"Tau_c: {tau_c_val:.2f} +/- {err_tau_c_val:.2f} ns"
+                )
+                self.lbl_results.setText(res_text)
+                self.canvas_fit.axes.legend()
+            except Exception:
+                pass
+
+        self.canvas_fit.draw()
+
+    def update_sample_name(self) -> None:
+        if self.current_idx >= 0:
+            name = self.current_experiment.text()
+            self.datasets[self.current_idx]["name"] = name
+            self.update_table()
+
+    def show_context_menu(self, pos: QPoint) -> None:
+        menu = QMenu()
+        action_change = QAction("Change Experiment", self)
+        action_delete = QAction("Delete Experiment", self)
+        action_export = QAction("Export Table to CSV", self)
+
+        action_change.triggered.connect(self.change_experiment)
+        action_delete.triggered.connect(self.delete_experiment)
+        action_export.triggered.connect(self.export_table_to_csv)
+
+        menu.addAction(action_change)
+        menu.addAction(action_delete)
+        menu.addSeparator()
+        menu.addAction(action_export)
+        menu.exec(self.table_data.mapToGlobal(pos))
+
+    def change_experiment(self) -> None:
+        row = self.table_data.currentRow()
+        if row < 0:
+            return
+        folder = QFileDialog.getExistingDirectory(self, "Select Bruker Directory")
+        if folder:
+            try:
+                delay_list = None
+                if not os.path.exists(os.path.join(folder, "vdlist")):
+                    delay_list, _ = QFileDialog.getOpenFileName(
+                        self, "vdlist not found. Select delay list file:", folder
+                    )
+
+                tb = processing.TractBruker(folder, delay_list=delay_list)
+                self.datasets[row]["handler"] = tb
+                self.datasets[row]["path"] = folder
+                self.datasets[row]["name"] = os.path.basename(folder)
+                self.datasets[row]["p0"] = tb.phc0
+                self.datasets[row]["p1"] = tb.phc1
+                self.update_table()
+                if row == self.current_idx:
+                    self.switch_dataset(row)
+            except Exception as e:
+                QMessageBox.critical(self, "Error", f"Failed to change data: {str(e)}")
+
+    def delete_experiment(self) -> None:
+        row = self.table_data.currentRow()
+        if row < 0:
+            return
+        del self.datasets[row]
+        self.update_table()
+        if len(self.datasets) == 0:
+            self.current_idx = -1
+            self.canvas_spec.axes.clear()
+            self.canvas_spec.draw()
+            self.canvas_fit.axes.clear()
+            self.canvas_fit.draw()
+            self.current_experiment.clear()
+        elif row == self.current_idx:
+            self.switch_dataset(max(0, row - 1))
+        elif row < self.current_idx:
+            self.current_idx -= 1
+
+    def on_span_select(self, vmin: float, vmax: float) -> None:
+        self.input_int_start.setText(f"{vmax:.3f}")
+        self.input_int_end.setText(f"{vmin:.3f}")

pytractnmr-0.1.1b1.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: pyTRACTnmr
+Version: 0.1.1b1
+Summary: A simple gui based application to process and analyse TRACT data from NMR spectroscopy.
+Requires-Python: >=3.14
+Requires-Dist: matplotlib>=3.10.8
+Requires-Dist: nmrglue>=0.11
+Requires-Dist: numpy>=2.4.2
+Requires-Dist: pyside6-stubs>=6.7.3.0
+Requires-Dist: pyside6>=6.10.2
+Requires-Dist: scipy-stubs>=1.17.0.2
+Requires-Dist: scipy>=1.17.0
+Description-Content-Type: text/markdown
+
+This is a simple GUI application for processing and Analysing TRACT data. Currently this only supports collected with Bruker spectrometers with pulseprogram `tractf3gpphwg`.

pytractnmr-0.1.1b1.dist-info/RECORD

@@ -0,0 +1,9 @@
+pyTRACTnmr/__init__.py,sha256=5rxO0E3s6JQ3X_bBwWIR3tOVEZrS4ZIC-_LZPemSnmQ,24
+pyTRACTnmr/main.py,sha256=o1UZv2D9Kay36K4hoKR0iu_xRw3QuFxofzehycXoSSw,296
+pyTRACTnmr/processing.py,sha256=8Afvi66NDRBXWs7l260uIYOSxr4X-GpDZf8zWL3SRck,9204
+pyTRACTnmr/widgets.py,sha256=DlSSWUZ_soVfeXvkm5s26zPKoxREUW-4x5__vvXtpj4,2818
+pyTRACTnmr/window.py,sha256=geP_yvoXslK14yyRNBVYH2XmWl4cogAUbMn6FXYO94I,24399
+pytractnmr-0.1.1b1.dist-info/METADATA,sha256=tNeUqf02m2xHpx1Lp7zo5gB9Ptc8Kv112ZEGBjYA5bc,617
+pytractnmr-0.1.1b1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+pytractnmr-0.1.1b1.dist-info/entry_points.txt,sha256=wAW1nWzvGBezl-fd7fcJLk-2iMC4ow11xTi-uSfcUC0,52
+pytractnmr-0.1.1b1.dist-info/RECORD,,

pytractnmr-0.1.1b1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pytractnmr-0.1.1b1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pytractnmr = pyTRACTnmr.main:main