corems.mass_spectrum.calc.KendrickGroup

  1class KendrickGrouping:
  2    """Class for Kendrick grouping of mass spectra.
  3
  4    Methods
  5    -------
  6    * mz_odd_even_index_lists().
  7        Get odd and even indexes lists.
  8    * calc_error(current, test).
  9        Calculate the error between two values.
 10    * populate_kendrick_index_dict_error(list_indexes, sort=True).
 11        Populate the Kendrick index dictionary based on error.
 12    * populate_kendrick_index_dict_rounding(list_indexes, sort=True).
 13        Populate the Kendrick index dictionary based on rounding.
 14    * sort_abundance_kendrick_dict(even_kendrick_group_index, odd_kendrick_group_index).
 15        Sort the Kendrick index dictionary based on abundance.
 16    * kendrick_groups_indexes(sort=True).
 17        Get the Kendrick groups indexes dictionary.
 18
 19    """
 20
 21    def mz_odd_even_index_lists(self):
 22        """Get odd and even indexes lists.
 23
 24        Returns
 25        -------
 26        tuple
 27            A tuple containing the lists of even and odd indexes.
 28
 29        """
 30        even_idx = []
 31        odd_idx = []
 32
 33        for i, mspeak in enumerate(self.mspeaks):
 34            if mspeak.nominal_mz_exp % 2 == 0:
 35                even_idx.append(i)
 36            else:
 37                odd_idx.append(i)
 38
 39        return even_idx, odd_idx
 40
 41    def calc_error(self, current: float, test: float):
 42        """Calculate the error between two values.
 43
 44        Parameters
 45        ----------
 46        current : float
 47            The current value.
 48        test : float
 49            The test value.
 50
 51        Returns
 52        -------
 53        float
 54            The calculated error.
 55
 56        """
 57        return ((test - current) / current) * 1e6
 58
 59    def populate_kendrick_index_dict_error(self, list_indexes: list, sort: bool = True):
 60        """Populate the Kendrick index dictionary based on error.
 61
 62        Parameters
 63        ----------
 64        list_indexes : list
 65            The list of indexes.
 66        sort : bool, optional
 67            Whether to sort the dictionary by abundance (default is True).
 68
 69        Returns
 70        -------
 71        dict
 72            The Kendrick index dictionary.
 73
 74        """
 75
 76        def error():
 77            return abs(current_kmd_reference - next_mspeak.kmd)
 78
 79        already_found = []
 80
 81        all_results = []
 82
 83        for i in list_indexes:
 84            result_indexes = []
 85
 86            mspeak = self.mspeaks[i]
 87
 88            current_kmd_reference = mspeak.kmd
 89
 90            for j in list_indexes:
 91                if j not in already_found and j != i:
 92                    next_mspeak = self.mspeaks[j]
 93
 94                    if error() <= 0.001:
 95                        result_indexes.append(j)
 96                        already_found.append(j)
 97
 98                        current_kmd_reference = next_mspeak.kmd
 99
100            if result_indexes and len(result_indexes) > 3:
101                already_found.append(i)
102
103                result_indexes.insert(0, i)
104
105                all_results.append(result_indexes)
106            else:
107                for w in result_indexes:
108                    already_found.remove(w)
109
110        kendrick_group_index = {
111            i: indexes_list for i, indexes_list in enumerate(all_results)
112        }
113
114        # return dictionary with the keys sorted by sum of the abundances
115        if sort:
116            return dict(
117                sorted(
118                    kendrick_group_index.items(),
119                    key=lambda it: sum([self.mspeaks[i].abundance for i in it[1]]),
120                    reverse=False,
121                )
122            )
123
124        else:
125            return kendrick_group_index
126
127    def populate_kendrick_index_dict_rounding(
128        self, list_indexes: list, sort: bool = True
129    ):
130        """Populate the Kendrick index dictionary based on rounding.
131
132        Parameters
133        ----------
134        list_indexes : list
135            The list of indexes.
136        sort : bool, optional
137            Whether to sort the dictionary by abundance (default is True).
138
139        Returns
140        -------
141        dict
142            The Kendrick index dictionary.
143
144        """
145        kendrick_group_index = {}
146
147        for i in list_indexes:
148            mspeak = self.mspeaks[i]
149
150            group = round(mspeak.kmd * 100)
151
152            if group not in kendrick_group_index:
153                kendrick_group_index[group] = [i]
154
155            else:
156                last_index = kendrick_group_index[group][-1]
157
158                if self.parameters.mass_spectrum.verbose_processing:
159                    print(abs(mspeak.kmd - self.mspeaks[last_index].kmd))
160
161                if abs(mspeak.kmd - self.mspeaks[last_index].kmd) < 0.001:
162                    kendrick_group_index[group].append(i)
163
164            # return dictionary with the keys sorted by sum of the abundances
165        if sort:
166            return dict(
167                sorted(
168                    kendrick_group_index.items(),
169                    key=lambda it: sum([self.mspeaks[i].abundance for i in it[1]]),
170                    reverse=True,
171                )
172            )
173
174        else:
175            return kendrick_group_index
176
177    def sort_abundance_kendrick_dict(
178        self, even_kendrick_group_index: dict, odd_kendrick_group_index: dict
179    ):
180        """Sort the Kendrick index dictionary based on abundance.
181
182        Parameters
183        ----------
184        even_kendrick_group_index : dict
185            The Kendrick index dictionary for even indexes.
186        odd_kendrick_group_index : dict
187            The Kendrick index dictionary for odd indexes.
188
189        Returns
190        -------
191        dict
192            The sorted Kendrick index dictionary.
193
194        """
195        all_even_indexes = [i for v in even_kendrick_group_index.values() for i in v]
196
197        all_odd_indexes = [i for v in odd_kendrick_group_index.values() for i in v]
198
199        sum_even = sum([self.mspeaks[i].abundance for i in all_even_indexes])
200
201        sum_odd = sum([self.mspeaks[i].abundance for i in all_odd_indexes])
202
203        if sum_even >= sum_odd:
204            even_kendrick_group_index.update(odd_kendrick_group_index)
205
206            return even_kendrick_group_index
207
208        else:
209            odd_kendrick_group_index.update(even_kendrick_group_index)
210
211            return odd_kendrick_group_index
212
213    def kendrick_groups_indexes(self, sort: bool = True):
214        """Get the Kendrick groups indexes dictionary.
215
216        Parameters
217        ----------
218        sort : bool, optional
219            Whether to sort the dictionary by abundance (default is True).
220
221        Returns
222        -------
223        dict
224            The Kendrick groups indexes dictionary.
225
226        """
227        even_idx, odd_idx = self.mz_odd_even_index_lists()
228
229        even_kendrick_group_index = self.populate_kendrick_index_dict_error(
230            even_idx, sort=sort
231        )
232
233        odd_kendrick_group_index = self.populate_kendrick_index_dict_error(
234            odd_idx, sort=sort
235        )
236
237        return self.sort_abundance_kendrick_dict(
238            even_kendrick_group_index, odd_kendrick_group_index
239        )