| |
| """ |
| Created on Wed Sep 7 14:55:39 2022 |
| |
| @author: DELL |
| """ |
|
|
|
|
| import numpy as np |
| import pandas as pd |
| from tqdm import tqdm |
|
|
| from matchms.Spectrum import Spectrum |
| from matchms.similarity import CosineGreedy |
|
|
| from rdkit import Chem, DataStructs |
| from rdkit.Chem import AllChem |
| from rdkit.Chem import rdFMCS |
|
|
|
|
| def disable_rdkit_logging(): |
| """ |
| Disables RDKit whiny logging. |
| """ |
| import rdkit.rdBase as rkrb |
| import rdkit.RDLogger as rkl |
| logger = rkl.logger() |
| logger.setLevel(rkl.ERROR) |
| rkrb.DisableLog('rdApp.error') |
|
|
| disable_rdkit_logging() |
| get_fp = lambda x: AllChem.GetMorganFingerprintAsBitVect(x, radius=2) |
| get_sim = lambda x, y: DataStructs.DiceSimilarity(x, y) |
|
|
|
|
| def get_tagged_atoms_from_mol(mol): |
| '''Takes an RDKit molecule and returns list of tagged atoms and their |
| corresponding numbers''' |
| atoms = [] |
| atom_tags = [] |
| for atom in mol.GetAtoms(): |
| if atom.HasProp('molAtomMapNumber'): |
| atoms.append(atom) |
| atom_tags.append(int(atom.GetProp('molAtomMapNumber'))) |
| return atom_tags |
|
|
|
|
| def calc_frag_mass(frag): |
| '''Takes an RDKit fragment and returns the exact mass of the fragment''' |
| mass = 0 |
| for ad in frag.GetAtoms(): |
| mass += ad.GetMass() |
| return mass |
| |
|
|
| def calc_possible_spectrum_loss(smiles_1, smiles_2): |
| """ |
| Calculate mass difference between related fragments of two compounds. |
| Arguments: |
| smiles_1, smiles_2: str, two different smiles of compounds. |
| Returns: |
| DataFrame, |
| transform, transformation from smiles_1 to smiles_2. |
| loss, corresponding neutral loss of the transformations. |
| Example: |
| smiles_1 = 'COc1cc(O)c2c(c1)OC(c1ccc(O)cc1)CC2=O' |
| smiles_2 = 'CC1OC(OCC2OC(Oc3cc(O)c4c(c3)OC(c3ccc(O)cc3)CC4=O)C(O)C(O)C2O)C(O)C(O)C1O' |
| calc_possible_spectrum_loss(smiles_1, smiles_2) |
| """ |
| |
| try: |
| x = Chem.MolToSmiles(Chem.MolFromSmiles(smiles_1)) |
| y = Chem.MolToSmiles(Chem.MolFromSmiles(smiles_2)) |
| except: |
| return None |
| |
| mol1 = Chem.AddHs(Chem.MolFromSmiles(x)) |
| mol2 = Chem.AddHs(Chem.MolFromSmiles(y)) |
| |
| if get_sim(get_fp(mol1), get_fp(mol2)) < 0.3: |
| return None |
| |
| mcs = rdFMCS.FindMCS([mol1, mol2], bondCompare=rdFMCS.BondCompare.CompareOrderExact, |
| matchValences = True, ringMatchesRingOnly = True) |
| if mcs.numAtoms <= 5: |
| return None |
| |
| mcs_str = mcs.smartsString |
| |
| rdu1 = AllChem.DeleteSubstructs(mol1, Chem.MolFromSmarts(mcs_str)) |
| rdu2 = AllChem.DeleteSubstructs(mol2, Chem.MolFromSmarts(mcs_str)) |
| |
| try: |
| rdu1 = Chem.GetMolFrags(rdu1, asMols=True) |
| except: |
| rdu1 = np.array([rdu1]) |
| |
| try: |
| rdu2 = Chem.GetMolFrags(rdu2, asMols=True) |
| except: |
| rdu2 = np.array([rdu2]) |
| |
| if (len(rdu1) == 0) and (len(rdu2) == 0): |
| return None |
|
|
| mass_1 = np.array([calc_frag_mass(m) for m in rdu1]) |
| mass_2 = np.array([calc_frag_mass(m) for m in rdu2]) |
| if len(mass_1) == 0: |
| mass_1 = np.array([0]) |
| if len(mass_2) == 0: |
| mass_2 = np.array([0]) |
| |
| mass_diffs, mol_transform = [], [] |
| for i in range(len(mass_1)): |
| for j in range(len(mass_2)): |
| try: |
| a = Chem.MolToSmiles(Chem.RemoveHs(rdu1[i])) |
| except: |
| a = 'None' |
| try: |
| b = Chem.MolToSmiles(Chem.RemoveHs(rdu2[j])) |
| except: |
| b = 'None' |
| mol_transform.append('{}>>{}'.format(a,b)) |
| mass_diffs.append(mass_2[j] - mass_1[i]) |
| |
| return pd.DataFrame({'transform': mol_transform, 'loss': mass_diffs}) |
| |
| |
| def calc_aligned_similarity(smiles_1, smiles_2, spectrum_1, spectrum_2, mz_tol=0.05, similarity_function=CosineGreedy()): |
| """ |
| Calculate dtw similarity between two spectrums. |
| Arguments: |
| smiles_1, smiles_2: str, two different smiles of compounds. |
| spectrum_1, spectrum_2: Two different spectrum of matchms. |
| Returns: |
| similarity: float, similarity between aligned spectrums. |
| matching_data: DataFrame, fragment matching information. |
| Example: |
| smiles_1 = 'CCCC=C1C2=CC=CC=C2C(=O)O1' |
| smiles_2 = 'CCCC=C1C2=C(C=CCC2)C(=O)O1' |
| spectrum_1 = Spectrum(mz = np.array([91.1, 115.1, 117.1, 128.1, 129.1, 143.1, 145.1, 152.1, 153.1, 171.1, 189.1]), |
| intensities = np.array([0.12314933, 0.10446688, 0.16478671, 0.56083889, 0.11087135, |
| 0.43528005, 0.1149675 , 0.10339803, 0.51058281, 0.999999, 0.88490263]), |
| metadata={"precursor_mz": 189.0909}) |
| spectrum_2 = Spectrum(mz = np.array([ 79.1, 93.1, 105.1, 117.1, 145.1, 173.1, 191.1]), |
| intensities = np.array([0.10704697, 0.10657389, 0.1382483 , 0.12679477, 0.16397634, |
| 0.26150501, 0.999999]), |
| metadata={"precursor_mz": 191.1064}) |
| calc_aligned_similarity(smiles_1, smiles_2, spectrum_1, spectrum_2) |
| """ |
| |
| loss = calc_possible_spectrum_loss(smiles_1, smiles_2) |
| |
| if loss is None: |
| loss_1 = loss_2 = 0 |
| loss = pd.DataFrame({'transform': [], 'loss': []}) |
| else: |
| loss_1 = -sum([l for l in list(loss['loss']) if l < 0]) |
| loss_2 = sum([l for l in list(loss['loss']) if l > 0]) |
| |
| mcs1 = 9999 |
| mcs2 = 9999 |
| try: |
| mcs1 = spectrum_1.metadata['precursor_mz'] - loss_1 |
| except: |
| pass |
| try: |
| mcs2 = spectrum_2.metadata['precursor_mz'] - loss_2 |
| except: |
| pass |
| maxCS = min(mcs1, mcs2) |
| |
| if (len(spectrum_1.mz) == 0) or (len(spectrum_2.mz) == 0): |
| return 0, None |
| |
| x_mz, x_intensities = spectrum_1.mz, spectrum_1.intensities |
| y_mz, y_intensities = spectrum_2.mz, spectrum_2.intensities |
| |
| y_mz_new, y_intensities_new = [], [] |
| matching_data = [] |
| for i, y_mz_ in enumerate(y_mz): |
| if y_intensities[i] < 0.01: |
| continue |
| if np.min(np.abs(y_mz_ - x_mz)) <= mz_tol: |
| if y_mz_ > maxCS + 2.006: |
| continue |
| a = y_mz_ |
| b = x_mz[np.argmin(np.abs(y_mz_ - x_mz))] |
| c = abs(a - b) |
| d = y_intensities[i] |
| y_mz_new.append(y_mz_) |
| y_intensities_new.append(y_intensities[i]) |
| matching_data.append([a, b, c, d]) |
| else: |
| matched = False |
| for loss_ in loss['loss']: |
| ''' |
| if y_mz_ - loss_ > maxCS - loss_ + 2.006: |
| continue |
| ''' |
| if np.min(np.abs(y_mz_ - loss_ - x_mz)) <= mz_tol: |
| matched = True |
| a = y_mz_ |
| b = x_mz[np.argmin(np.abs(y_mz_ - loss_ - x_mz))] |
| c = abs(a - b) |
| d = y_intensities[i] |
| y_mz_new.append(y_mz_ - loss_) |
| y_intensities_new.append(y_intensities[i]) |
| matching_data.append([a, b, c, d]) |
| break |
| if not matched: |
| y_mz_new.append(y_mz_) |
| y_intensities_new.append(y_intensities[i]) |
| y_mz_new = np.array(y_mz_new) |
| y_intensities_new = np.array(y_intensities_new) |
| |
| index = np.argsort(y_mz_new) |
| y_mz_new = y_mz_new[index] |
| y_intensities_new = y_intensities_new[index] |
| |
| spectrum_2_aligned = Spectrum(mz = y_mz_new, |
| intensities = y_intensities_new, |
| metadata = spectrum_2.metadata) |
| |
| similarity = float(similarity_function.pair(spectrum_1, spectrum_2_aligned)['score']) |
| matching_data = pd.DataFrame(matching_data, columns = ['reference', 'query', 'loss', 'intensity']) |
| return similarity, matching_data |
|
|
