CoreMS 4.0.0__py3-none-any.whl

corems/mass_spectrum/calc/CalibrationCalc.py

@@ -0,0 +1,253 @@
+import numpy as np
+
+
+class FreqDomain_Calibration:
+    """Frequency Domain Calibration class for mass spectrum.
+
+    Parameters
+    ----------
+    mass_spectrum : MassSpectrum
+        The mass spectrum object.
+    selected_mass_peaks : list
+        List of selected mass peaks.
+    include_isotopologue : bool, optional
+        Flag to include isotopologues, by default False.
+
+    Attributes
+    ----------
+    mz_exp : ndarray
+        Array of experimental m/z values.
+    mz_calc : ndarray
+        Array of calculated m/z values.
+    freq_exp : ndarray
+        Array of experimental frequencies.
+    mass_spectrum : MassSpectrum
+        The mass spectrum object.
+    freq_exp_ms : ndarray
+        Array of experimental frequencies for mass spectrum.
+
+    Methods
+    -------
+    * recal_mass_spec(mz_domain, Aterm, Bterm, Cterm).
+        Recalibrate the mass spectrum with the given parameters.
+    * linear().
+        Perform linear calibration.
+    * quadratic(iteration=False).
+        Perform quadratic calibration.
+    * ledford_calibration(iteration=False).
+        Perform Ledford calibration.
+    * step_fit(steps=4).
+        Perform step fit calibration.
+
+    """
+
+    def __init__(self, mass_spectrum, selected_mass_peaks, include_isotopologue=False):
+        self.selected_mspeaks = selected_mass_peaks
+        error = list()
+        freq_exp = list()
+        mz_calc = list()
+        mz_exp = list()
+
+        for mspeak in selected_mass_peaks:
+            if not include_isotopologue:
+                molecular_formulas = [
+                    formula for formula in mspeak if not formula.is_isotopologue
+                ]
+            else:
+                molecular_formulas = mspeak
+
+            for molecular_formula in molecular_formulas:
+                freq_exp.append(mspeak.freq_exp)
+                error.append(molecular_formula.mz_error)
+                mz_calc.append(molecular_formula.mz_calc)
+                mz_exp.append(mspeak.mz_exp)
+
+        self.mz_exp = np.array(mz_exp)
+        self.mz_calc = np.array(mz_calc)
+        self.freq_exp = np.array(freq_exp)
+        self.mass_spectrum = mass_spectrum
+        self.freq_exp_ms = np.array([mspeak.freq_exp for mspeak in mass_spectrum])
+
+    def recal_mass_spec(self, mz_domain, Aterm, Bterm, Cterm):
+        """Recalibrate the mass spectrum with the given parameters.
+
+        Parameters
+        ----------
+        mz_domain : ndarray
+            Array of m/z values for recalibration.
+        Aterm : float
+            Aterm parameter for recalibration.
+        Bterm : float
+            Bterm parameter for recalibration.
+        Cterm : float
+            Cterm parameter for recalibration.
+
+        """
+        self.mass_spectrum._calibration_terms = (Aterm, Bterm, 0)
+        self.mass_spectrum.mz_cal = mz_domain
+
+    def linear(self):
+        """Perform linear calibration."""
+        matrix = np.vstack([1 / self.freq_exp, np.ones(len(self.freq_exp))]).T
+        Aterm, Bterm = np.linalg.lstsq(matrix, self.mz_calc, rcond=None)[0]
+        if self.mass_spectrum.parameters.mass_spectrum.verbose_processing:
+            print("%.2f Aterm,  %.2f Bterm" % (Aterm, Bterm))
+            print("Linear Calibration %.2f Aterm,  %.2f Bterm " % (Aterm, Bterm))
+        mz_domain = (Aterm / self.freq_exp_ms) + Bterm
+        self.recal_mass_spec(mz_domain, Aterm, Bterm, 0)
+
+    def quadratic(self, iteration: bool = False):
+        """Perform quadratic calibration.
+
+        Parameters
+        ----------
+        iteration : bool, optional
+            Flag to perform iterative calibration, by default False.
+
+        """
+        mz_calc = self.mz_calc
+        freq_exp = self.freq_exp
+        mz_exp = self.mz_exp
+
+        error = ((mz_exp - mz_calc) / mz_calc) * 1000000
+        last_rms = np.sqrt(np.mean(error**2))
+        while True:
+            matrix = np.vstack(
+                [1 / freq_exp, 1 / np.power(freq_exp, 2), np.ones(len(freq_exp))]
+            ).T
+            Aterm, Bterm, Cterm = np.linalg.lstsq(matrix, self.mz_calc, rcond=None)[0]
+            mz_exp = (Aterm / (freq_exp)) + (Bterm / np.power((freq_exp), 2)) + Cterm
+            error = ((mz_exp - mz_calc) / mz_calc) * 1000000
+            rms = np.sqrt(np.mean(error**2))
+            std = np.std(error)
+            if self.mass_spectrum.parameters.mass_spectrum.verbose_processing:
+                print("%.2f Aterm,  %.2f Bterm" % (Aterm, Bterm))
+                print(
+                    "Quadratic Calibration %.2f RMS,  %.2f std,  %.2f Aterm,  %.2f Bterm "
+                    % (rms, std, Aterm, Bterm)
+                )
+            if rms < last_rms:
+                last_rms = rms
+                freq_exp = (
+                    Aterm
+                    + np.sqrt(np.power(-Aterm, 2) - (4 * Cterm * (mz_exp - Bterm)))
+                ) / (2 * mz_exp)
+
+                mz_domain = (
+                    (Aterm / (self.freq_exp_ms))
+                    + (Bterm / np.power((self.freq_exp_ms), 2))
+                    + Cterm
+                )
+                self.recal_mass_spec(mz_domain, Aterm, Bterm, Cterm)
+                if not iteration:
+                    break
+            else:
+                break
+
+    def ledford_calibration(self, iteration: bool = False):
+        """Perform Ledford calibration.
+
+        Parameters
+        ----------
+        iteration : bool, optional
+            Flag to perform iterative calibration, by default False.
+
+        """
+        mz_calc = self.mz_calc
+        freq_exp = self.freq_exp
+        mz_exp = self.mz_exp
+
+        error = ((mz_exp - self.mz_calc) / self.mz_calc) * 1000000
+        last_rms = np.sqrt(np.mean(error**2))
+        while True:
+            matrix = np.vstack([1 / freq_exp, 1 / np.power(freq_exp, 2)]).T
+            Aterm, Bterm = np.linalg.lstsq(matrix, self.mz_calc, rcond=None)[0]
+
+            mz_exp = (Aterm / (freq_exp)) + (Bterm / np.power((freq_exp), 2))
+            error = ((mz_exp - mz_calc) / mz_calc) * 1000000
+            rms = np.sqrt(np.mean(error**2))
+            std = np.std(error)
+            if self.mass_spectrum.parameters.mass_spectrum.verbose_processing:
+                print("%.2f Aterm,  %.2f Bterm" % (Aterm, Bterm))
+                print(
+                    "Ledford Calibration %.2f RMS,  %.2f std,  %.2f Aterm,  %.2f Bterm "
+                    % (rms, std, Aterm, Bterm)
+                )
+            if rms < last_rms:
+                last_rms = rms
+                freq_exp = (
+                    Aterm + np.sqrt(np.power(-Aterm, 2) - (4 * mz_exp - Bterm))
+                ) / (2 * mz_exp)
+                mz_domain = (Aterm / (self.freq_exp_ms)) + (
+                    Bterm / np.power((self.freq_exp_ms), 2)
+                )
+                self.recal_mass_spec(mz_domain, Aterm, Bterm, 0)
+                if not iteration:
+                    break
+            else:
+                break
+
+    def step_fit(self, steps: int = 4):
+        """Perform step fit calibration.
+
+        Parameters
+        ----------
+        steps : int, optional
+            Number of steps for step fit calibration, by default 4.
+
+        """
+
+        def f_to_mz(f, A, B, C, a):
+            return (A / f) + (B / np.power(f, 2)) + (C * a / np.power(f, 2))
+
+        def mz_to_f(m, A, B, C):
+            return -A - m / B
+
+        tuple_indexes = [
+            (i, i + steps) for i in range(0, len(self.selected_mspeaks) - steps, steps)
+        ]
+
+        for current_index, tuple_index in enumerate(tuple_indexes):
+            mspeak_ii, mspeak_fi = tuple_index
+            freq_exp = list()
+            mz_calc = list()
+            mz_exp = list()
+            abu = list()
+
+            for i in range(mspeak_ii, mspeak_fi + 1):
+                best_formula = self.selected_mspeaks[i].best_molecular_formula_candidate
+
+                freq_exp.append(self.selected_mspeaks[i].freq_exp)
+                mz_calc.append(best_formula.mz_calc)
+                mz_exp.append(self.selected_mspeaks[i].mz_exp)
+                abu.append(self.selected_mspeaks[i].abundance)
+
+            freq_exp = np.array(freq_exp)
+            mz_calc = np.array(mz_calc)
+            mz_exp = np.array(mz_exp)
+            abu = np.array(abu)
+
+            if current_index == len(tuple_indexes) - 1:
+                ms_peaks_indexes = (self.selected_mspeaks[mspeak_ii].index, 0)
+
+            elif current_index == 0:
+                ms_peaks_indexes = (
+                    len(self.mass_spectrum) - 1,
+                    self.selected_mspeaks[mspeak_fi].index - 1,
+                )
+            else:
+                ms_peaks_indexes = (
+                    self.selected_mspeaks[mspeak_ii].index,
+                    self.selected_mspeaks[mspeak_fi].index - 1,
+                )
+
+            final_index, start_index = ms_peaks_indexes
+
+            matrix = np.vstack([1 / freq_exp, 1 / np.power(freq_exp, 2)]).T
+            A, B = np.linalg.lstsq(matrix, mz_calc, rcond=None)[0]
+            C = 0
+
+            for mspeak in self.mass_spectrum[start_index:final_index]:
+                mspeak.mz_cal = f_to_mz(mspeak.freq_exp, A, B, C, 0)
+
+        self.mass_spectrum.is_calibrated = True

corems/mass_spectrum/calc/KendrickGroup.py

@@ -0,0 +1,239 @@
+class KendrickGrouping:
+    """Class for Kendrick grouping of mass spectra.
+
+    Methods
+    -------
+    * mz_odd_even_index_lists().
+        Get odd and even indexes lists.
+    * calc_error(current, test).
+        Calculate the error between two values.
+    * populate_kendrick_index_dict_error(list_indexes, sort=True).
+        Populate the Kendrick index dictionary based on error.
+    * populate_kendrick_index_dict_rounding(list_indexes, sort=True).
+        Populate the Kendrick index dictionary based on rounding.
+    * sort_abundance_kendrick_dict(even_kendrick_group_index, odd_kendrick_group_index).
+        Sort the Kendrick index dictionary based on abundance.
+    * kendrick_groups_indexes(sort=True).
+        Get the Kendrick groups indexes dictionary.
+
+    """
+
+    def mz_odd_even_index_lists(self):
+        """Get odd and even indexes lists.
+
+        Returns
+        -------
+        tuple
+            A tuple containing the lists of even and odd indexes.
+
+        """
+        even_idx = []
+        odd_idx = []
+
+        for i, mspeak in enumerate(self.mspeaks):
+            if mspeak.nominal_mz_exp % 2 == 0:
+                even_idx.append(i)
+            else:
+                odd_idx.append(i)
+
+        return even_idx, odd_idx
+
+    def calc_error(self, current: float, test: float):
+        """Calculate the error between two values.
+
+        Parameters
+        ----------
+        current : float
+            The current value.
+        test : float
+            The test value.
+
+        Returns
+        -------
+        float
+            The calculated error.
+
+        """
+        return ((test - current) / current) * 1e6
+
+    def populate_kendrick_index_dict_error(self, list_indexes: list, sort: bool = True):
+        """Populate the Kendrick index dictionary based on error.
+
+        Parameters
+        ----------
+        list_indexes : list
+            The list of indexes.
+        sort : bool, optional
+            Whether to sort the dictionary by abundance (default is True).
+
+        Returns
+        -------
+        dict
+            The Kendrick index dictionary.
+
+        """
+
+        def error():
+            return abs(current_kmd_reference - next_mspeak.kmd)
+
+        already_found = []
+
+        all_results = []
+
+        for i in list_indexes:
+            result_indexes = []
+
+            mspeak = self.mspeaks[i]
+
+            current_kmd_reference = mspeak.kmd
+
+            for j in list_indexes:
+                if j not in already_found and j != i:
+                    next_mspeak = self.mspeaks[j]
+
+                    if error() <= 0.001:
+                        result_indexes.append(j)
+                        already_found.append(j)
+
+                        current_kmd_reference = next_mspeak.kmd
+
+            if result_indexes and len(result_indexes) > 3:
+                already_found.append(i)
+
+                result_indexes.insert(0, i)
+
+                all_results.append(result_indexes)
+            else:
+                for w in result_indexes:
+                    already_found.remove(w)
+
+        kendrick_group_index = {
+            i: indexes_list for i, indexes_list in enumerate(all_results)
+        }
+
+        # return dictionary with the keys sorted by sum of the abundances
+        if sort:
+            return dict(
+                sorted(
+                    kendrick_group_index.items(),
+                    key=lambda it: sum([self.mspeaks[i].abundance for i in it[1]]),
+                    reverse=False,
+                )
+            )
+
+        else:
+            return kendrick_group_index
+
+    def populate_kendrick_index_dict_rounding(
+        self, list_indexes: list, sort: bool = True
+    ):
+        """Populate the Kendrick index dictionary based on rounding.
+
+        Parameters
+        ----------
+        list_indexes : list
+            The list of indexes.
+        sort : bool, optional
+            Whether to sort the dictionary by abundance (default is True).
+
+        Returns
+        -------
+        dict
+            The Kendrick index dictionary.
+
+        """
+        kendrick_group_index = {}
+
+        for i in list_indexes:
+            mspeak = self.mspeaks[i]
+
+            group = round(mspeak.kmd * 100)
+
+            if group not in kendrick_group_index:
+                kendrick_group_index[group] = [i]
+
+            else:
+                last_index = kendrick_group_index[group][-1]
+
+                if self.parameters.mass_spectrum.verbose_processing:
+                    print(abs(mspeak.kmd - self.mspeaks[last_index].kmd))
+
+                if abs(mspeak.kmd - self.mspeaks[last_index].kmd) < 0.001:
+                    kendrick_group_index[group].append(i)
+
+            # return dictionary with the keys sorted by sum of the abundances
+        if sort:
+            return dict(
+                sorted(
+                    kendrick_group_index.items(),
+                    key=lambda it: sum([self.mspeaks[i].abundance for i in it[1]]),
+                    reverse=True,
+                )
+            )
+
+        else:
+            return kendrick_group_index
+
+    def sort_abundance_kendrick_dict(
+        self, even_kendrick_group_index: dict, odd_kendrick_group_index: dict
+    ):
+        """Sort the Kendrick index dictionary based on abundance.
+
+        Parameters
+        ----------
+        even_kendrick_group_index : dict
+            The Kendrick index dictionary for even indexes.
+        odd_kendrick_group_index : dict
+            The Kendrick index dictionary for odd indexes.
+
+        Returns
+        -------
+        dict
+            The sorted Kendrick index dictionary.
+
+        """
+        all_even_indexes = [i for v in even_kendrick_group_index.values() for i in v]
+
+        all_odd_indexes = [i for v in odd_kendrick_group_index.values() for i in v]
+
+        sum_even = sum([self.mspeaks[i].abundance for i in all_even_indexes])
+
+        sum_odd = sum([self.mspeaks[i].abundance for i in all_odd_indexes])
+
+        if sum_even >= sum_odd:
+            even_kendrick_group_index.update(odd_kendrick_group_index)
+
+            return even_kendrick_group_index
+
+        else:
+            odd_kendrick_group_index.update(even_kendrick_group_index)
+
+            return odd_kendrick_group_index
+
+    def kendrick_groups_indexes(self, sort: bool = True):
+        """Get the Kendrick groups indexes dictionary.
+
+        Parameters
+        ----------
+        sort : bool, optional
+            Whether to sort the dictionary by abundance (default is True).
+
+        Returns
+        -------
+        dict
+            The Kendrick groups indexes dictionary.
+
+        """
+        even_idx, odd_idx = self.mz_odd_even_index_lists()
+
+        even_kendrick_group_index = self.populate_kendrick_index_dict_error(
+            even_idx, sort=sort
+        )
+
+        odd_kendrick_group_index = self.populate_kendrick_index_dict_error(
+            odd_idx, sort=sort
+        )
+
+        return self.sort_abundance_kendrick_dict(
+            even_kendrick_group_index, odd_kendrick_group_index
+        )