CoreMS 4.0.0__py3-none-any.whl

corems/molecular_id/factory/spectrum_search_results.py

@@ -0,0 +1,119 @@
+class SpectrumSearchResults:
+    """Class for storing Search Results for a single Spectrum Query
+
+    Parameters
+    ----------
+    query_spectrum : MassSpectrum
+        The queried mass spectrum
+    precursor_mz : float, optional
+        The queried precursor_mz. None is interpreted as an open query, i.e. no precursor_mz
+    spectral_similarity_search_results : dict
+        The search results for the queried spectrum, which will be unpacked into attributes
+
+    Attributes
+    ----------
+    query_spectrum : MassSpectrum
+        The queried mass spectrum
+    query_spectrum_id : int
+        The id of the queried spectrum (the scan number within an MassSpectra object)
+    precursor_mz : float
+        The precursor m/z of the queried spectrum
+
+    Other Possible Attributes
+    -------------------------
+    ref_mol_id : str
+        The id of the molecule associated with the query spectrum in reference database
+    ref_ms_id : str
+        The id of the query spectrum in reference database
+    ref_precursor_mz : float
+        The precursor mass of the query spectrum
+    precursor_mz_error_ppm : float
+        The ppm error between the query spectrum and the reference spectrum
+    entropy_similarity : float
+        The entropy similarity between the query spectrum and the reference spectrum
+    ref_ion_type : str
+        The ion type of the reference spectrum, i.e. [M+H]+, [M+Na]+, etc.
+    query_mz_in_ref_n : list
+        The number of query m/z peaks that are in the reference spectrum
+    query_mz_in_ref_fract : float
+        The fraction of query m/z peaks that are in the reference spectrum
+    query_frag_types : list
+        The fragment types of the query spectrum that are in the reference spectrum,
+        i.e. LSF (lipid species fragments) or MSF (molecular species fragments),
+        generally used for only for lipidomics
+    ref_mz_in_query_n : list
+        The number of reference m/z peaks that are in the query spectrum
+    ref_mz_in_query_fract : float
+        The fraction of reference m/z peaks that are in the query spectrum
+    ref_frag_types : list
+        The fragment types of the reference spectrum,
+        i.e. LSF (lipid species fragments) or MSF (molecular species fragments),
+        generally used for only for lipidomics
+    database_name : str
+        The name of the associated database, i.e. "LipidBlast" or "GNPS"
+
+    Methods
+    -------
+    *to_dataframe().
+        Convert the SpectrumSearchResults to a pandas DataFrame
+
+    """
+
+    def __init__(
+        self, query_spectrum, precursor_mz, spectral_similarity_search_results
+    ):
+        self.query_spectrum = query_spectrum
+        self.precursor_mz = precursor_mz
+        if query_spectrum is not None:
+            if query_spectrum.scan_number is not None:
+                self.query_spectrum_id = query_spectrum.scan_number
+        attribute_keys = [
+            "ref_mol_id",
+            "ref_ms_id",
+            "ref_precursor_mz",
+            "precursor_mz_error_ppm",
+            "ref_ion_type",
+            "entropy_similarity",
+            "query_mz_in_ref_n",
+            "query_mz_in_ref_fract",
+            "query_frag_types",
+            "ref_mz_in_query_n",
+            "ref_mz_in_query_fract",
+            "ref_frag_types",
+            "database_name",
+        ]
+        for key in spectral_similarity_search_results.keys():
+            if key in attribute_keys:
+                setattr(self, key, spectral_similarity_search_results[key])
+
+    def to_dataframe(self, cols_to_drop=None):
+        """Convert the SpectrumSearchResults to a pandas DataFrame
+
+        Parameters
+        ----------
+        cols_to_drop : list, optional
+            A list of columns to drop from the DataFrame. Default is None.
+
+        Returns
+        -------
+        pandas.DataFrame
+            A DataFrame with the SpectrumSearchResults attributes as columns
+
+        """
+        import pandas as pd
+
+        # get initial dict
+        df = pd.DataFrame.from_dict(self.__dict__).copy()
+
+        # remove ms2_spectrum column
+        df = df.drop(columns=["query_spectrum"])
+
+        # drop additional columns
+        if cols_to_drop is not None:
+            df = df.drop(columns=cols_to_drop)
+
+        # reorder to high to low entropy similarity
+        df = df.sort_values(by=["entropy_similarity"], ascending=False)
+
+        # rename id to query_scan_number
+        return pd.DataFrame(df)

corems/molecular_id/input/nistMSI.py

@@ -0,0 +1,148 @@
+__author__ = "Yuri E. Corilo"
+__date__ = "Feb 12, 2020"
+
+from threading import Thread
+from pathlib import Path
+
+from corems.molecular_id.factory.EI_SQL import EI_LowRes_SQLite
+
+
+class ReadNistMSI(Thread):
+    """A class for reading NIST MSI files and storing the data in a SQLite database.
+
+    Parameters
+    ----------
+    file_path : str
+        The path to the NIST MSI file.
+    url : str, optional
+        The URL for the SQLite database. Default is 'sqlite://'.
+
+    Raises
+    ------
+    FileExistsError
+        If the specified file does not exist.
+
+    Attributes
+    ----------
+    file_path : str
+        The path to the NIST MSI file.
+    url : str
+        The URL for the SQLite database.
+    sqlLite_obj : EI_LowRes_SQLite
+        The SQLite object for storing the compound data.
+
+    Methods
+    -------
+    * run().
+        Runs the thread and initializes the SQLite object.
+    * get_sqlLite_obj().
+        Returns the SQLite object.
+    * get_compound_data_dict_list().
+        Parses the NIST MSI file and returns a list of compound data dictionaries.
+    """
+
+    def __init__(self, file_path, url="sqlite://"):
+        Thread.__init__(self)
+        file_path = Path(file_path)
+
+        if not file_path.exists():
+            raise FileExistsError("File does not exist: " + file_path)
+
+        self.file_path = file_path
+
+        self.url = url
+
+    def run(self):
+        """Runs the thread and initializes the SQLite object."""
+        self.sqlLite_obj = self.get_sqlLite_obj()
+
+    def get_sqlLite_obj(self):
+        """Returns the SQLite object.
+
+        Returns
+        -------
+        EI_LowRes_SQLite
+            The SQLite object for storing the compound data.
+        """
+        compound_data_dict_list = self.get_compound_data_dict_list()
+
+        sqlLite_obj = EI_LowRes_SQLite(url=self.url)
+
+        for data_dict in compound_data_dict_list:
+            if not data_dict.get("NUM PEAKS"):
+                data_dict["NUM PEAKS"] = len(data_dict.get("mz"))
+            if not data_dict.get("CASNO"):
+                data_dict["CASNO"] = data_dict.get("CAS")
+                if not data_dict["CASNO"]:
+                    data_dict["CASNO"] = 0
+            # print(data_dict)
+            try:
+                sqlLite_obj.add_compound(data_dict)
+            except:
+                print(data_dict.get("NAME"))
+
+        return sqlLite_obj
+
+    def get_compound_data_dict_list(self):
+        """Parses the NIST MSI file and returns a list of compound data dictionaries.
+
+        Returns
+        -------
+        list
+            A list of compound data dictionaries.
+        """
+        list_dict_data = []
+
+        with open(self.file_path) as msifile:
+            content = msifile.readlines()
+
+            i = 0
+
+            dict_data = dict()
+            dict_data["mz"] = list()
+            dict_data["abundance"] = list()
+            # for line in content:
+            #   print(line, line=="\n" )
+
+            while i < len(content):
+                split_line = content[i].split(":")
+
+                # empty line
+                if len(content[i]) == 1:
+                    i += 1
+                    if dict_data.get("NAME"):
+                        list_dict_data.append(dict_data)
+
+                    # print(dict_data)
+                    dict_data = dict()
+                    dict_data["mz"] = list()
+                    dict_data["abundance"] = list()
+
+                # metadata, name, ri, rt etc
+                elif len(split_line) >= 2:
+                    label = split_line[0]
+                    value = ":".join(split_line[1:]).strip("\n").strip("")
+                    dict_data[label] = value
+                    i += 1
+
+                # mz and abundance pairs
+                elif len(split_line) == 1:
+                    for s in content[i].strip("\n").strip("").split("(")[1:]:
+                        values = s.split(" ")
+
+                        if values[0] == "":
+                            mz = values[1]
+                        else:
+                            mz = values[0]
+
+                        abun = values[-2].strip(")")
+
+                        dict_data["mz"].append(mz)
+                        dict_data["abundance"].append(abun)
+
+                    i += 1
+                # something else
+                else:
+                    i += 1
+
+        return list_dict_data

corems/molecular_id/search/compoundSearch.py

@@ -0,0 +1,214 @@
+from math import exp
+from threading import Thread
+
+from numpy import power
+
+from corems.molecular_id.calc.SpectralSimilarity import SpectralSimilarity
+from corems.molecular_id.factory.EI_SQL import EI_LowRes_SQLite
+
+
+class LowResMassSpectralMatch(Thread):
+    """A class representing a low-resolution mass spectral match.
+
+    Parameters
+    -----------
+    gcms_obj : object
+        The GC-MS object.
+    sql_obj : object, optional
+        The SQL object for database operations. Default is None.
+    calibration : bool, optional
+        Flag indicating if the match is for calibration. Default is False.
+
+    Attributes
+    -----------
+    gcms_obj : object
+        The GC-MS object.
+    sql_obj : object
+        The SQL object for database operations.
+    calibration : bool
+        Flag indicating if the match is for calibration.
+
+    Methods
+    --------
+    * metabolite_detector_score(gc_peak, ref_obj, spectral_simi).
+        Calculates the spectral similarity scores and the similarity score for a given GC peak and reference object.
+    * run().
+        Runs the low-resolution mass spectral match.
+
+    """
+
+    def __init__(self, gcms_obj, sql_obj=None, calibration=False):
+        Thread.__init__(self)
+
+        self.gcms_obj = gcms_obj
+
+        #  initiated at create_molecular_database()
+        # self.dict_molecular_lookup_table = None
+        self.calibration = calibration
+        # reading local file for now,
+        if not sql_obj:
+            self.sql_obj = EI_LowRes_SQLite(
+                url=self.gcms_obj.molecular_search_settings.url_database
+            )
+        else:
+            self.sql_obj = sql_obj
+
+    def metabolite_detector_score(self, gc_peak, ref_obj, spectral_simi):
+        """
+        Calculates the spectral similarity scores and the similarity score for a given GC peak and reference object.
+
+        Parameters
+        -----------
+        gc_peak : object
+            The GC peak object.
+        ref_obj : object
+            The reference object.
+        spectral_simi : object
+            The spectral similarity object.
+
+        Returns
+        --------
+        tuple
+            A tuple containing the spectral similarity scores, RI score, and similarity score.
+
+        """
+        spectral_similarity_scores = {}
+        spectral_similarity_scores["cosine_correlation"] = (
+            spectral_simi.cosine_correlation()
+        )
+
+        if self.gcms_obj.molecular_search_settings.exploratory_mode:
+            spectral_similarity_scores["weighted_cosine_correlation"] = (
+                spectral_simi.weighted_cosine_correlation()
+            )
+            ss, ss_nist = spectral_simi.stein_scott()
+            spectral_similarity_scores["stein_scott_similarity"] = ss
+            spectral_similarity_scores["stein_scott_similarity_nist"] = ss_nist
+
+            spectral_similarity_scores["pearson_correlation"] = (
+                spectral_simi.pearson_correlation()
+            )
+            spectral_similarity_scores["spearman_correlation"] = (
+                spectral_simi.spearman_correlation()
+            )
+            spectral_similarity_scores["kendall_tau_correlation"] = (
+                spectral_simi.kendall_tau()
+            )
+            spectral_similarity_scores["euclidean_distance"] = (
+                spectral_simi.euclidean_distance()
+            )
+            spectral_similarity_scores["manhattan_distance"] = (
+                spectral_simi.manhattan_distance()
+            )
+            spectral_similarity_scores["jaccard_distance"] = (
+                spectral_simi.jaccard_distance()
+            )
+            spectral_similarity_scores["dft_correlation"] = (
+                spectral_simi.dft_correlation()
+            )
+            spectral_similarity_scores["dwt_correlation"] = (
+                spectral_simi.dwt_correlation()
+            )
+            spectral_similarity_scores.update(spectral_simi.extra_distances())
+            # print(spectral_similarity_scores)
+        # print(ref_obj.get('ri'), gc_peak.ri, self.gcms_obj.molecular_search_settings.ri_window)
+
+        ri_score = exp(
+            -1
+            * (
+                power((gc_peak.ri - ref_obj.get("ri")), 2)
+                / (2 * power(self.gcms_obj.molecular_search_settings.ri_std, 2))
+            )
+        )
+
+        similarity_score = (
+            (spectral_similarity_scores.get("cosine_correlation") ** 2) * (ri_score)
+        ) ** (1 / 3)
+
+        return spectral_similarity_scores, ri_score, similarity_score
+
+    def run(self):
+        """Runs the low-resolution mass spectral match."""
+        # TODO select the best gcms peak
+        import tqdm
+
+        original_use_deconvolution = (
+            self.gcms_obj.chromatogram_settings.use_deconvolution
+        )
+
+        if not self.gcms_obj:
+            # Do not use deconvolution for the retention index calibration
+
+            if self.calibration:
+                self.gcms_obj.chromatogram_settings.use_deconvolution = False
+
+            self.gcms_obj.process_chromatogram()
+
+        self.gcms_obj.chromatogram_settings.use_deconvolution = (
+            original_use_deconvolution
+        )
+        verbose = self.gcms_obj.chromatogram_settings.verbose_processing
+        for gc_peak in tqdm.tqdm(self.gcms_obj, disable = not verbose):
+            if not self.calibration:
+                window = self.gcms_obj.molecular_search_settings.ri_search_range
+
+                ri = gc_peak.ri
+
+                min_mat_ri = (ri - window, ri + window)
+
+                ref_objs = self.sql_obj.query_min_max_ri(min_mat_ri)
+
+            else:
+                compound_names = self.gcms_obj.molecular_search_settings.ri_calibration_compound_names
+
+                window = self.gcms_obj.molecular_search_settings.rt_search_range
+
+                rt = gc_peak.retention_time
+
+                min_mat_rt = (rt - window, rt + window)
+
+                ref_objs = self.sql_obj.query_names_and_rt(min_mat_rt, compound_names)
+
+            for ref_obj in ref_objs:
+                # uses spectral similarly and uses a threshold to only select peaks with high data correlation
+
+                spectral_simi = SpectralSimilarity(
+                    gc_peak.mass_spectrum.mz_abun_dict, ref_obj
+                )
+
+                if self.calibration:
+                    spectral_similarity_scores = {}
+                    spectral_similarity_scores["cosine_correlation"] = (
+                        spectral_simi.cosine_correlation()
+                    )
+
+                    # print(w_correlation_value,correlation_value )
+                    if (
+                        spectral_similarity_scores["cosine_correlation"]
+                        >= self.gcms_obj.molecular_search_settings.correlation_threshold
+                    ):
+                        gc_peak.add_compound(ref_obj, spectral_similarity_scores)
+
+                # use score, usually a combination of Retention index and Spectral Similarity
+                # Threshold is implemented by not necessarily used
+                else:
+                    # m/q developed methods will be implemented here
+                    spectral_similarity_scores, ri_score, similarity_score = (
+                        self.metabolite_detector_score(gc_peak, ref_obj, spectral_simi)
+                    )
+
+                    # TODO need to add similarity score option in the parameters encapsulation class
+
+                    if (
+                        similarity_score
+                        >= self.gcms_obj.molecular_search_settings.score_threshold
+                    ):
+                        gc_peak.add_compound(
+                            ref_obj,
+                            spectral_similarity_scores,
+                            ri_score,
+                            similarity_score,
+                        )
+
+        self.sql_obj.session.close()
+        self.sql_obj.engine.dispose()