| |
| """ |
| Created on Fri Sep 30 10:13:32 2022 |
| |
| @author: DELL |
| """ |
|
|
| import os |
| import re |
| import hnswlib |
| import string |
| import random |
| import shutil |
| import pickle |
| import numpy as np |
| import pandas as pd |
|
|
| from itertools import chain |
| |
| from PyQt5.QtCore import Qt, QVariant, QThread |
| from PyQt5 import QtCore, QtWidgets, QtGui |
| from PyQt5.QtGui import QPixmap |
| from PyQt5.QtWidgets import QApplication, QMainWindow, QGridLayout, QLabel |
|
|
| from matplotlib.figure import Figure |
| from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas |
| from matplotlib.backends.backend_qt5 import NavigationToolbar2QT as NavigationToolbar |
|
|
| import matchms.filtering as msfilters |
| from hnswlib import Index |
| from rdkit import Chem |
| from rdkit.Chem import Draw, rdFMCS |
| from molmass import Formula |
| from matchms.Spectrum import Spectrum |
| from matchms.importing import load_from_mgf |
| from gensim.models import Word2Vec |
|
|
| from uic import main |
| from core.identification import identify_unknown, match_spectrum |
|
|
|
|
| class DeepMASS2(QMainWindow, main.Ui_MainWindow): |
| |
| def __init__(self, parent=None): |
| super(DeepMASS2, self).__init__(parent) |
| self.setupUi(self) |
| self.setWindowTitle("DeepMASS2") |
| self.setWindowIcon(QtGui.QIcon("icon/favicon.ico")) |
| |
| try: |
| shutil.rmtree('temp') |
| os.mkdir('temp') |
| except: |
| pass |
| |
| |
| self.label_logo.setPixmap(QPixmap("icon/logo_deepmass.png")) |
| |
| |
| self.LabelAnno = QLabel() |
| self.gridlayoutAnno = QGridLayout(self.groupBoxAnno) |
| self.gridlayoutAnno.addWidget(self.LabelAnno) |
| self.LabelRef = QLabel() |
| self.gridlayoutRef = QGridLayout(self.groupBoxRef) |
| self.gridlayoutRef.addWidget(self.LabelRef) |
| |
| self.figSpe = MakeFigure(3.6, 2.4, dpi = 300) |
| self.figSpe_ntb = NavigationToolbar(self.figSpe, self) |
| self.gridlayoutfigSpec = QGridLayout(self.box_spectrum) |
| self.gridlayoutfigSpec.addWidget(self.figSpe) |
| self.gridlayoutfigSpec.addWidget(self.figSpe_ntb) |
| |
| |
| |
| self.pn = None |
| self.pp = None |
| self.database = pd.DataFrame() |
| self.spectrums = pd.DataFrame(columns=['title', 'spectrum']) |
| self.identified_spectrums = [] |
| self.reference_positive = None |
| self.reference_negative = None |
| self.default_index_positive = 'data/references_index_positive_spec2vec.bin' |
| self.default_index_negative = 'data/references_index_negative_spec2vec.bin' |
| self.default_reference_positive = 'data/references_spectrums_positive.pickle' |
| self.default_reference_negative = 'data/references_spectrums_negative.pickle' |
| try: |
| self.default_database = pd.read_csv('data/DeepMassStructureDB-v1.0.csv') |
| except: |
| self.ErrorMsg("Missing data files") |
| return |
| self.current_spectrum = None |
| self.current_reference = None |
| |
| |
| self.butt_open.setDisabled(True) |
| self.butt_run.setDisabled(True) |
| self.butt_match.setDisabled(True) |
| self.butt_save.setDisabled(True) |
| self.butt_open.clicked.connect(self.load_spectrums) |
| self.butt_save.clicked.connect(self.save_identification) |
| self.butt_run.clicked.connect(self.run_identification) |
| self.butt_match.clicked.connect(self.run_matching_ms) |
| self.butt_spectrum.clicked.connect(self.plot_spectrum) |
| self.butt_loss.clicked.connect(self.plot_loss) |
| self.butt_plotComm.clicked.connect(self.plot_mol_with_highlight) |
| self.list_spectrum.itemClicked.connect(self.fill_formula_table) |
| self.tab_formula.itemClicked.connect(self.fill_structural_table) |
| self.tab_structure.itemClicked.connect(self.fill_reference_table) |
| self.tab_reference.itemClicked.connect(self.plot_spectrum) |
| |
| self.tab_formula.setSelectionBehavior(QtWidgets.QTableView.SelectRows) |
| self.tab_structure.setSelectionBehavior(QtWidgets.QTableView.SelectRows) |
| self.tab_reference.setSelectionBehavior(QtWidgets.QTableView.SelectRows) |
| |
| |
| self.Thread_LoadIndexPositive = None |
| self.Thread_LoadIndexNegative = None |
| self.Thread_LoadReference = None |
| self.Thread_Identification = None |
| self.Thread_Matching = None |
| |
| self.progressBar.setValue(0) |
| self.progressBar.setFormat('Loading database') |
| self.load_references_positive() |
| try: |
| self.deepmass_positive = Word2Vec.load("model/Ms2Vec_allGNPSpositive.hdf5") |
| self.deepmass_negative = Word2Vec.load("model/Ms2Vec_allGNPSnegative.hdf5") |
| except: |
| self.ErrorMsg("Missing model files") |
| return |
|
|
|
|
| def WarnMsg(self, Text): |
| msg = QtWidgets.QMessageBox() |
| msg.resize(550, 200) |
| msg.setIcon(QtWidgets.QMessageBox.Warning) |
| msg.setText(Text) |
| msg.setWindowTitle("Warning") |
| msg.exec_() |
| |
| |
| def ErrorMsg(self, Text): |
| msg = QtWidgets.QMessageBox() |
| msg.resize(550, 200) |
| msg.setIcon(QtWidgets.QMessageBox.Critical) |
| msg.setText(Text) |
| msg.setWindowTitle("Error") |
| msg.exec_() |
|
|
|
|
| def InforMsg(self, Text): |
| msg = QtWidgets.QMessageBox() |
| msg.resize(550, 200) |
| msg.setIcon(QtWidgets.QMessageBox.Information) |
| msg.setText(Text) |
| msg.setWindowTitle("Information") |
| msg.exec_() |
|
|
| |
| def _set_index_positive(self, msg): |
| self.pp = msg |
|
|
|
|
| def _set_index_negative(self, msg): |
| self.pn = msg |
|
|
| |
| def _set_database(self, msg): |
| self.database = msg |
| |
| |
| def _set_reference_positive(self, msg): |
| self.reference_positive = msg |
|
|
|
|
| def _set_reference_negative(self, msg): |
| self.reference_negative = msg |
| |
| |
| def _set_succeed_annotation(self, msg): |
| self.identified_spectrums.append(msg) |
| |
| |
| def _set_process_bar(self, msg): |
| self.progressBar.setValue(int(msg)) |
| |
|
|
| def _set_table_widget(self, widget, data): |
| widget.setRowCount(0) |
| widget.setRowCount(data.shape[0]) |
| widget.setColumnCount(data.shape[1]) |
| widget.setHorizontalHeaderLabels(data.columns) |
| widget.setVerticalHeaderLabels(data.index.astype(str)) |
| for i in range(data.shape[0]): |
| for j in range(data.shape[1]): |
| if type(data.iloc[i,j]) == np.float64: |
| item = QtWidgets.QTableWidgetItem() |
| item.setData(Qt.EditRole, QVariant(float(data.iloc[i,j]))) |
| else: |
| item = QtWidgets.QTableWidgetItem(str(data.iloc[i,j])) |
| widget.setItem(i, j, item) |
|
|
| |
| def _set_busy(self): |
| self.butt_open.setDisabled(True) |
| self.butt_run.setDisabled(True) |
| self.butt_match.setDisabled(True) |
| self.butt_save.setDisabled(True) |
| |
|
|
| def _set_finished(self): |
| self.progressBar.setValue(100) |
| self.progressBar.setFormat('Ready') |
| self.butt_open.setDisabled(False) |
| self.butt_run.setDisabled(False) |
| self.butt_match.setDisabled(False) |
| self.butt_save.setDisabled(False) |
| |
| |
| def get_formula_mass(self, formula): |
| f = Formula(formula) |
| return f.isotope.mass |
| |
| |
| def load_references_positive(self): |
| self.progressBar.setValue(22) |
| self.progressBar.setFormat('Loading positive references') |
| try: |
| self.Thread_LoadIndexPositive = Thread_LoadIndex(self.default_index_positive) |
| self.Thread_LoadIndexPositive._index.connect(self._set_index_positive) |
| self.Thread_LoadIndexPositive.start() |
| self.Thread_LoadIndexPositive.finished.connect(self.load_references_negative) |
| except: |
| self.ErrorMsg("Missing data files") |
| return |
|
|
|
|
| def load_references_negative(self): |
| self.progressBar.setValue(44) |
| self.progressBar.setFormat('Loading negative references') |
| try: |
| self.Thread_LoadIndexNegative = Thread_LoadIndex(self.default_index_negative) |
| self.Thread_LoadIndexNegative._index.connect(self._set_index_negative) |
| self.Thread_LoadIndexNegative.start() |
| self.Thread_LoadIndexNegative.finished.connect(self.load_reference_spectrums) |
| except: |
| self.ErrorMsg("Missing data files") |
| return |
| |
| |
| def load_reference_spectrums(self): |
| self.progressBar.setValue(77) |
| self.progressBar.setFormat('Loading reference spectrums') |
| if self.reference_positive is not None: |
| self._set_finished() |
| else: |
| self.Thread_LoadReference = Thread_LoadReference(self.default_reference_positive, self.default_reference_negative) |
| self.Thread_LoadReference._reference_positive.connect(self._set_reference_positive) |
| self.Thread_LoadReference._reference_negative.connect(self._set_reference_negative) |
| self.Thread_LoadReference._i.connect(self._set_process_bar) |
| self.Thread_LoadReference.start() |
| self.Thread_LoadReference.finished.connect(self._set_finished) |
|
|
| |
| def load_spectrums(self): |
| self._set_busy() |
| options = QtWidgets.QFileDialog.Options() |
| options |= QtWidgets.QFileDialog.DontUseNativeDialog |
| fileNames, _ = QtWidgets.QFileDialog.getOpenFileNames(self, "Load", "","MGF Files (*.mgf)", options=options) |
| if len(fileNames) == 0: |
| self._set_finished() |
| return |
| spectrums = [] |
| for fileName in fileNames: |
| spectrums += [s for s in load_from_mgf(fileName) if 'compound_name' in list(s.metadata.keys())] |
| titles = [s.metadata['compound_name'] for s in spectrums] |
| self.spectrums = pd.DataFrame({'title': titles, 'spectrum': spectrums}) |
| self.set_list_spectrums() |
| self._set_finished() |
|
|
|
|
| def set_list_spectrums(self): |
| data = self.spectrums |
| if len(data) == 0: |
| return |
| self.list_spectrum.clear() |
| for i in data.index: |
| self.list_spectrum.addItem(data.loc[i, 'title']) |
| self.list_spectrum.show() |
| self.list_spectrum.setCurrentRow(0) |
|
|
|
|
| def run_identification(self): |
| self._set_busy() |
| self.identified_spectrums = [] |
| if len(self.spectrums) == 0: |
| self.ErrorMsg('Please load unknown spectrums first') |
| self._set_finished() |
| return |
| self.progressBar.setValue(0) |
| self.progressBar.setFormat('Identifying unknowns') |
| spectrums = self.spectrums['spectrum'] |
| p_positive = self.pp |
| p_negative = self.pn |
| model_positive = self.deepmass_positive |
| model_negative = self.deepmass_negative |
| reference_positive = self.reference_positive |
| reference_negative = self.reference_negative |
|
|
| self.Thread_Identification = Thread_Identification(spectrums, p_positive, p_negative, |
| model_positive, model_negative, |
| reference_positive, reference_negative, |
| self.default_database) |
| self.Thread_Identification._result.connect(self._set_succeed_annotation) |
| self.Thread_Identification._i.connect(self._set_process_bar) |
| self.Thread_Identification.start() |
| self.Thread_Identification.finished.connect(self.fill_formula_table) |
| |
|
|
| def run_matching_ms(self): |
| self._set_busy() |
| self.identified_spectrums = [] |
| if len(self.spectrums) == 0: |
| self.ErrorMsg('Please load unknown spectrums first') |
| self._set_finished() |
| return |
| self.progressBar.setValue(0) |
| self.progressBar.setFormat('Identifying unknowns') |
| spectrums = self.spectrums['spectrum'] |
| reference_positive = self.reference_positive |
| reference_negative = self.reference_negative |
| precursors_positive = np.array([s.get('precursor_mz') for s in reference_positive]) |
| precursors_negative = np.array([s.get('precursor_mz') for s in reference_negative]) |
| self.Thread_Matching = Thread_Matching(spectrums, |
| precursors_positive, precursors_negative, |
| reference_positive, reference_negative) |
| self.Thread_Matching._result.connect(self._set_succeed_annotation) |
| self.Thread_Matching._i.connect(self._set_process_bar) |
| self.Thread_Matching.start() |
| self.Thread_Matching.finished.connect(self.fill_formula_table) |
|
|
|
|
| def fill_reference_table(self): |
| if 'reference' not in self.current_spectrum.metadata.keys(): |
| self.WarnMsg('No identification result for the selected spectrum') |
| return |
| self.current_reference = self.current_spectrum.metadata['reference'] |
| i = self.tab_structure.currentRow() |
| header = [self.tab_structure.horizontalHeaderItem(i).text() for i in range(self.tab_structure.columnCount())] |
| j = list(header).index('CanonicalSMILES') |
| smi_anno = self.tab_structure.item(i, j).text() |
|
|
| annotation = self.current_spectrum.metadata['annotation'] |
| i = np.where(annotation['CanonicalSMILES'].values == smi_anno)[0][0] |
|
|
| reference_table = [] |
| for s in self.current_reference: |
| if 'smiles' in s.metadata.keys(): |
| smiles = s.metadata['smiles'] |
| else: |
| smiles = '' |
| if 'compound_name' in s.metadata.keys(): |
| name = s.metadata['compound_name'] |
| else: |
| name = smiles |
| if 'adduct' in s.metadata.keys(): |
| adduct = s.metadata['adduct'] |
| else: |
| adduct = '' |
| if 'parent_mass' in s.metadata.keys(): |
| parent_mass = s.metadata['parent_mass'] |
| else: |
| parent_mass = '' |
| if 'database' in s.metadata.keys(): |
| ref_database = s.metadata['database'] |
| else: |
| ref_database = '' |
| reference_table.append([name, adduct, smiles, parent_mass, ref_database]) |
| reference_table = pd.DataFrame(reference_table, columns = ['name', 'adduct', 'smiles', 'parent_mass', 'database']) |
| self._set_table_widget(self.tab_reference, reference_table) |
| self.tab_reference.setCurrentCell(0, 0) |
| self.plot_spectrum() |
| self._set_finished() |
| |
| |
| def fill_formula_table(self): |
| data = self.spectrums |
| selectItem = self.list_spectrum.currentItem().text() |
| w = np.where(data.loc[:, 'title'] == selectItem)[0][0] |
| try: |
| self.current_spectrum = self.identified_spectrums[w] |
| except: |
| self.WarnMsg('No available structures') |
| return |
| |
| if 'annotation' not in self.current_spectrum.metadata.keys(): |
| self.WarnMsg('No available structures') |
| return |
| annotation = self.current_spectrum.metadata['annotation'] |
| if len(annotation) == 0: |
| self.WarnMsg('No available structures') |
| return |
| formula = np.unique(annotation['MolecularFormula']) |
| mass = [self.get_formula_mass(f) for f in formula] |
| |
| if 'parent_mass' in self.current_spectrum.metadata.keys(): |
| diff = np.array([abs(m - float(self.current_spectrum.metadata['parent_mass'])) for m in mass]) |
| else: |
| diff = np.repeat(np.nan, len(mass)) |
| |
| formula_table = pd.DataFrame({'formula': formula, 'mass': mass, 'error (mDa)': 1000*diff}) |
| formula_table = formula_table.sort_values(by = 'error (mDa)', ascending=True, ignore_index=True) |
| self._set_table_widget(self.tab_formula, formula_table) |
| self.tab_formula.setCurrentCell(0, 0) |
| self.fill_structural_table() |
| self.fill_information_table() |
| self._set_finished() |
| |
| |
| def fill_structural_table(self): |
| annotation = self.current_spectrum.metadata['annotation'] |
| i = self.tab_formula.currentRow() |
| header = [self.tab_formula.horizontalHeaderItem(i).text() for i in range(self.tab_formula.columnCount())] |
| j = list(header).index('formula') |
| formula = self.tab_formula.item(i, j).text() |
| |
| structural_table = annotation.loc[annotation['MolecularFormula'] == formula,:] |
| structural_table = structural_table.reset_index(drop = True) |
| if len(structural_table) == 0: |
| self.WarnMsg('No available structures') |
| self._set_finished() |
| return |
| self._set_table_widget(self.tab_structure, structural_table) |
| self.tab_structure.setCurrentCell(0, 0) |
| self.fill_reference_table() |
| self._set_finished() |
| |
| |
| def fill_information_table(self): |
| information = self.current_spectrum.metadata |
| keys = [k for k in information.keys() if k in ['compound_name', 'precursor_mz', 'precursor_intensity', 'retention_time', 'inchikey', |
| 'formula', 'smiles', 'adduct', 'charge', 'parent_mass', 'ionmode']] |
| values = [information[k] for k in keys] |
| info_table = pd.DataFrame({'keys':keys, 'values':values}) |
| self._set_table_widget(self.tab_information, info_table) |
| |
| |
| def plot_spectrum(self): |
| try: |
| i = self.tab_reference.currentRow() |
| self.figSpe.PlotSpectrum(self.current_spectrum, self.current_reference[i], loss = False) |
| except: |
| self.WarnMsg('Cannot plot Spectrum') |
| self.plot_mol() |
| |
|
|
| def plot_loss(self): |
| try: |
| i = self.tab_reference.currentRow() |
| reference = self.current_spectrum.metadata['reference'][i] |
| self.figSpe.PlotSpectrum(self.current_spectrum, reference, loss = True) |
| except: |
| self.WarnMsg('Cannot plot Losses') |
| |
| |
| def plot_mol(self, highlight = False): |
| i = self.tab_structure.currentRow() |
| header = [self.tab_structure.horizontalHeaderItem(i).text() for i in range(self.tab_structure.columnCount())] |
| j = list(header).index('CanonicalSMILES') |
| mol_anno = self.tab_structure.item(i, j).text() |
| mol_anno = Chem.MolFromSmiles(mol_anno) |
| |
| i = self.tab_reference.currentRow() |
| header = [self.tab_reference.horizontalHeaderItem(i).text() for i in range(self.tab_reference.columnCount())] |
| j = list(header).index('smiles') |
| mol_ref = self.tab_reference.item(i, j).text() |
| mol_ref = Chem.MolFromSmiles(mol_ref) |
| |
| if highlight: |
| mcs = rdFMCS.FindMCS([mol_anno, mol_ref], bondCompare=rdFMCS.BondCompare.CompareOrderExact, |
| matchValences = True, ringMatchesRingOnly = True) |
| mcs_str = mcs.smartsString |
| mcs_mol = Chem.MolFromSmarts(mcs_str) |
| allsubs_anno = tuple(chain.from_iterable(mol_anno.GetSubstructMatches(mcs_mol))) |
| allsubs_ref = tuple(chain.from_iterable(mol_ref.GetSubstructMatches(mcs_mol))) |
| else: |
| allsubs_anno = () |
| allsubs_ref = () |
| |
| if mol_anno is not None: |
| file_name = ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(10)) |
| Draw.MolToFile(mol_anno, 'temp/{}.png'.format(file_name), wedgeBonds=False, highlightAtoms=allsubs_anno) |
| self.LabelAnno.setPixmap(QPixmap('temp/{}.png'.format(file_name))) |
| |
| if mol_ref is not None: |
| file_name = ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(10)) |
| Draw.MolToFile(mol_ref, 'temp/{}.png'.format(file_name), wedgeBonds=False, highlightAtoms=allsubs_ref) |
| self.LabelRef.setPixmap(QPixmap('temp/{}.png'.format(file_name))) |
| |
| |
| def plot_mol_with_highlight(self): |
| self.plot_mol(highlight = True) |
| self.InforMsg('Finished') |
| |
| |
| def save_identification(self): |
| options = QtWidgets.QFileDialog.Options() |
| options |= QtWidgets.QFileDialog.DontUseNativeDialog |
| savePath = QtWidgets.QFileDialog.getExistingDirectory(self, "Save", options=options) |
| if savePath: |
| if savePath == '': |
| self.WarnMsg('Invalid path') |
| return |
| for s in self.identified_spectrums: |
| name = s.metadata['compound_name'] |
| name = re.sub(r'[^ \w+]', '', name) |
| if 'annotation' in s.metadata.keys(): |
| annotation = s.metadata['annotation'] |
| else: |
| annotation = pd.DataFrame(columns=['Title', 'MolecularFormula', 'CanonicalSMILES', 'InChIKey']) |
| path = "{}/{}.csv".format(savePath, name) |
| annotation.to_csv(path) |
| self.InforMsg('Finished') |
|
|
|
|
| class Thread_LoadReference(QThread): |
| _i = QtCore.pyqtSignal(int) |
| _reference_positive = QtCore.pyqtSignal(list) |
| _reference_negative = QtCore.pyqtSignal(list) |
| |
| def __init__(self, positive, negative): |
| super().__init__() |
| self.positive = positive |
| self.negative = negative |
|
|
| def run(self): |
| with open(self.negative, 'rb') as file: |
| reference_negative = pickle.load(file) |
| self._reference_negative.emit(list(reference_negative)) |
| self._i.emit(88) |
| |
| with open(self.positive, 'rb') as file: |
| reference_positive = pickle.load(file) |
| self._reference_positive.emit(list(reference_positive)) |
| self._i.emit(99) |
|
|
|
|
| class Thread_LoadIndex(QThread): |
| _index = QtCore.pyqtSignal(hnswlib.Index) |
| |
| def __init__(self, spec_path): |
| super().__init__() |
| self.spec_path = spec_path |
| |
| def run(self): |
| if 'spec2vec' in self.spec_path: |
| dim = 300 |
| else: |
| dim = 200 |
| spec_bin = Index(space = 'l2', dim = dim) |
| spec_bin.load_index(self.spec_path) |
| self._index.emit(spec_bin) |
|
|
|
|
| class Thread_Identification(QThread): |
| _i = QtCore.pyqtSignal(int) |
| _result = QtCore.pyqtSignal(Spectrum) |
|
|
| def __init__(self, spectrums, p_positive, p_negative, model_positive, model_negative, reference_positive, reference_negative, database): |
| super(Thread_Identification, self).__init__() |
| self.p_positive = p_positive |
| self.p_negative = p_negative |
| self.spectrums = spectrums |
| self.model_positive = model_positive |
| self.model_negative = model_negative |
| self.reference_positive = reference_positive |
| self.reference_negative = reference_negative |
| self.database = database |
|
|
| def __del__(self): |
| self.wait() |
| self.working = False |
|
|
| def run(self): |
| for i, s in enumerate(self.spectrums): |
| if 'ionmode' in s.metadata.keys(): |
| if s.metadata['ionmode'] == 'negative': |
| sn = identify_unknown(s, self.p_negative, self.model_negative, self.reference_negative, self.database) |
| else: |
| sn = identify_unknown(s, self.p_positive, self.model_positive, self.reference_positive, self.database) |
| else: |
| sn = identify_unknown(s, self.p_positive, self.model_positive, self.reference_positive, self.database) |
| self._i.emit(int(100 * i / len(self.spectrums))) |
| self._result.emit(sn) |
|
|
|
|
| class Thread_Matching(QThread): |
| _i = QtCore.pyqtSignal(int) |
| _result = QtCore.pyqtSignal(Spectrum) |
|
|
| def __init__(self, spectrums, precursors_positive, precursors_negative, reference_positive, reference_negative): |
| super(Thread_Matching, self).__init__() |
| self.spectrums = spectrums |
| self.precursors_positive = precursors_positive |
| self.precursors_negative = precursors_negative |
| self.reference_positive = reference_positive |
| self.reference_negative = reference_negative |
|
|
| def __del__(self): |
| self.wait() |
| self.working = False |
|
|
| def run(self): |
| for i, s in enumerate(self.spectrums): |
| if 'ionmode' in s.metadata.keys(): |
| if s.metadata['ionmode'] == 'negative': |
| sn = match_spectrum(s, self.precursors_negative, self.reference_negative) |
| else: |
| sn = match_spectrum(s, self.precursors_positive, self.reference_positive) |
| else: |
| sn = match_spectrum(s, self.precursors_positive, self.reference_positive) |
| self._i.emit(int(100 * i / len(self.spectrums))) |
| self._result.emit(sn) |
|
|
|
|
| class MakeFigure(FigureCanvas): |
| def __init__(self,width=5, height=5, dpi=300): |
| self.fig = Figure(figsize=(width, height), dpi=dpi) |
| self.fig.subplots_adjust(top=0.95,bottom=0.3,left=0.18,right=0.95) |
| super(MakeFigure,self).__init__(self.fig) |
| self.axes = self.fig.add_subplot(111) |
| self.axes.spines['bottom'].set_linewidth(0.5) |
| self.axes.spines['left'].set_linewidth(0.5) |
| self.axes.spines['right'].set_linewidth(0.5) |
| self.axes.spines['top'].set_linewidth(0.5) |
| self.axes.tick_params(width=0.8,labelsize=3) |
| FigureCanvas.setSizePolicy(self, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding) |
| FigureCanvas.updateGeometry(self) |
| |
| |
| def PlotSpectrum(self, spectrum, reference, loss = False): |
| self.axes.cla() |
| mz, abunds = spectrum.peaks.mz, spectrum.peaks.intensities |
| mz1, abunds1 = reference.peaks.mz, reference.peaks.intensities |
| if loss: |
| try: |
| spectrum = msfilters.add_parent_mass(spectrum) |
| spectrum = msfilters.add_losses(spectrum, loss_mz_from=10.0, loss_mz_to=2000.0) |
| reference = msfilters.add_parent_mass(reference) |
| reference = msfilters.add_losses(reference, loss_mz_from=10.0, loss_mz_to=2000.0) |
| mz, abunds = spectrum.losses.mz, spectrum.losses.intensities |
| mz1, abunds1 = reference.losses.mz, reference.losses.intensities |
| except: |
| print('Cannot Plot Losses') |
| return |
| abunds /= np.max(abunds) |
| abunds1 /= np.max(abunds1) |
| self.axes.vlines(mz, ymin=0, ymax=abunds, color='r', lw = 0.5) |
| self.axes.vlines(mz1, ymin = 0, ymax = -abunds1, color='b', lw = 0.5) |
| self.axes.axhline(y=0,color='black', lw = 0.5) |
| self.axes.set_xlabel('m/z', fontsize = 3.5) |
| self.axes.set_ylabel('abundance', fontsize = 3.5) |
| self.draw() |
| |
|
|
| if __name__ == '__main__': |
| import sys |
| |
| app = QApplication(sys.argv) |
| ui = DeepMASS2() |
| ui.show() |
| sys.exit(app.exec_()) |
