CoreMS 4.0.0__py3-none-any.whl

corems/molecular_id/search/findOxygenPeaks.py

@@ -0,0 +1,330 @@
+__author__ = "Yuri E. Corilo"
+__date__ = "Jul 31, 2019"
+
+from copy import deepcopy
+from threading import Thread
+
+from numpy import average, std
+
+from corems.molecular_id.calc.ClusterFilter import ClusteringFilter
+from corems.molecular_id.factory.molecularSQL import MolForm_SQL
+from corems.molecular_id.search.molecularFormulaSearch import SearchMolecularFormulas
+
+
+class FindOxygenPeaks(Thread):
+    """Class to find Oxygen peaks in a mass spectrum for formula assignment search
+
+    Class to walk 14Da units over oxygen space for negative ion mass spectrum of natural organic matter
+    Returns a list of MSPeak class containing the possible Molecular Formula class objects.
+
+    Parameters
+    ----------
+    mass_spectrum_obj : MassSpec class
+        This is where we store MassSpec class obj,
+
+    lookupTableSettings:  MolecularLookupTableSettings class
+        This is where we store MolecularLookupTableSettings class obj
+
+    min_O , max_O : int
+        minium and maximum of Oxygen to allow the software to look for
+        it will override the settings at lookupTableSettings.usedAtoms
+        default min = 1, max = 22
+
+    Attributes
+    ----------
+    mass_spectrum_obj : MassSpec class
+        This is where we store MassSpec class obj,
+    lookupTableSettings:  MolecularLookupTableSettings class
+        This is where we store MolecularLookupTableSettings class obj
+
+    Methods
+    ----------
+    * run().
+            will be called when the instantiated class method start is called
+    * get_list_found_peaks().
+            returns a list of MSpeaks classes cotaining all the MolecularFormula candidates inside the MSPeak
+            for more details of the structure see MSPeak class and MolecularFormula class
+    * set_mass_spec_indexes_by_found_peaks().
+            set the mass spectrum to interate over only the selected indexes
+    """
+
+    def __init__(
+        self, mass_spectrum_obj, sql_db: bool = False, min_O: int = 1, max_O: int = 22
+    ):
+        Thread.__init__(self)
+
+        self.mass_spectrum_obj = mass_spectrum_obj
+        self.min_0 = min_O
+        self.max_O = max_O
+
+        if not sql_db:
+            self.sql_db = MolForm_SQL(
+                mass_spectrum_obj.molecular_search_settings.url_database
+            )
+        else:
+            self.sql_db = sql_db
+
+    def run(self):
+        """Run the thread"""
+        # save initial settings min peaks per class filter
+        initial_min_peak_bool = deepcopy(
+            self.mass_spectrum_obj.molecular_search_settings.use_min_peaks_filter
+        )
+
+        # deactivate the usage of min peaks per class filter
+        self.mass_spectrum_obj.molecular_search_settings.use_min_peaks_filter = False
+
+        # save initial settings for Ox
+        initial_ox = deepcopy(
+            self.mass_spectrum_obj.molecular_search_settings.usedAtoms["O"]
+        )
+
+        # resets the used atoms to look only for oxygen organic compounds
+        self.mass_spectrum_obj.molecular_search_settings.usedAtoms["O"] = (
+            self.min_0,
+            self.max_O,
+        )
+
+        self.list_found_mspeaks = []
+
+        kmd_base = self.mass_spectrum_obj.mspeaks_settings.kendrick_base
+
+        self.mass_spectrum_obj.change_kendrick_base_all_mspeaks(kmd_base)
+
+        # needs to be wrapped inside the mass_spec class
+        ClusteringFilter().filter_kendrick(self.mass_spectrum_obj)
+
+        if self.mass_spectrum_obj.parameters.mass_spectrum.verbose_processing:
+            print("Start most abundant mass spectral peak search")
+        molecular_formula_obj_reference = self.find_most_abundant_formula(
+            self.mass_spectrum_obj
+        )
+
+        if self.mass_spectrum_obj.parameters.mass_spectrum.verbose_processing:
+            print(
+                "Select most abundant peak with molecular formula =  %s with a m/z error of %s ppm"
+                % (
+                    molecular_formula_obj_reference.string,
+                    molecular_formula_obj_reference.mz_error,
+                )
+            )
+            print("Started mass spectral peak series search")
+
+        self.list_found_mspeaks = self.find_series_mspeaks(
+            self.mass_spectrum_obj, molecular_formula_obj_reference, deltamz=14
+        )
+
+        # reset indexes after done with operation that includes a filter (i.e. ClusteringFilter().filter_kendrick())
+
+        self.mass_spectrum_obj.molecular_search_settings.usedAtoms["O"] = initial_ox
+
+        self.mass_spectrum_obj.molecular_search_settings.use_min_peaks_filter = (
+            initial_min_peak_bool
+        )
+
+        self.mass_spectrum_obj.reset_indexes()
+
+        self.mass_spectrum_obj.filter_by_noise_threshold()
+        if self.mass_spectrum_obj.parameters.mass_spectrum.verbose_processing:
+            print("Done with mass spectral peak series search")
+
+        self.sql_db.close()
+
+    def find_most_abundant_formula(self, mass_spectrum_obj):
+        """Find the most abundant formula in the mass spectrum
+
+        Parameters
+        ----------
+        mass_spectrum_obj : MassSpec class
+            Mass spectrum object
+
+        Returns
+        ----------
+        MolecularFormula class obj
+            most abundant MolecularFormula with the lowest mass error
+        """
+        # need to find a better way to cut off outliners
+        # import matplotlib.pyplot as plt
+        # plt.hist(mass_spectrum_obj.abundance, bins=100)
+        # plt.show()
+
+        abundances = mass_spectrum_obj.abundance
+        abun_mean = average(abundances, axis=0)
+        abun_std = std(abundances, axis=0)
+
+        upper_limit = abun_mean + 7 * abun_std
+        if mass_spectrum_obj.parameters.mass_spectrum.verbose_processing:
+            print(
+                "Maximum abundance limit  = %s and max abundance kendrick cluster = %s"
+                % (
+                    upper_limit,
+                    max(mass_spectrum_obj, key=lambda m: m.abundance).abundance,
+                )
+            )
+
+        mspeak_most_abundant = max(
+            mass_spectrum_obj,
+            key=lambda m: m.abundance if m.abundance <= upper_limit else 0,
+        )
+
+        print("Searching molecular formulas")
+
+        SearchMolecularFormulas(mass_spectrum_obj, self.sql_db).run_worker_ms_peaks(
+            [mspeak_most_abundant]
+        )
+
+        print("Finished searching molecular formulas")
+
+        if mspeak_most_abundant:
+            return mspeak_most_abundant.best_molecular_formula_candidate
+
+        else:
+            raise Exception(
+                "Could not find a possible molecular formula match for the most abundant peak of m/z %.5f"
+                % mspeak_most_abundant.mz_exp
+            )
+
+        # return the first option
+        # return mspeak_most_abundant[0]
+
+    def find_most_abundant_formula_test(self, mass_spectrum_obj, settings):
+        """[Test function] Find the most abundant formula in the mass spectrum
+
+        Parameters
+        ----------
+        mass_spectrum_obj : MassSpec class
+            Mass spectrum object
+        settings : MolecularSearchSettings class
+            Molecular search settings object
+
+        Returns
+        ----------
+        MolecularFormula class obj
+            most abundant MolecularFormula with the lowest mass error
+
+        """
+        # this function is intended for test only.
+        # Have to sort by Kendrick to be able to select the most abundant series
+        # then select the most abundant peak inside the series
+        # or have the user select the reference mspeak on the gui
+
+        mspeak_most_abundant = mass_spectrum_obj.most_abundant_mspeak
+
+        SearchMolecularFormulas(mass_spectrum_obj, self.sql_db).run_worker_ms_peaks(
+            [mspeak_most_abundant]
+        )
+
+        if mspeak_most_abundant:
+            return mspeak_most_abundant.best_molecular_formula_candidate
+
+        else:
+            raise Exception(
+                "Could not find a possible molecular formula match for the most abundant peak of m/z %.5f"
+                % mspeak_most_abundant.mz_exp
+            )
+        # return the first option
+        # return mspeak_most_abundant[0]
+
+    def find_series_mspeaks(
+        self, mass_spectrum_obj, molecular_formula_obj_reference, deltamz=14
+    ):
+        """Find a series of abundant peaks in the mass spectrum for a given molecular formula
+
+        Parameters
+        ----------
+        mass_spectrum_obj : MassSpec class
+            Mass spectrum object
+        molecular_formula_obj_reference : MolecularFormula class
+            Molecular formula object
+        deltamz : float
+            delta m/z to look for peaks
+
+        Returns
+        ----------
+        list
+            list of MSpeak class objects
+        """
+        abundances = mass_spectrum_obj.abundance
+        abun_mean = average(abundances, axis=0)
+        abun_std = std(abundances, axis=0)
+        upper_limit = abun_mean + 7 * abun_std
+
+        list_most_abundant_peaks = list()
+
+        min_mz = mass_spectrum_obj.min_mz_exp
+
+        max_mz = mass_spectrum_obj.max_mz_exp
+
+        initial_nominal_mass = molecular_formula_obj_reference.mz_nominal_calc
+
+        mass = initial_nominal_mass
+
+        nominal_masses = []
+        while mass <= max_mz:
+            # print "shit 1", mass, min_mz
+            mass += deltamz
+            nominal_masses.append(mass)
+
+        mass = initial_nominal_mass
+        while mass >= min_mz:
+            # print "shit 1", mass, min_mz
+            mass -= deltamz
+            nominal_masses.append(mass)
+
+        nominal_masses = sorted(nominal_masses)
+
+        for nominal_mass in nominal_masses:
+            first_index, last_index = (
+                mass_spectrum_obj.get_nominal_mz_first_last_indexes(nominal_mass)
+            )
+
+            ms_peaks = mass_spectrum_obj[first_index:last_index]
+
+            if ms_peaks:
+                #
+                # print (nominal_mass, first_index,
+                #    last_index,
+                #    mass_spectrum_obj[first_index].mz_exp,
+                #    mass_spectrum_obj[last_index].mz_exp
+                #    )
+                #
+
+                mspeak_most_abundant = max(
+                    ms_peaks,
+                    key=lambda m: m.abundance if m.abundance <= upper_limit else 0,
+                )
+
+                # mspeak_most_abundant = max(ms_peaks, key=lambda m: m.abundance)
+
+                list_most_abundant_peaks.append(mspeak_most_abundant)
+        if mass_spectrum_obj.parameters.mass_spectrum.verbose_processing:
+            print("Start molecular formula search")
+        SearchMolecularFormulas(mass_spectrum_obj, self.sql_db).run_worker_ms_peaks(
+            list_most_abundant_peaks
+        )
+        if mass_spectrum_obj.parameters.mass_spectrum.verbose_processing:
+            print("Done molecular formula search")
+        return [mspeak for mspeak in list_most_abundant_peaks if mspeak]
+
+    def get_list_found_peaks(self):
+        """Get the list of found peaks
+
+        Returns
+        ----------
+        list
+            list of MSpeak class objects
+        """
+        return sorted(self.list_found_mspeaks, key=lambda mp: mp.mz_exp)
+
+    def set_mass_spec_indexes_by_found_peaks(self):
+        """Set the mass spectrum to interate over only the selected indexes.
+
+        Notes
+        ----------
+        Warning!!!!
+        set the mass spectrum to interate over only the selected indexes
+        don not forget to call mass_spectrum_obj.reset_indexes after the job is done
+        """
+
+        indexes = [msp.index for msp in self.list_found_mspeaks]
+        self.mass_spectrum_obj.set_indexes(indexes)

corems/molecular_id/search/lcms_spectral_search.py

@@ -0,0 +1,348 @@
+import re
+
+import numpy as np
+
+from corems.molecular_id.factory.spectrum_search_results import SpectrumSearchResults
+
+
+class LCMSSpectralSearch:
+    """
+    Methods for searching LCMS spectra.
+
+    This class is designed to be a mixin class for the :obj:`~corems.mass_spectra.factory.lc_class.LCMSBase` class.
+
+    """
+
+    @staticmethod
+    def get_more_match_quals(
+        query_mz_arr, lib_entry, mz_tol_da=0.1, include_fragment_types=False
+    ):
+        """
+        Return additional match qualities between query and library entry.
+
+        Parameters
+        ----------
+        query_mz_arr : np.array
+            Array of query spectrum. Shape (N, 2), with m/z in the first column
+            and abundance in the second.
+        lib_entry : dict
+            Library spectrum entry, with 'mz' key containing the spectrum in
+            the format (mz, abundance),(mz, abundance), i.e. from MetabRef.
+        mz_tol_da : float, optional
+            Tolerance in Da for matching peaks (in MS2). Default is 0.1.
+        include_fragment_types : bool, optional
+            If True, include fragment type comparisons in output.
+            Defaults to False.
+
+        Returns
+        -------
+        tuple
+            Tuple of (query_in_lib, query_in_lib_fract, lib_in_query, lib_in_query_fract, query_frags, lib_frags, lib_precursor_mz).
+
+        Notes
+        -----
+        query_in_lib : int
+            Number of peaks in query that are present in the library entry (within mz_tol_da).
+        query_in_lib_fract : float
+            Fraction of peaks in query that are present in the library entry (within mz_tol_da).
+        lib_in_query : int
+            Number of peaks in the library entry that are present in the query (within mz_tol_da).
+        lib_in_query_fract : float
+            Fraction of peaks in the library entry that are present in the query (within mz_tol_da).
+        query_frags : list
+            List of unique fragment types present in the query, generally 'MLF' or 'LSF' or both.
+        lib_frags : list
+            List of unique fragment types present in the library entry, generally 'MLF' or 'LSF' or both.
+
+        Raises
+        ------
+        ValueError
+            If library entry does not have 'fragment_types' key and include_fragment_types is True.
+
+        """
+
+        if "mz" in lib_entry.keys():
+            # Get the original mz values from the library entry
+            lib_mzs = np.array(
+                re.findall(r"\(([^,]+),([^)]+)\)", lib_entry["mz"]), dtype=float
+            ).reshape(-1, 2)[:, 0]
+        elif "peaks" in lib_entry.keys() and lib_entry["peaks"] is not None:
+            lib_mzs = lib_entry["peaks"][:, 0]
+
+        # Get count and fraction of peaks in query that are in lib entry
+        query_in_lib = 0
+        for peak in query_mz_arr:
+            if np.any(np.isclose(lib_mzs, peak, atol=mz_tol_da)):
+                query_in_lib += 1
+        query_in_lib_fract = query_in_lib / len(query_mz_arr)
+
+        # Get count and fraction of peaks in lib that are in query
+        lib_in_query = 0
+        for peak in lib_mzs:
+            if np.any(np.isclose(query_mz_arr, peak, atol=mz_tol_da)):
+                lib_in_query += 1
+        lib_in_query_fract = lib_in_query / len(lib_mzs)
+
+        if include_fragment_types:
+            # Check that fragment types are present in the library entry
+            if "fragment_types" not in lib_entry.keys():
+                raise ValueError(
+                    "Flash entropy library entry must have 'fragment_types' key to include fragment types in output."
+                )
+
+            # Get types of fragments in the lib entry and convert it to a list on ", "
+            lib_frags = [x.strip() for x in lib_entry["fragment_types"].split(",")]
+            # make list of the fragment types that are present in the query spectrum
+            lib_in_query_ids = list(
+                set(
+                    [
+                        ind
+                        for ind, x in enumerate(lib_mzs)
+                        if len(np.where(np.isclose(query_mz_arr, x, atol=mz_tol_da))[0])
+                        > 0
+                    ]
+                )
+            )
+            query_frags = list(set([lib_frags[x] for x in lib_in_query_ids]))
+            lib_frags = list(set(lib_frags))
+
+        else:
+            query_frags = None
+            lib_frags = None
+
+        return (
+            query_in_lib,
+            query_in_lib_fract,
+            lib_in_query,
+            lib_in_query_fract,
+            query_frags,
+            lib_frags,
+        )
+
+    def fe_search(
+        self,
+        scan_list,
+        fe_lib,
+        precursor_mz_list=[],
+        use_mass_features=True,
+        peak_sep_da=0.01,
+        get_additional_metrics=True,
+        accumulate_results=False,
+    ):
+        """
+        Search LCMS spectra using a FlashEntropy approach.
+
+        Parameters
+        ----------
+        scan_list : list
+            List of scan numbers to search.
+        fe_lib : :obj:`~ms_entropy.FlashEntropySearch`
+            FlashEntropy Search instance.
+        precursor_mz_list : list, optional
+            List of precursor m/z values to search, by default [], which implies
+            matched with mass features; to enable this use_mass_features must be True.
+        use_mass_features : bool, optional
+            If True, use mass features to get precursor m/z values, by default True.
+            If True, will add search results to mass features' ms2_similarity_results attribute.
+        peak_sep_da : float, optional
+            Minimum separation between m/z peaks spectra in Da. This needs match the
+            approximate resolution of the search spectra and the FlashEntropySearch
+            instance, by default 0.01.
+        get_additional_metrics : bool, optional
+            If True, get additional metrics from FlashEntropy search, by default True.
+        accumulate_results : bool, optional
+            If True, accumulate results with existing spectral_search_results instead of
+            replacing them. This allows searching the same scans with multiple libraries
+            without overwriting previous results, by default False.
+
+        Returns
+        -------
+        None, but adds results to self.spectral_search_results and associates these
+        spectral_search_results with mass_features within the self.mass_features dictionary.
+
+        """
+        # Retrieve parameters from self
+        # include_fragment_types should used for lipids queries only, not general metabolomics
+        include_fragment_types = self.parameters.lc_ms.include_fragment_types
+        min_match_score = self.parameters.lc_ms.ms2_min_fe_score
+
+        # If precursor_mz_list is empty and use_mass_features is True, get precursor m/z values from mass features for each scan in scan_list
+        if use_mass_features and len(precursor_mz_list) == 0:
+            precursor_mz_list = []
+            for scan in scan_list:
+                mf_ids = [
+                    key
+                    for key, value in self.mass_features.items()
+                    if scan in value.ms2_mass_spectra
+                ]
+                precursor_mz = [
+                    value.mz
+                    for key, value in self.mass_features.items()
+                    if key in mf_ids
+                ]
+                precursor_mz_list.append(precursor_mz)
+
+        # Check that precursor_mz_list same length as scan_list, if not, raise error
+        if len(precursor_mz_list) != len(scan_list):
+            raise ValueError("Length of precursor_mz_list is not equal to scan_list.")
+
+        # Loop through each query spectrum / precursor match and save ids of db spectrum that are decent matches
+        overall_results_dict = {}
+        for i in np.arange(len(scan_list)):
+            scan_oi = scan_list[i]
+            if len(self._ms[scan_oi].mspeaks) > 0:
+                precursor_mzs = precursor_mz_list[i]
+                overall_results_dict[scan_oi] = {}
+                for precursor_mz in precursor_mzs:
+                    query_spectrum = fe_lib.clean_spectrum_for_search(
+                        precursor_mz=precursor_mz,
+                        peaks=np.vstack(
+                            (self._ms[scan_oi].mz_exp, self._ms[scan_oi].abundance)
+                        ).T,
+                        precursor_ions_removal_da=None,
+                        noise_threshold=self._ms[
+                            scan_oi
+                        ].parameters.mass_spectrum.noise_threshold_min_relative_abundance
+                        / 100,
+                        min_ms2_difference_in_da=peak_sep_da,
+                    )
+                    search_results = fe_lib.search(
+                        precursor_mz=precursor_mz,
+                        peaks=query_spectrum,
+                        ms1_tolerance_in_da=self.parameters.mass_spectrum[
+                            "ms1"
+                        ].molecular_search.max_ppm_error
+                        * 10**-6
+                        * precursor_mz,
+                        ms2_tolerance_in_da=peak_sep_da * 0.5,
+                        method={"identity"},
+                        precursor_ions_removal_da=None,
+                        noise_threshold=self._ms[
+                            scan_oi
+                        ].parameters.mass_spectrum.noise_threshold_min_relative_abundance
+                        / 100,
+                        target="cpu",
+                    )["identity_search"]
+                    match_inds = np.where(search_results > min_match_score)[0]
+
+                    # If any decent matches are found, add them to the results dictionary
+                    if len(match_inds) > 0:
+                        match_scores = search_results[match_inds]
+                        ref_ms_ids = [fe_lib[x]["id"] for x in match_inds]
+                        ref_mol_ids = [
+                            fe_lib[x]["molecular_data_id"] for x in match_inds
+                        ]
+                        ref_precursor_mzs = [
+                            fe_lib[x]["precursor_mz"] for x in match_inds
+                        ]
+                        ion_types = [fe_lib[x]["ion_type"] for x in match_inds]
+                        overall_results_dict[scan_oi][precursor_mz] = {
+                            "ref_mol_id": ref_mol_ids,
+                            "ref_ms_id": ref_ms_ids,
+                            "ref_precursor_mz": ref_precursor_mzs,
+                            "precursor_mz_error_ppm": [
+                                (precursor_mz - x) / precursor_mz * 10**6
+                                for x in ref_precursor_mzs
+                            ],
+                            "entropy_similarity": match_scores,
+                            "ref_ion_type": ion_types,
+                        }
+                        # Add database name, if present
+                        db_name = [
+                            fe_lib[x].get("database_name") for x in match_inds
+                        ]
+                        if db_name is not None:
+                            overall_results_dict[scan_oi][precursor_mz].update(
+                                {"database_name": db_name}
+                            )
+                        if get_additional_metrics:
+                            more_match_quals = [
+                                self.get_more_match_quals(
+                                    self._ms[scan_oi].mz_exp,
+                                    fe_lib[x],
+                                    mz_tol_da=peak_sep_da,
+                                    include_fragment_types=include_fragment_types,
+                                )
+                                for x in match_inds
+                            ]
+                            overall_results_dict[scan_oi][precursor_mz].update(
+                                {
+                                    "query_mz_in_ref_n": [
+                                        x[0] for x in more_match_quals
+                                    ],
+                                    "query_mz_in_ref_fract": [
+                                        x[1] for x in more_match_quals
+                                    ],
+                                    "ref_mz_in_query_n": [
+                                        x[2] for x in more_match_quals
+                                    ],
+                                    "ref_mz_in_query_fract": [
+                                        x[3] for x in more_match_quals
+                                    ],
+                                }
+                            )
+                            if include_fragment_types:
+                                overall_results_dict[scan_oi][precursor_mz].update(
+                                    {
+                                        "query_frag_types": [
+                                            x[4] for x in more_match_quals
+                                        ],
+                                        "ref_frag_types": [
+                                            x[5] for x in more_match_quals
+                                        ],
+                                    }
+                                )
+
+        # Drop scans with no results from dictionary
+        overall_results_dict = {k: v for k, v in overall_results_dict.items() if v}
+
+        # Cast each entry as a MS2SearchResults object
+        for scan_id in overall_results_dict.keys():
+            for precursor_mz in overall_results_dict[scan_id].keys():
+                ms2_spectrum = self._ms[scan_id]
+                ms2_search_results = overall_results_dict[scan_id][precursor_mz]
+                overall_results_dict[scan_id][precursor_mz] = SpectrumSearchResults(
+                    ms2_spectrum, precursor_mz, ms2_search_results
+                )
+
+        # Add MS2SearchResults to the existing spectral search results dictionary
+        if accumulate_results:
+            # Merge results with existing spectral_search_results
+            for scan_id, precursor_dict in overall_results_dict.items():
+                if scan_id in self.spectral_search_results:
+                    # Scan already has results, merge precursor_mz dictionaries
+                    self.spectral_search_results[scan_id].update(precursor_dict)
+                else:
+                    # New scan, add entire dictionary
+                    self.spectral_search_results[scan_id] = precursor_dict
+        else:
+            # Replace existing results (original behavior)
+            self.spectral_search_results.update(overall_results_dict)
+
+        # If there are mass features, associate the results with each mass feature
+        if len(self.mass_features) > 0:
+            # Determine which results to associate with mass features
+            if accumulate_results:
+                # When accumulating, only associate new results from this search
+                # to avoid duplicating previously associated results
+                results_to_associate = overall_results_dict
+            else:
+                # When not accumulating, clear existing associations and re-associate all results
+                for mass_feature_id in self.mass_features.keys():
+                    self.mass_features[mass_feature_id].ms2_similarity_results = []
+                results_to_associate = self.spectral_search_results
+            
+            for mass_feature_id, mass_feature in self.mass_features.items():
+                scan_ids = mass_feature.ms2_scan_numbers
+                for ms2_scan_id in scan_ids:
+                    precursor_mz = mass_feature.mz
+                    try:
+                        results_to_associate[ms2_scan_id][precursor_mz]
+                    except KeyError:
+                        pass
+                    else:
+                        self.mass_features[
+                            mass_feature_id
+                        ].ms2_similarity_results.append(
+                            results_to_associate[ms2_scan_id][precursor_mz]
+                        )