CoreMS 4.0.0__py3-none-any.whl

corems/molecular_formula/input/masslist_ref.py

@@ -0,0 +1,355 @@
+__author__ = "Yuri E. Corilo"
+__date__ = "Oct 24, 2019"
+
+import json
+import re
+import sys
+from pathlib import Path
+from typing import Dict, List
+
+import pandas as pd
+
+from corems.encapsulation.constant import Atoms, Labels
+from corems.molecular_formula.factory.MolecularFormulaFactory import (
+    LCMSLibRefMolecularFormula,
+    MolecularFormula,
+)
+
+
+class MolecularFormulaLinkProxy:
+    """Proxy class for MolecularFormulaLink to be used in the molecular formula ref file import
+
+    Parameters
+    ----------
+    molecular_formula : MolecularFormula | LCMSLibRefMolecularFormula
+        corems MolecularFormula or LCMSLibRefMolecularFormula object
+    mz : float
+        target m/z
+
+    Attributes
+    ----------
+    C : int
+        number of carbon atoms
+    H : int
+        number of hydrogen atoms
+    H_C : float
+        ratio of hydrogen to carbon atoms
+    class_label : str
+        molecular formula class label
+    mz_calc : float
+        calculated m/z
+    dbe : int
+        double bond equivalent
+    formula_dict : dict
+        molecular formula dictionary
+
+    Methods
+    -------
+    * to_dict().
+        return molecular formula dictionary
+
+    """
+
+    def __init__(self, molecular_formula, mz):
+        self.C = molecular_formula.get("C")
+        self.H = molecular_formula.get("H")
+        self.H_C = molecular_formula.get("H") / molecular_formula.get("C")
+        self.class_label = json.dumps(molecular_formula.class_dict)
+        self.mz_calc = float(mz)
+        self.dbe = molecular_formula.dbe
+        self.formula_dict = molecular_formula.to_dict()
+
+    def to_dict(self):
+        return self.formula_dict
+
+
+class ImportMassListRef:  # Thread
+    """Import Mass List from Reference File
+
+    Parameters
+    ----------
+    ref_file_location : str
+        path to the reference file
+
+    Attributes
+    ----------
+    ref_file_location : str
+        path to the reference file
+
+    Methods
+    -------
+    * molecular_formula_ref(mz, molecular_formula).
+        Return MolecularFormulaLinkProxy object
+    * from_lcms_lib_file(ion_charge, ion_types).
+        Return Dict[standard_name, Dict[m/z, List[MolecularFormula]]] from LCMS library reference file
+    * from_bruker_ref_file().
+        Return List[MolecularFormula] from Bruker reference file
+    * from_corems_ref_file(delimiter).
+        Return List[MolecularFormula] from CoreMS reference file
+    * split(delimiters, string, maxsplit).
+        Splits a string using a list of delimiters.
+    * mformula_s_to_dict(s_mformulatring, iontype).
+        Converts a molecular formula string to a dict
+    """
+
+    def __init__(self, ref_file_location):
+        # Thread.__init__(self)
+
+        self.ref_file_location = Path(ref_file_location)
+
+        if not self.ref_file_location.exists():
+            tb = sys.exc_info()[2]
+            raise FileNotFoundError(ref_file_location).with_traceback(tb)
+
+    def molecular_formula_ref(self, mz, molecular_formula):
+        """Instantiate a MolecularFormulaLinkProxy object
+
+        Parameters
+        ----------
+        mz : float
+            target m/z
+        molecular_formula : MolecularFormula | LCMSLibRefMolecularFormula
+            corems MolecularFormula or LCMSLibRefMolecularFormula object
+
+        Returns
+        -------
+        MolecularFormulaLinkProxy
+            MolecularFormulaLinkProxy object
+        """
+        return MolecularFormulaLinkProxy(molecular_formula, mz)
+
+    def from_lcms_lib_file(
+        self, ion_charge: float, ion_types: List[str]
+    ) -> Dict[str, Dict[float, List[LCMSLibRefMolecularFormula]]]:
+        """Create a dictionary of LCMSLibRefMolecularFormula objects from LCMS library reference file
+
+        Parameters
+        ----------
+        ion_charge : float
+            ion charge
+        ion_types : List[str]
+            list of ion types
+
+        Returns
+        -------
+        Dict
+            Dict[standard_name, Dict[m/z, List[MolecularFormula]]] from LCMS library reference file. m/z is the target m/z; standard_name is the name of the molecular standard mix; MolecularFormula is the corems molecular formula class
+        """
+
+        data = {}
+
+        with open(self.ref_file_location) as ref_f:
+            df = pd.read_csv(ref_f, header=0, encoding="unicode_escape")
+
+            for index, row in df.iterrows():
+                formula_s = row["Neutral Formula"]
+                formula_dict = self.mformula_s_to_dict(formula_s, Labels.neutral)
+                name = row["Compound Name"]
+                kegg_id = row["KEGG ID"]
+                standard_name = row["NEW MIX"]
+                cas = row["KEGG ID"]
+                # print(row["Neutral Formula"], formula_dict)
+                molf_formula = LCMSLibRefMolecularFormula(
+                    formula_dict,
+                    ion_charge,
+                    Labels.neutral,
+                    name=name,
+                    kegg_id=kegg_id,
+                    cas=cas,
+                )
+                # if round(molf_formula.mz_calc, 4) != round(row['Mass Adduct -H'],4):
+                #    print(formula_s)
+                #    print(round(molf_formula.mz_calc, 4) , round(row['Mass Adduct -H'],4))
+
+                if standard_name in data.keys():
+                    # TODO change it to target ion types and add ion type in the data structure
+                    mz_calc = molf_formula.protonated_mz
+
+                    if mz_calc in data.get(standard_name).keys():
+                        data.get(standard_name).get(mz_calc).append(molf_formula)
+
+                    else:
+                        data[standard_name][mz_calc] = [molf_formula]
+                else:
+                    data[standard_name] = {molf_formula.mz_calc: [molf_formula]}
+                # print(formula_s, formula_dict)
+                # if molf_formula.ion_type != 'de-protonated':
+                #    print( 'ha', molf_formula.ion_type )
+                # print(formula_dict)
+                # print(row['c1'], row['c2'])
+
+        return data
+
+    def from_bruker_ref_file(self) -> List[MolecularFormula]:
+        """Create a list of MolecularFormula objects from Bruker reference file
+
+        Returns
+        -------
+        List[MolecularFormula]
+            List of MolecularFormula objects from Bruker reference file
+        """
+
+        import csv
+
+        list_mf_obj = []
+
+        with open(self.ref_file_location) as ref_f:
+            labels = ref_f.readline().strip("\n").split(";")
+
+            for line in ref_f.readlines():
+                if line != "\n":
+                    list_ref = line.strip("\n").split(" ")
+
+                    if list_ref[2][-1] == "+":
+                        ion_charge = int(list_ref[2][:-1])
+
+                    else:
+                        ion_charge = -1 * int(list_ref[2][:-1])
+
+                    ion_mol_formula = list_ref[0]
+                    mz = float(list_ref[1])
+                    formula_dict = self.mformula_s_to_dict(ion_mol_formula)
+
+                    list_mf_obj.append(
+                        MolecularFormula(formula_dict, ion_charge, external_mz=mz)
+                    )
+
+        return list_mf_obj
+
+    def from_corems_ref_file(self, delimiter="\t"):  # pragma: no cover
+        """Create a list of MolecularFormula objects from CoreMS reference file
+
+        Not being used
+
+        Parameters
+        ----------
+        delimiter : str
+            delimiter used in the reference file
+
+        Returns
+        -------
+        List[MolecularFormula]
+            List of MolecularFormula objects from CoreMS reference file
+        """
+        # not being used
+        import csv
+
+        list_mf_obj = []
+
+        with open("res/RefMassLists/Crude-Pos-ESI.ref") as ref_f:
+            labels = ref_f.readline().strip("\n").split(delimiter)
+
+            for line in ref_f.readlines():
+                if line != "\n":
+                    list_ref = line.strip("\n").split(delimiter)
+
+                    formula_string = list_ref[0]
+                    ion_charge = int(list_ref[1])
+                    ion_type = list_ref[2]
+
+                    molform = MolecularFormula(
+                        formula_string, ion_charge, ion_type=ion_type
+                    )
+
+                    list_mf_obj.append(self.molecular_formula_ref(molform))
+
+        return list_mf_obj
+
+    def split(self, delimiters, string, maxsplit=0):  # pragma: no cover
+        """Splits a string using a list of delimiters.
+
+        Does not work when formula has atoms with same characters, i.e - C10H21NNa
+
+        Parameters
+        ----------
+        delimiters : list
+            list of delimiters
+        string : str
+            string to be split
+        maxsplit : int, optional
+            maximum number of splits. Default is 0
+
+        Returns
+        -------
+        list
+            list of strings obtained after splitting the string
+        list
+            list of counts obtained after splitting the string
+        """
+        regexPattern = "|".join(map(re.escape, delimiters))  # pragma: no cover
+        isotopes = re.findall(regexPattern, string)  # pragma: no cover
+        counts = re.split(regexPattern, string, maxsplit)  # pragma: no cover
+        return isotopes, counts
+
+    def mformula_s_to_dict(self, s_mformulatring, iontype="unknown"):
+        """Converts a molecular formula string to a dict
+
+        Parameters
+        ----------
+        s_mformulatring : str
+            molecular formula string, i.e. 'C10H21NNa'
+        iontype : str, optional
+            ion type. Default is 'unknown'
+
+        Returns
+        -------
+        dict
+            molecular formula dictionary
+
+        Notes
+        -----
+        Does not work if the atomic mass number is passed i.e. 37Cl, 81Br, convention follow the light isotope labeling 35Cl is Cl, 12C is C, etc.
+        If you need to use heavy isotopes please use another reference file format that separate the formula string by a blank space and parse it using the function corems_ref_file
+
+        Raises
+        ------
+        TypeError
+            Atom does not exist in Atoms.atoms_order list
+        Exception
+            Empty molecular formula
+        """
+        if s_mformulatring:
+            # find the case C122
+            all_atoms = re.findall(r"[A-Z]{1}[0-9]{1,10000}", s_mformulatring)
+
+            # find the case Br2
+            all_atoms2 = re.findall(r"[A-Z]{1}[a-z]{1}[0-9]{1,10000}", s_mformulatring)
+            # find the case N
+            single_digit_atoms_one = re.findall(
+                r"[A-Z]{1}(?![0-9])(?![a-z])", s_mformulatring
+            )
+            # print(single_digit_atoms_one)
+            # find the case Na
+            due_digit_atoms_one = re.findall(
+                r"[A-Z]{1}[a-z]{1}(?![0-9])", s_mformulatring
+            )
+
+            all_atoms = (
+                all_atoms + all_atoms2 + due_digit_atoms_one + single_digit_atoms_one
+            )
+
+            dict_res = {}
+
+            for each_atom_count in all_atoms:
+                count = re.findall(r"[0-9]{1,10000}", each_atom_count)
+                atom = "".join(re.findall(r"[A-z]", each_atom_count))
+
+                if atom in Atoms.atoms_order:
+                    if count:
+                        dict_res[atom] = int(count[0])
+                    else:
+                        dict_res[atom] = 1
+
+                else:
+                    tb = sys.exc_info()[2]
+                    raise TypeError(
+                        "Atom %s does not exist in Atoms.atoms_order list" % atom
+                    ).with_traceback(tb)
+
+            dict_res[Labels.ion_type] = iontype
+
+            return dict_res
+
+        else:
+            tb = sys.exc_info()[2]
+            raise Exception("Empty molecular formula").with_traceback(tb)

corems/molecular_id/calc/ClusterFilter.py

@@ -0,0 +1,251 @@
+import pandas as pd
+from sklearn.cluster import DBSCAN
+from sklearn.preprocessing import StandardScaler
+
+# import matplotlib.pyplot as plt
+
+
+class ClusteringFilter:
+    """Class for filtering and clustering mass spectra data using various algorithms.
+
+    Attributes
+    -------
+    mass_spectrum : MassSpectrum
+        Mass spectrum object.
+    ms_peaks : list
+        List of mass peaks.
+    ms_peak_indexes : list
+        List of peak indexes.
+    min_samples : int
+        Minimum number of samples in a cluster.
+    eps : float
+        The maximum distance between two samples for one to be considered as in the neighborhood of the other.
+    bandwidth : float
+        Bandwidth used in MeanShift algorithm.
+    quantile : float
+        Quantile used in estimate_bandwidth function.
+    n_samples : int
+        Number of samples used in estimate_bandwidth function.
+    bin_seeding : bool
+        If true, initial kernel locations are not locations of all points, but rather the location of the discretized version of points, where points are binned onto a grid whose coarseness corresponds to the bandwidth. Setting this option to True will speed up the algorithm because fewer seeds will be initialized.
+    min_peaks_per_class : int
+        Minimum number of peaks per class.
+
+    Methods
+    -------
+    * get_mass_error_matrix_data(ms_peaks).
+        Get the mass error matrix data from a list of mass peaks.
+    * get_kendrick_matrix_data(mass_spectrum).
+        Get the Kendrick matrix data from a mass spectrum.
+    * filter_kendrick(mass_spectrum).
+        Filter the mass spectrum data using the Kendrick algorithm.
+    * filter_kendrick_by_index(ms_peak_indexes, mass_spectrum_obj).
+        Filter the mass spectrum data using the Kendrick algorithm based on a list of peak indexes.
+    * remove_assignment_by_mass_error(mass_spectrum).
+        Remove assignments from the mass spectrum based on mass error.
+
+
+    """
+
+    def get_mass_error_matrix_data(self, ms_peaks):
+        """Get the mass error matrix data from a list of mass peaks.
+
+        Parameters
+        ----------
+        ms_peaks : list
+            List of mass peaks.
+
+        Returns
+        -------
+        matrix_data : ndarray
+            Matrix data containing mass and error values.
+        list_indexes_mass_spec : list
+            List of indexes of mass peaks in the original mass spectrum.
+        """
+        mass_list = list()
+        error_list = list()
+        list_indexes_mass_spec = []
+
+        for index, mspeak in enumerate(ms_peaks):
+            if mspeak.is_assigned:
+                # print(mspeak.mz_exp, len(mspeak))
+                for mformula in mspeak:
+                    mass_list.append(mspeak.mz_exp)
+                    error_list.append(mformula.mz_error)
+                    list_indexes_mass_spec.append(index)
+
+        kendrick_dict = {"mass": mass_list, "error": error_list}
+        df = pd.DataFrame(kendrick_dict)
+        matrix_data = df.values.astype("float32", copy=False)
+        return matrix_data, list_indexes_mass_spec
+
+    def get_kendrick_matrix_data(self, mass_spectrum):
+        """Get the Kendrick matrix data from a mass spectrum.
+
+        Parameters
+        ----------
+        mass_spectrum : MassSpectrum
+            Mass spectrum object.
+
+        Returns
+        -------
+        matrix_data : ndarray
+            Matrix data containing Kendrick mass and Kendrick mass defect values.
+        """
+        km = mass_spectrum.kendrick_mass
+        kmd = mass_spectrum.kmd
+        kendrick_dict = {"km": km, "kmd": kmd}
+        df = pd.DataFrame(kendrick_dict)
+        matrix_data = df.values.astype("float32", copy=False)
+        return matrix_data
+
+    def filter_kendrick(self, mass_spectrum):
+        """Filter the mass spectrum data using the Kendrick algorithm.
+
+        Parameters
+        ----------
+        mass_spectrum : MassSpectrum
+            Mass spectrum object.
+
+        """
+        matrix_data = self.get_kendrick_matrix_data(mass_spectrum)
+
+        stdscaler = StandardScaler().fit(matrix_data)
+
+        matrix_data_scaled = stdscaler.transform(matrix_data)
+
+        clusters = DBSCAN(eps=0.75, min_samples=50).fit_predict(matrix_data_scaled)
+
+        # Number of clusters in labels, ignoring noise if present.
+        n_clusters_ = len(set(clusters)) - (1 if -1 in clusters else 0)
+        n_noise_ = list(clusters).count(-1)
+
+        indexes = []
+        for i in range(len(clusters)):
+            if clusters[i] == -1:
+                indexes.append(i)
+
+        if mass_spectrum.parameters.mass_spectrum.verbose_processing:
+            print("Estimated number of clusters: %d" % n_clusters_)
+            print("Estimated number of noise points: %d" % n_noise_)
+        mass_spectrum.filter_by_index(indexes)
+        # from matplotlib import pyplot as plt
+        # plt.scatter(matrix_data[:, 0], matrix_data[:, 1], c=clusters, cmap="jet")
+        # plt.xlabel("km")
+        # plt.ylabel("kmd")
+        # plt.show()
+        # plt.close()
+
+    def filter_kendrick_by_index(self, ms_peak_indexes, mass_spectrum_obj):
+        """Filter the mass spectrum data using the Kendrick algorithm based on a list of peak indexes.
+
+        Parameters
+        ----------
+        ms_peak_indexes : list
+            List of peak indexes.
+        mass_spectrum_obj : MassSpectrum
+            Mass spectrum object.
+
+        Returns
+        -------
+        noise_idx : list
+            List of indexes of noise points in the mass spectrum.
+        """
+        min_samples = mass_spectrum_obj.molecular_search_settings.min_peaks_per_class
+
+        kendrick_dict = {"km": list(), "kmd": list()}
+
+        if len(ms_peak_indexes) <= 1:
+            return []
+
+        for index, _ in ms_peak_indexes:
+            kendrick_dict["km"].append(mass_spectrum_obj[index].kendrick_mass)
+            kendrick_dict["kmd"].append(mass_spectrum_obj[index].kmd)
+
+        # check min data points otherwise StandardScaler().fit(0 will fail
+
+        df = pd.DataFrame(kendrick_dict)
+        matrix_data = df.values.astype("float32", copy=False)
+
+        stdscaler = StandardScaler().fit(matrix_data)
+        matrix_data_scaled = stdscaler.transform(matrix_data)
+
+        clusters = DBSCAN(eps=0.8, min_samples=min_samples).fit_predict(
+            matrix_data_scaled
+        )
+
+        # Number of clusters in labels, ignoring noise if present.
+        n_clusters_ = len(set(clusters)) - (1 if -1 in clusters else 0)
+        n_noise_ = list(clusters).count(-1)
+
+        if mass_spectrum_obj.parameters.mass_spectrum.verbose_processing:
+            print("Estimated number of clusters: %d" % n_clusters_)
+            print("Estimated number of noise points: %d" % n_noise_)
+
+        noise_idx = []
+
+        other_peaks_idx = []
+
+        for i in range(len(clusters)):
+            if clusters[i] == -1:
+                noise_idx.append(ms_peak_indexes[i])
+
+            else:
+                other_peaks_idx.append(ms_peak_indexes[i])
+
+        # mfs = [mass_spectrum_obj[index].best_molecular_formula_candidate.string for index in other_peaks_idx]
+
+        # mfs_noise = [mass_spectrum_obj[index].best_molecular_formula_candidate.string for index in noise_idx]
+
+        # print(mfs)
+        # print(mfs_noise)
+
+        # from matplotlib import pyplot as plt
+        # plt.scatter(matrix_data[:, 0], matrix_data[:, 1], c=clusters, cmap="jet")
+        # plt.xlabel("km")
+        # plt.ylabel("kmd")
+        # plt.show()
+        # plt.close()
+
+        return noise_idx
+
+    def remove_assignment_by_mass_error(self, mass_spectrum):
+        """Remove assignments from the mass spectrum based on mass error.
+
+        Parameters
+        ----------
+        mass_spectrum : MassSpectrum
+            Mass spectrum object.
+
+        """
+        # data need to be binned by mz unit or more to be able to use clustering
+
+        matrix_data, list_indexes_mass_spec = self.get_mass_error_matrix_data(
+            mass_spectrum
+        )
+
+        stdscaler = StandardScaler().fit(matrix_data)
+
+        matrix_data_scaled = stdscaler.transform(matrix_data)
+
+        # bandwidth = estimate_bandwidth(matrix_data_scaled, quantile=0.3, n_samples=int(len(ms_peaks)/3))
+
+        # clusters = MeanShift(bandwidth=bandwidth, bin_seeding=True).fit_predict(matrix_data_scaled)
+
+        # eps and min_samp need to be optimized by precision and number of mspeaks
+        clusters = DBSCAN(eps=0.15).fit_predict(matrix_data_scaled)
+
+        indexes = []
+
+        # from matplotlib import pyplot as plt
+        # plt.scatter(matrix_data[:, 0], matrix_data[:, 1], c=clusters, cmap="plasma")
+        # plt.xlabel("km")
+        # plt.ylabel("kmd")
+        # plt.show()
+        # plt.close()
+
+        for i in range(len(clusters)):
+            if clusters[i] == -1:
+                indexes.append(list_indexes_mass_spec[i])
+
+        mass_spectrum.remove_assignment_by_index(indexes)