corems.mass_spectrum.factory.MassSpectrumClasses

   1from pathlib import Path
   2
   3import numpy as np
   4from lmfit.models import GaussianModel
   5
   6# from matplotlib import rcParamsDefault, rcParams
   7from numpy import array, float64, histogram, trapz, where
   8from pandas import DataFrame
   9
  10from corems.encapsulation.constant import Labels
  11from corems.encapsulation.factory.parameters import MSParameters
  12from corems.encapsulation.input.parameter_from_json import (
  13    load_and_set_parameters_ms,
  14    load_and_set_toml_parameters_ms,
  15)
  16from corems.mass_spectrum.calc.KendrickGroup import KendrickGrouping
  17from corems.mass_spectrum.calc.MassSpectrumCalc import MassSpecCalc
  18from corems.mass_spectrum.calc.MeanResolvingPowerFilter import MeanResolvingPowerFilter
  19from corems.ms_peak.factory.MSPeakClasses import ICRMassPeak as MSPeak
  20
  21__author__ = "Yuri E. Corilo"
  22__date__ = "Jun 12, 2019"
  23
  24
  25def overrides(interface_class):
  26    """Checks if the method overrides a method from an interface class."""
  27
  28    def overrider(method):
  29        assert method.__name__ in dir(interface_class)
  30        return method
  31
  32    return overrider
  33
  34
  35class MassSpecBase(MassSpecCalc, KendrickGrouping):
  36    """A mass spectrum base class, stores the profile data and instrument settings.
  37
  38    Iteration over a list of MSPeaks classes stored at the _mspeaks attributes.
  39    _mspeaks is populated under the hood by calling process_mass_spec method.
  40    Iteration is null if _mspeaks is empty.
  41
  42    Parameters
  43    ----------
  44    mz_exp : array_like
  45        The m/z values of the mass spectrum.
  46    abundance : array_like
  47        The abundance values of the mass spectrum.
  48    d_params : dict
  49        A dictionary of parameters for the mass spectrum.
  50    **kwargs
  51        Additional keyword arguments.
  52
  53    Attributes
  54    ----------
  55
  56    mspeaks : list
  57        A list of mass peaks.
  58    is_calibrated : bool
  59        Whether the mass spectrum is calibrated.
  60    is_centroid : bool
  61        Whether the mass spectrum is centroided.
  62    has_frequency : bool
  63        Whether the mass spectrum has a frequency domain.
  64    calibration_order : None or int
  65        The order of the mass spectrum's calibration.
  66    calibration_points : None or ndarray
  67        The calibration points of the mass spectrum.
  68    calibration_ref_mzs: None or ndarray
  69        The reference m/z values of the mass spectrum's calibration.
  70    calibration_meas_mzs : None or ndarray
  71        The measured m/z values of the mass spectrum's calibration.
  72    calibration_RMS : None or float
  73        The root mean square of the mass spectrum's calibration.
  74    calibration_segment : None or CalibrationSegment
  75        The calibration segment of the mass spectrum.
  76    _abundance : ndarray
  77        The abundance values of the mass spectrum.
  78    _mz_exp : ndarray
  79        The m/z values of the mass spectrum.
  80    _mspeaks : list
  81        A list of mass peaks.
  82    _dict_nominal_masses_indexes : dict
  83        A dictionary of nominal masses and their indexes.
  84    _baseline_noise : float
  85        The baseline noise of the mass spectrum.
  86    _baseline_noise_std : float
  87        The standard deviation of the baseline noise of the mass spectrum.
  88    _dynamic_range : float or None
  89        The dynamic range of the mass spectrum.
  90    _transient_settings : None or TransientSettings
  91        The transient settings of the mass spectrum.
  92    _frequency_domain : None or FrequencyDomain
  93        The frequency domain of the mass spectrum.
  94    _mz_cal_profile : None or MzCalibrationProfile
  95        The m/z calibration profile of the mass spectrum.
  96
  97    Methods
  98    -------
  99    * process_mass_spec(). Main function to process the mass spectrum,
 100    including calculating the noise threshold, peak picking, and resetting the MSpeak indexes.
 101
 102    See also: MassSpecCentroid(), MassSpecfromFreq(), MassSpecProfile()
 103    """
 104
 105    def __init__(self, mz_exp, abundance, d_params, **kwargs):
 106        self._abundance = array(abundance, dtype=float64)
 107        self._mz_exp = array(mz_exp, dtype=float64)
 108
 109        # objects created after process_mass_spec() function
 110        self._mspeaks = list()
 111        self.mspeaks = list()
 112        self._dict_nominal_masses_indexes = dict()
 113        self._baseline_noise = 0.001
 114        self._baseline_noise_std = 0.001
 115        self._dynamic_range = None
 116        # set to None: initialization occurs inside subclass MassSpecfromFreq
 117        self._transient_settings = None
 118        self._frequency_domain = None
 119        self._mz_cal_profile = None
 120        self.is_calibrated = False
 121
 122        self._set_parameters_objects(d_params)
 123        self._init_settings()
 124
 125        self.is_centroid = False
 126        self.has_frequency = False
 127
 128        self.calibration_order = None
 129        self.calibration_points = None
 130        self.calibration_ref_mzs = None
 131        self.calibration_meas_mzs = None
 132        self.calibration_RMS = None
 133        self.calibration_segment = None
 134        self.calibration_raw_error_median = None
 135        self.calibration_raw_error_stdev = None
 136
 137    def _init_settings(self):
 138        """Initializes the settings for the mass spectrum."""
 139        self._parameters = MSParameters()
 140
 141    def __len__(self):
 142        return len(self.mspeaks)
 143
 144    def __getitem__(self, position) -> MSPeak:
 145        return self.mspeaks[position]
 146
 147    def set_indexes(self, list_indexes):
 148        """Set the mass spectrum to iterate over only the selected MSpeaks indexes.
 149
 150        Parameters
 151        ----------
 152        list_indexes : list of int
 153            A list of integers representing the indexes of the MSpeaks to iterate over.
 154
 155        """
 156        self.mspeaks = [self._mspeaks[i] for i in list_indexes]
 157
 158        for i, mspeak in enumerate(self.mspeaks):
 159            mspeak.index = i
 160
 161        self._set_nominal_masses_start_final_indexes()
 162
 163    def reset_indexes(self):
 164        """Reset the mass spectrum to iterate over all MSpeaks objects.
 165
 166        This method resets the mass spectrum to its original state, allowing iteration over all MSpeaks objects.
 167        It also sets the index of each MSpeak object to its corresponding position in the mass spectrum.
 168
 169        """
 170        self.mspeaks = self._mspeaks
 171
 172        for i, mspeak in enumerate(self.mspeaks):
 173            mspeak.index = i
 174
 175        self._set_nominal_masses_start_final_indexes()
 176
 177    def add_mspeak(
 178        self,
 179        ion_charge,
 180        mz_exp,
 181        abundance,
 182        resolving_power,
 183        signal_to_noise,
 184        massspec_indexes,
 185        exp_freq=None,
 186        ms_parent=None,
 187    ):
 188        """Add a new MSPeak object to the MassSpectrum object.
 189
 190        Parameters
 191        ----------
 192        ion_charge : int
 193            The ion charge of the MSPeak.
 194        mz_exp : float
 195            The experimental m/z value of the MSPeak.
 196        abundance : float
 197            The abundance of the MSPeak.
 198        resolving_power : float
 199            The resolving power of the MSPeak.
 200        signal_to_noise : float
 201            The signal-to-noise ratio of the MSPeak.
 202        massspec_indexes : list
 203            A list of indexes of the MSPeak in the MassSpectrum object.
 204        exp_freq : float, optional
 205            The experimental frequency of the MSPeak. Defaults to None.
 206        ms_parent : MSParent, optional
 207            The MSParent object associated with the MSPeak. Defaults to None.
 208        """
 209        mspeak = MSPeak(
 210            ion_charge,
 211            mz_exp,
 212            abundance,
 213            resolving_power,
 214            signal_to_noise,
 215            massspec_indexes,
 216            len(self._mspeaks),
 217            exp_freq=exp_freq,
 218            ms_parent=ms_parent,
 219        )
 220
 221        self._mspeaks.append(mspeak)
 222
 223    def _set_parameters_objects(self, d_params):
 224        """Set the parameters of the MassSpectrum object.
 225
 226        Parameters
 227        ----------
 228        d_params : dict
 229            A dictionary containing the parameters to set.
 230
 231        Notes
 232        -----
 233        This method sets the following parameters of the MassSpectrum object:
 234        - _calibration_terms
 235        - label
 236        - analyzer
 237        - acquisition_time
 238        - instrument_label
 239        - polarity
 240        - scan_number
 241        - retention_time
 242        - mobility_rt
 243        - mobility_scan
 244        - _filename
 245        - _dir_location
 246        - _baseline_noise
 247        - _baseline_noise_std
 248        - sample_name
 249        """
 250        self._calibration_terms = (
 251            d_params.get("Aterm"),
 252            d_params.get("Bterm"),
 253            d_params.get("Cterm"),
 254        )
 255
 256        self.label = d_params.get(Labels.label)
 257
 258        self.analyzer = d_params.get("analyzer")
 259
 260        self.acquisition_time = d_params.get("acquisition_time")
 261
 262        self.instrument_label = d_params.get("instrument_label")
 263
 264        self.polarity = int(d_params.get("polarity"))
 265
 266        self.scan_number = d_params.get("scan_number")
 267
 268        self.retention_time = d_params.get("rt")
 269
 270        self.mobility_rt = d_params.get("mobility_rt")
 271
 272        self.mobility_scan = d_params.get("mobility_scan")
 273
 274        self._filename = d_params.get("filename_path")
 275
 276        self._dir_location = d_params.get("dir_location")
 277
 278        self._baseline_noise = d_params.get("baseline_noise")
 279
 280        self._baseline_noise_std = d_params.get("baseline_noise_std")
 281
 282        if d_params.get("sample_name") != "Unknown":
 283            self.sample_name = d_params.get("sample_name")
 284            if not self.sample_name:
 285                self.sample_name = self.filename.stem
 286        else:
 287            self.sample_name = self.filename.stem
 288
 289    def reset_cal_therms(self, Aterm, Bterm, C, fas=0):
 290        """Reset calibration terms and recalculate the mass-to-charge ratio and abundance.
 291
 292        Parameters
 293        ----------
 294        Aterm : float
 295            The A-term calibration coefficient.
 296        Bterm : float
 297            The B-term calibration coefficient.
 298        C : float
 299            The C-term calibration coefficient.
 300        fas : float, optional
 301            The frequency amplitude scaling factor. Default is 0.
 302        """
 303        self._calibration_terms = (Aterm, Bterm, C)
 304
 305        self._mz_exp = self._f_to_mz()
 306        self._abundance = self._abundance
 307        self.find_peaks()
 308        self.reset_indexes()
 309
 310    def clear_molecular_formulas(self):
 311        """Clear the molecular formulas for all mspeaks in the MassSpectrum.
 312
 313        Returns
 314        -------
 315        numpy.ndarray
 316            An array of the cleared molecular formulas for each mspeak in the MassSpectrum.
 317        """
 318        self.check_mspeaks()
 319        return array([mspeak.clear_molecular_formulas() for mspeak in self.mspeaks])
 320
 321    def process_mass_spec(self, keep_profile=True):
 322        """Process the mass spectrum.
 323
 324        Parameters
 325        ----------
 326        keep_profile : bool, optional
 327            Whether to keep the profile data after processing. Defaults to True.
 328
 329        Notes
 330        -----
 331        This method does the following:
 332        - calculates the noise threshold
 333        - does peak picking (creates mspeak_objs)
 334        - resets the mspeak_obj indexes
 335        """
 336
 337        # if runned mannually make sure to rerun filter_by_noise_threshold
 338        # calculates noise threshold
 339        # do peak picking( create mspeak_objs)
 340        # reset mspeak_obj the indexes
 341
 342        self.cal_noise_threshold()
 343
 344        self.find_peaks()
 345        self.reset_indexes()
 346
 347        if self.mspeaks:
 348            self._dynamic_range = self.max_abundance / self.min_abundance
 349        else:
 350            self._dynamic_range = 0
 351        if not keep_profile:
 352            self._abundance *= 0
 353            self._mz_exp *= 0
 354
 355    def cal_noise_threshold(self):
 356        """Calculate the noise threshold of the mass spectrum."""
 357
 358        if self.label == Labels.simulated_profile:
 359            self._baseline_noise, self._baseline_noise_std = 0.1, 1
 360
 361        if self.settings.noise_threshold_method == "log":
 362            self._baseline_noise, self._baseline_noise_std = (
 363                self.run_log_noise_threshold_calc()
 364            )
 365
 366        else:
 367            self._baseline_noise, self._baseline_noise_std = (
 368                self.run_noise_threshold_calc()
 369            )
 370
 371    @property
 372    def parameters(self):
 373        """Return the parameters of the mass spectrum."""
 374        return self._parameters
 375
 376    @parameters.setter
 377    def parameters(self, instance_MSParameters):
 378        self._parameters = instance_MSParameters
 379
 380    def set_parameter_from_json(self, parameters_path):
 381        """Set the parameters of the mass spectrum from a JSON file.
 382
 383        Parameters
 384        ----------
 385        parameters_path : str
 386            The path to the JSON file containing the parameters.
 387        """
 388        load_and_set_parameters_ms(self, parameters_path=parameters_path)
 389
 390    def set_parameter_from_toml(self, parameters_path):
 391        load_and_set_toml_parameters_ms(self, parameters_path=parameters_path)
 392
 393    @property
 394    def mspeaks_settings(self):
 395        """Return the MS peak settings of the mass spectrum."""
 396        return self.parameters.ms_peak
 397
 398    @mspeaks_settings.setter
 399    def mspeaks_settings(self, instance_MassSpecPeakSetting):
 400        self.parameters.ms_peak = instance_MassSpecPeakSetting
 401
 402    @property
 403    def settings(self):
 404        """Return the settings of the mass spectrum."""
 405        return self.parameters.mass_spectrum
 406
 407    @settings.setter
 408    def settings(self, instance_MassSpectrumSetting):
 409        self.parameters.mass_spectrum = instance_MassSpectrumSetting
 410
 411    @property
 412    def molecular_search_settings(self):
 413        """Return the molecular search settings of the mass spectrum."""
 414        return self.parameters.molecular_search
 415
 416    @molecular_search_settings.setter
 417    def molecular_search_settings(self, instance_MolecularFormulaSearchSettings):
 418        self.parameters.molecular_search = instance_MolecularFormulaSearchSettings
 419
 420    @property
 421    def mz_cal_profile(self):
 422        """Return the calibrated m/z profile of the mass spectrum."""
 423        return self._mz_cal_profile
 424
 425    @mz_cal_profile.setter
 426    def mz_cal_profile(self, mz_cal_list):
 427        if len(mz_cal_list) == len(self._mz_exp):
 428            self._mz_cal_profile = mz_cal_list
 429        else:
 430            raise Exception(
 431                "calibrated array (%i) is not of the same size of the data (%i)"
 432                % (len(mz_cal_list), len(self.mz_exp_profile))
 433            )
 434
 435    @property
 436    def mz_cal(self):
 437        """Return the calibrated m/z values of the mass spectrum."""
 438        return array([mspeak.mz_cal for mspeak in self.mspeaks])
 439
 440    @mz_cal.setter
 441    def mz_cal(self, mz_cal_list):
 442        if len(mz_cal_list) == len(self.mspeaks):
 443            self.is_calibrated = True
 444            for index, mz_cal in enumerate(mz_cal_list):
 445                self.mspeaks[index].mz_cal = mz_cal
 446        else:
 447            raise Exception(
 448                "calibrated array (%i) is not of the same size of the data (%i)"
 449                % (len(mz_cal_list), len(self._mspeaks))
 450            )
 451
 452    @property
 453    def mz_exp(self):
 454        """Return the experimental m/z values of the mass spectrum."""
 455        self.check_mspeaks()
 456
 457        if self.is_calibrated:
 458            return array([mspeak.mz_cal for mspeak in self.mspeaks])
 459
 460        else:
 461            return array([mspeak.mz_exp for mspeak in self.mspeaks])
 462
 463    @property
 464    def freq_exp_profile(self):
 465        """Return the experimental frequency profile of the mass spectrum."""
 466        return self._frequency_domain
 467
 468    @freq_exp_profile.setter
 469    def freq_exp_profile(self, new_data):
 470        self._frequency_domain = array(new_data)
 471
 472    @property
 473    def freq_exp_pp(self):
 474        """Return the experimental frequency values of the mass spectrum that are used for peak picking."""
 475        _, _, freq = self.prepare_peak_picking_data()
 476        return freq
 477
 478    @property
 479    def mz_exp_profile(self):
 480        """Return the experimental m/z profile of the mass spectrum."""
 481        if self.is_calibrated:
 482            return self.mz_cal_profile
 483        else:
 484            return self._mz_exp
 485
 486    @mz_exp_profile.setter
 487    def mz_exp_profile(self, new_data):
 488        self._mz_exp = array(new_data)
 489
 490    @property
 491    def mz_exp_pp(self):
 492        """Return the experimental m/z values of the mass spectrum that are used for peak picking."""
 493        mz, _, _ = self.prepare_peak_picking_data()
 494        return mz
 495
 496    @property
 497    def abundance_profile(self):
 498        """Return the abundance profile of the mass spectrum."""
 499        return self._abundance
 500
 501    @abundance_profile.setter
 502    def abundance_profile(self, new_data):
 503        self._abundance = array(new_data)
 504
 505    @property
 506    def abundance_profile_pp(self):
 507        """Return the abundance profile of the mass spectrum that is used for peak picking."""
 508        _, abundance, _ = self.prepare_peak_picking_data()
 509        return abundance
 510
 511    @property
 512    def abundance(self):
 513        """Return the abundance values of the mass spectrum."""
 514        self.check_mspeaks()
 515        return array([mspeak.abundance for mspeak in self.mspeaks])
 516
 517    def freq_exp(self):
 518        """Return the experimental frequency values of the mass spectrum."""
 519        self.check_mspeaks()
 520        return array([mspeak.freq_exp for mspeak in self.mspeaks])
 521
 522    @property
 523    def resolving_power(self):
 524        """Return the resolving power values of the mass spectrum."""
 525        self.check_mspeaks()
 526        return array([mspeak.resolving_power for mspeak in self.mspeaks])
 527
 528    @property
 529    def signal_to_noise(self):
 530        self.check_mspeaks()
 531        return array([mspeak.signal_to_noise for mspeak in self.mspeaks])
 532
 533    @property
 534    def nominal_mz(self):
 535        """Return the nominal m/z values of the mass spectrum."""
 536        if self._dict_nominal_masses_indexes:
 537            return sorted(list(self._dict_nominal_masses_indexes.keys()))
 538        else:
 539            raise ValueError("Nominal indexes not yet set")
 540
 541    def get_mz_and_abundance_peaks_tuples(self):
 542        """Return a list of tuples containing the m/z and abundance values of the mass spectrum."""
 543        self.check_mspeaks()
 544        return [(mspeak.mz_exp, mspeak.abundance) for mspeak in self.mspeaks]
 545
 546    @property
 547    def kmd(self):
 548        """Return the Kendrick mass defect values of the mass spectrum."""
 549        self.check_mspeaks()
 550        return array([mspeak.kmd for mspeak in self.mspeaks])
 551
 552    @property
 553    def kendrick_mass(self):
 554        """Return the Kendrick mass values of the mass spectrum."""
 555        self.check_mspeaks()
 556        return array([mspeak.kendrick_mass for mspeak in self.mspeaks])
 557
 558    @property
 559    def max_mz_exp(self):
 560        """Return the maximum experimental m/z value of the mass spectrum."""
 561        return max([mspeak.mz_exp for mspeak in self.mspeaks])
 562
 563    @property
 564    def min_mz_exp(self):
 565        """Return the minimum experimental m/z value of the mass spectrum."""
 566        return min([mspeak.mz_exp for mspeak in self.mspeaks])
 567
 568    @property
 569    def max_abundance(self):
 570        """Return the maximum abundance value of the mass spectrum."""
 571        return max([mspeak.abundance for mspeak in self.mspeaks])
 572
 573    @property
 574    def max_signal_to_noise(self):
 575        """Return the maximum signal-to-noise ratio of the mass spectrum."""
 576        return max([mspeak.signal_to_noise for mspeak in self.mspeaks])
 577
 578    @property
 579    def most_abundant_mspeak(self):
 580        """Return the most abundant MSpeak object of the mass spectrum."""
 581        return max(self.mspeaks, key=lambda m: m.abundance)
 582
 583    @property
 584    def min_abundance(self):
 585        """Return the minimum abundance value of the mass spectrum."""
 586        return min([mspeak.abundance for mspeak in self.mspeaks])
 587
 588    # takes too much cpu time
 589    @property
 590    def dynamic_range(self):
 591        """Return the dynamic range of the mass spectrum."""
 592        return self._dynamic_range
 593
 594    @property
 595    def baseline_noise(self):
 596        """Return the baseline noise of the mass spectrum."""
 597        if self._baseline_noise:
 598            return self._baseline_noise
 599        else:
 600            return None
 601
 602    @property
 603    def baseline_noise_std(self):
 604        """Return the standard deviation of the baseline noise of the mass spectrum."""
 605        if self._baseline_noise_std == 0:
 606            return self._baseline_noise_std
 607        if self._baseline_noise_std:
 608            return self._baseline_noise_std
 609        else:
 610            return None
 611
 612    @property
 613    def Aterm(self):
 614        """Return the A-term calibration coefficient of the mass spectrum."""
 615        return self._calibration_terms[0]
 616
 617    @property
 618    def Bterm(self):
 619        """Return the B-term calibration coefficient of the mass spectrum."""
 620        return self._calibration_terms[1]
 621
 622    @property
 623    def Cterm(self):
 624        """Return the C-term calibration coefficient of the mass spectrum."""
 625        return self._calibration_terms[2]
 626
 627    @property
 628    def filename(self):
 629        """Return the filename of the mass spectrum."""
 630        return Path(self._filename)
 631
 632    @property
 633    def dir_location(self):
 634        """Return the directory location of the mass spectrum."""
 635        return self._dir_location
 636
 637    def sort_by_mz(self):
 638        """Sort the mass spectrum by m/z values."""
 639        return sorted(self, key=lambda m: m.mz_exp)
 640
 641    def sort_by_abundance(self, reverse=False):
 642        """Sort the mass spectrum by abundance values."""
 643        return sorted(self, key=lambda m: m.abundance, reverse=reverse)
 644
 645    @property
 646    def tic(self):
 647        """Return the total ion current of the mass spectrum."""
 648        return trapz(self.abundance_profile, self.mz_exp_profile)
 649
 650    def check_mspeaks_warning(self):
 651        """Check if the mass spectrum has MSpeaks objects.
 652
 653        Raises
 654        ------
 655        Warning
 656            If the mass spectrum has no MSpeaks objects.
 657        """
 658        import warnings
 659
 660        if self.mspeaks:
 661            pass
 662        else:
 663            warnings.warn("mspeaks list is empty, continuing without filtering data")
 664
 665    def check_mspeaks(self):
 666        """Check if the mass spectrum has MSpeaks objects.
 667
 668        Raises
 669        ------
 670        Exception
 671            If the mass spectrum has no MSpeaks objects.
 672        """
 673        if self.mspeaks:
 674            pass
 675        else:
 676            raise Exception(
 677                "mspeaks list is empty, please run process_mass_spec() first"
 678            )
 679
 680    def remove_assignment_by_index(self, indexes):
 681        """Remove the molecular formula assignment of the MSpeaks objects at the specified indexes.
 682
 683        Parameters
 684        ----------
 685        indexes : list of int
 686            A list of indexes of the MSpeaks objects to remove the molecular formula assignment from.
 687        """
 688        for i in indexes:
 689            self.mspeaks[i].clear_molecular_formulas()
 690
 691    def filter_by_index(self, list_indexes):
 692        """Filter the mass spectrum by the specified indexes.
 693
 694        Parameters
 695        ----------
 696        list_indexes : list of int
 697            A list of indexes of the MSpeaks objects to drop.
 698
 699        """
 700
 701        self.mspeaks = [
 702            self.mspeaks[i] for i in range(len(self.mspeaks)) if i not in list_indexes
 703        ]
 704
 705        for i, mspeak in enumerate(self.mspeaks):
 706            mspeak.index = i
 707
 708        self._set_nominal_masses_start_final_indexes()
 709
 710    def filter_by_mz(self, min_mz, max_mz):
 711        """Filter the mass spectrum by the specified m/z range.
 712
 713        Parameters
 714        ----------
 715        min_mz : float
 716            The minimum m/z value to keep.
 717        max_mz : float
 718            The maximum m/z value to keep.
 719
 720        """
 721        self.check_mspeaks_warning()
 722        indexes = [
 723            index
 724            for index, mspeak in enumerate(self.mspeaks)
 725            if not min_mz <= mspeak.mz_exp <= max_mz
 726        ]
 727        self.filter_by_index(indexes)
 728
 729    def filter_by_s2n(self, min_s2n, max_s2n=False):
 730        """Filter the mass spectrum by the specified signal-to-noise ratio range.
 731
 732        Parameters
 733        ----------
 734        min_s2n : float
 735            The minimum signal-to-noise ratio to keep.
 736        max_s2n : float, optional
 737            The maximum signal-to-noise ratio to keep. Defaults to False (no maximum).
 738
 739        """
 740        self.check_mspeaks_warning()
 741        if max_s2n:
 742            indexes = [
 743                index
 744                for index, mspeak in enumerate(self.mspeaks)
 745                if not min_s2n <= mspeak.signal_to_noise <= max_s2n
 746            ]
 747        else:
 748            indexes = [
 749                index
 750                for index, mspeak in enumerate(self.mspeaks)
 751                if mspeak.signal_to_noise <= min_s2n
 752            ]
 753        self.filter_by_index(indexes)
 754
 755    def filter_by_abundance(self, min_abund, max_abund=False):
 756        """Filter the mass spectrum by the specified abundance range.
 757
 758        Parameters
 759        ----------
 760        min_abund : float
 761            The minimum abundance to keep.
 762        max_abund : float, optional
 763            The maximum abundance to keep. Defaults to False (no maximum).
 764
 765        """
 766        self.check_mspeaks_warning()
 767        if max_abund:
 768            indexes = [
 769                index
 770                for index, mspeak in enumerate(self.mspeaks)
 771                if not min_abund <= mspeak.abundance <= max_abund
 772            ]
 773        else:
 774            indexes = [
 775                index
 776                for index, mspeak in enumerate(self.mspeaks)
 777                if mspeak.abundance <= min_abund
 778            ]
 779        self.filter_by_index(indexes)
 780
 781    def filter_by_max_resolving_power(self, B, T):
 782        """Filter the mass spectrum by the specified maximum resolving power.
 783
 784        Parameters
 785        ----------
 786        B : float
 787        T : float
 788
 789        """
 790
 791        rpe = lambda m, z: (1.274e7 * z * B * T) / (m * z)
 792
 793        self.check_mspeaks_warning()
 794
 795        indexes_to_remove = [
 796            index
 797            for index, mspeak in enumerate(self.mspeaks)
 798            if mspeak.resolving_power >= rpe(mspeak.mz_exp, mspeak.ion_charge)
 799        ]
 800        self.filter_by_index(indexes_to_remove)
 801
 802    def filter_by_mean_resolving_power(
 803        self, ndeviations=3, plot=False, guess_pars=False
 804    ):
 805        """Filter the mass spectrum by the specified mean resolving power.
 806
 807        Parameters
 808        ----------
 809        ndeviations : float, optional
 810            The number of standard deviations to use for filtering. Defaults to 3.
 811        plot : bool, optional
 812            Whether to plot the resolving power distribution. Defaults to False.
 813        guess_pars : bool, optional
 814            Whether to guess the parameters for the Gaussian model. Defaults to False.
 815
 816        """
 817        self.check_mspeaks_warning()
 818        indexes_to_remove = MeanResolvingPowerFilter(
 819            self, ndeviations, plot, guess_pars
 820        ).main()
 821        self.filter_by_index(indexes_to_remove)
 822
 823    def filter_by_min_resolving_power(self, B, T):
 824        """Filter the mass spectrum by the specified minimum resolving power.
 825
 826        Parameters
 827        ----------
 828        B : float
 829        T : float
 830
 831        """
 832        rpe = lambda m, z: (1.274e7 * z * B * T) / (m * z)
 833
 834        self.check_mspeaks_warning()
 835
 836        indexes_to_remove = [
 837            index
 838            for index, mspeak in enumerate(self.mspeaks)
 839            if mspeak.resolving_power <= rpe(mspeak.mz_exp, mspeak.ion_charge)
 840        ]
 841        self.filter_by_index(indexes_to_remove)
 842
 843    def filter_by_noise_threshold(self):
 844        """Filter the mass spectrum by the noise threshold."""
 845
 846        threshold = self.get_noise_threshold()[1][0]
 847
 848        self.check_mspeaks_warning()
 849
 850        indexes_to_remove = [
 851            index
 852            for index, mspeak in enumerate(self.mspeaks)
 853            if mspeak.abundance <= threshold
 854        ]
 855        self.filter_by_index(indexes_to_remove)
 856
 857    def find_peaks(self):
 858        """Find the peaks of the mass spectrum."""
 859        # needs to clear previous results from peak_picking
 860        self._mspeaks = list()
 861
 862        # then do peak picking
 863        self.do_peak_picking()
 864        # print("A total of %i peaks were found" % len(self._mspeaks))
 865
 866    def change_kendrick_base_all_mspeaks(self, kendrick_dict_base):
 867        """Change the Kendrick base of all MSpeaks objects.
 868
 869        Parameters
 870        ----------
 871        kendrick_dict_base : dict
 872            A dictionary of the Kendrick base to change to.
 873
 874        Notes
 875        -----
 876        Example of kendrick_dict_base parameter: kendrick_dict_base = {"C": 1, "H": 2} or {"C": 1, "H": 1, "O":1} etc
 877        """
 878        self.parameters.ms_peak.kendrick_base = kendrick_dict_base
 879
 880        for mspeak in self.mspeaks:
 881            mspeak.change_kendrick_base(kendrick_dict_base)
 882
 883    def get_nominal_mz_first_last_indexes(self, nominal_mass):
 884        """Return the first and last indexes of the MSpeaks objects with the specified nominal mass.
 885
 886        Parameters
 887        ----------
 888        nominal_mass : int
 889            The nominal mass to get the indexes for.
 890
 891        Returns
 892        -------
 893        tuple
 894            A tuple containing the first and last indexes of the MSpeaks objects with the specified nominal mass.
 895        """
 896        if self._dict_nominal_masses_indexes:
 897            if nominal_mass in self._dict_nominal_masses_indexes.keys():
 898                return (
 899                    self._dict_nominal_masses_indexes.get(nominal_mass)[0],
 900                    self._dict_nominal_masses_indexes.get(nominal_mass)[1] + 1,
 901                )
 902
 903            else:
 904                # import warnings
 905                # uncomment warn to distribution
 906                # warnings.warn("Nominal mass not found in _dict_nominal_masses_indexes, returning (0, 0) for nominal mass %i"%nominal_mass)
 907                return (0, 0)
 908        else:
 909            raise Exception(
 910                "run process_mass_spec() function before trying to access the data"
 911            )
 912
 913    def get_masses_count_by_nominal_mass(self):
 914        """Return a dictionary of the nominal masses and their counts."""
 915
 916        dict_nominal_masses_count = {}
 917
 918        all_nominal_masses = list(set([i.nominal_mz_exp for i in self.mspeaks]))
 919
 920        for nominal_mass in all_nominal_masses:
 921            if nominal_mass not in dict_nominal_masses_count:
 922                dict_nominal_masses_count[nominal_mass] = len(
 923                    list(self.get_nominal_mass_indexes(nominal_mass))
 924                )
 925
 926        return dict_nominal_masses_count
 927
 928    def datapoints_count_by_nominal_mz(self, mz_overlay=0.1):
 929        """Return a dictionary of the nominal masses and their counts.
 930
 931        Parameters
 932        ----------
 933        mz_overlay : float, optional
 934            The m/z overlay to use for counting. Defaults to 0.1.
 935
 936        Returns
 937        -------
 938        dict
 939            A dictionary of the nominal masses and their counts.
 940        """
 941        dict_nominal_masses_count = {}
 942
 943        all_nominal_masses = list(set([i.nominal_mz_exp for i in self.mspeaks]))
 944
 945        for nominal_mass in all_nominal_masses:
 946            if nominal_mass not in dict_nominal_masses_count:
 947                min_mz = nominal_mass - mz_overlay
 948
 949                max_mz = nominal_mass + 1 + mz_overlay
 950
 951                indexes = indexes = where(
 952                    (self.mz_exp_profile > min_mz) & (self.mz_exp_profile < max_mz)
 953                )
 954
 955                dict_nominal_masses_count[nominal_mass] = indexes[0].size
 956
 957        return dict_nominal_masses_count
 958
 959    def get_nominal_mass_indexes(self, nominal_mass, overlay=0.1):
 960        """Return the indexes of the MSpeaks objects with the specified nominal mass.
 961
 962        Parameters
 963        ----------
 964        nominal_mass : int
 965            The nominal mass to get the indexes for.
 966        overlay : float, optional
 967            The m/z overlay to use for counting. Defaults to 0.1.
 968
 969        Returns
 970        -------
 971        generator
 972            A generator of the indexes of the MSpeaks objects with the specified nominal mass.
 973        """
 974        min_mz_to_look = nominal_mass - overlay
 975        max_mz_to_look = nominal_mass + 1 + overlay
 976
 977        return (
 978            i
 979            for i in range(len(self.mspeaks))
 980            if min_mz_to_look <= self.mspeaks[i].mz_exp <= max_mz_to_look
 981        )
 982
 983        # indexes = (i for i in range(len(self.mspeaks)) if min_mz_to_look <= self.mspeaks[i].mz_exp <= max_mz_to_look)
 984        # return indexes
 985
 986    def _set_nominal_masses_start_final_indexes(self):
 987        """Set the start and final indexes of the MSpeaks objects for all nominal masses."""
 988        dict_nominal_masses_indexes = {}
 989
 990        all_nominal_masses = set(i.nominal_mz_exp for i in self.mspeaks)
 991
 992        for nominal_mass in all_nominal_masses:
 993            # indexes = self.get_nominal_mass_indexes(nominal_mass)
 994            # Convert the iterator to a list to avoid multiple calls
 995            indexes = list(self.get_nominal_mass_indexes(nominal_mass))
 996
 997            # If the list is not empty, find the first and last; otherwise, set None
 998            if indexes:
 999                first, last = indexes[0], indexes[-1]
1000            else:
1001                first = last = None
1002            # defaultvalue = None
1003            # first = last = next(indexes, defaultvalue)
1004            # for last in indexes:
1005            #    pass
1006
1007            dict_nominal_masses_indexes[nominal_mass] = (first, last)
1008
1009        self._dict_nominal_masses_indexes = dict_nominal_masses_indexes
1010
1011    def plot_centroid(self, ax=None, c="g"):
1012        """Plot the centroid data of the mass spectrum.
1013
1014        Parameters
1015        ----------
1016        ax : matplotlib.axes.Axes, optional
1017            The matplotlib axes to plot on. Defaults to None.
1018        c : str, optional
1019            The color to use for the plot. Defaults to 'g' (green).
1020
1021        Returns
1022        -------
1023        matplotlib.axes.Axes
1024            The matplotlib axes containing the plot.
1025
1026        Raises
1027        ------
1028        Exception
1029            If no centroid data is found.
1030        """
1031
1032        import matplotlib.pyplot as plt
1033
1034        if self._mspeaks:
1035            if ax is None:
1036                ax = plt.gca()
1037
1038            markerline_a, stemlines_a, baseline_a = ax.stem(
1039                self.mz_exp, self.abundance, linefmt="-", markerfmt=" "
1040            )
1041
1042            plt.setp(markerline_a, "color", c, "linewidth", 2)
1043            plt.setp(stemlines_a, "color", c, "linewidth", 2)
1044            plt.setp(baseline_a, "color", c, "linewidth", 2)
1045
1046            ax.set_xlabel("$\t{m/z}$", fontsize=12)
1047            ax.set_ylabel("Abundance", fontsize=12)
1048            ax.tick_params(axis="both", which="major", labelsize=12)
1049
1050            ax.axes.spines["top"].set_visible(False)
1051            ax.axes.spines["right"].set_visible(False)
1052
1053            ax.get_yaxis().set_visible(False)
1054            ax.spines["left"].set_visible(False)
1055
1056        else:
1057            raise Exception("No centroid data found, please run process_mass_spec")
1058
1059        return ax
1060
1061    def plot_profile_and_noise_threshold(self, ax=None, legend=False):
1062        """Plot the profile data and noise threshold of the mass spectrum.
1063
1064        Parameters
1065        ----------
1066        ax : matplotlib.axes.Axes, optional
1067            The matplotlib axes to plot on. Defaults to None.
1068        legend : bool, optional
1069            Whether to show the legend. Defaults to False.
1070
1071        Returns
1072        -------
1073        matplotlib.axes.Axes
1074            The matplotlib axes containing the plot.
1075
1076        Raises
1077        ------
1078        Exception
1079            If no noise threshold is found.
1080        """
1081        import matplotlib.pyplot as plt
1082
1083        if self.baseline_noise_std and self.baseline_noise_std:
1084            # x = (self.mz_exp_profile.min(), self.mz_exp_profile.max())
1085            baseline = (self.baseline_noise, self.baseline_noise)
1086
1087            # std = self.parameters.mass_spectrum.noise_threshold_min_std
1088            # threshold = self.baseline_noise_std + (std * self.baseline_noise_std)
1089            x, y = self.get_noise_threshold()
1090
1091            if ax is None:
1092                ax = plt.gca()
1093
1094            ax.plot(
1095                self.mz_exp_profile,
1096                self.abundance_profile,
1097                color="green",
1098                label="Spectrum",
1099            )
1100            ax.plot(x, (baseline, baseline), color="yellow", label="Baseline Noise")
1101            ax.plot(x, y, color="red", label="Noise Threshold")
1102
1103            ax.set_xlabel("$\t{m/z}$", fontsize=12)
1104            ax.set_ylabel("Abundance", fontsize=12)
1105            ax.tick_params(axis="both", which="major", labelsize=12)
1106
1107            ax.axes.spines["top"].set_visible(False)
1108            ax.axes.spines["right"].set_visible(False)
1109
1110            ax.get_yaxis().set_visible(False)
1111            ax.spines["left"].set_visible(False)
1112            if legend:
1113                ax.legend()
1114
1115        else:
1116            raise Exception("Calculate noise threshold first")
1117
1118        return ax
1119
1120    def plot_mz_domain_profile(self, color="green", ax=None):
1121        """Plot the m/z domain profile of the mass spectrum.
1122
1123        Parameters
1124        ----------
1125        color : str, optional
1126            The color to use for the plot. Defaults to 'green'.
1127        ax : matplotlib.axes.Axes, optional
1128            The matplotlib axes to plot on. Defaults to None.
1129
1130        Returns
1131        -------
1132        matplotlib.axes.Axes
1133            The matplotlib axes containing the plot.
1134        """
1135
1136        import matplotlib.pyplot as plt
1137
1138        if ax is None:
1139            ax = plt.gca()
1140        ax.plot(self.mz_exp_profile, self.abundance_profile, color=color)
1141        ax.set(xlabel="m/z", ylabel="abundance")
1142
1143        return ax
1144
1145    def to_excel(self, out_file_path, write_metadata=True):
1146        """Export the mass spectrum to an Excel file.
1147
1148        Parameters
1149        ----------
1150        out_file_path : str
1151            The path to the Excel file to export to.
1152        write_metadata : bool, optional
1153            Whether to write the metadata to the Excel file. Defaults to True.
1154
1155        Returns
1156        -------
1157        None
1158        """
1159        from corems.mass_spectrum.output.export import HighResMassSpecExport
1160
1161        exportMS = HighResMassSpecExport(out_file_path, self)
1162        exportMS.to_excel(write_metadata=write_metadata)
1163
1164    def to_hdf(self, out_file_path):
1165        """Export the mass spectrum to an HDF file.
1166
1167        Parameters
1168        ----------
1169        out_file_path : str
1170            The path to the HDF file to export to.
1171
1172        Returns
1173        -------
1174        None
1175        """
1176        from corems.mass_spectrum.output.export import HighResMassSpecExport
1177
1178        exportMS = HighResMassSpecExport(out_file_path, self)
1179        exportMS.to_hdf()
1180
1181    def to_csv(self, out_file_path, write_metadata=True):
1182        """Export the mass spectrum to a CSV file.
1183
1184        Parameters
1185        ----------
1186        out_file_path : str
1187            The path to the CSV file to export to.
1188        write_metadata : bool, optional
1189            Whether to write the metadata to the CSV file. Defaults to True.
1190
1191        """
1192        from corems.mass_spectrum.output.export import HighResMassSpecExport
1193
1194        exportMS = HighResMassSpecExport(out_file_path, self)
1195        exportMS.to_csv(write_metadata=write_metadata)
1196
1197    def to_pandas(self, out_file_path, write_metadata=True):
1198        """Export the mass spectrum to a Pandas dataframe with pkl extension.
1199
1200        Parameters
1201        ----------
1202        out_file_path : str
1203            The path to the CSV file to export to.
1204        write_metadata : bool, optional
1205            Whether to write the metadata to the CSV file. Defaults to True.
1206
1207        """
1208        from corems.mass_spectrum.output.export import HighResMassSpecExport
1209
1210        exportMS = HighResMassSpecExport(out_file_path, self)
1211        exportMS.to_pandas(write_metadata=write_metadata)
1212
1213    def to_dataframe(self, additional_columns=None):
1214        """Return the mass spectrum as a Pandas dataframe.
1215
1216        Parameters
1217        ----------
1218        additional_columns : list, optional
1219            A list of additional columns to include in the dataframe. Defaults to None.
1220            Suitable columns are: "Aromaticity Index", "Aromaticity Index (modified)", and "NOSC"
1221
1222        Returns
1223        -------
1224        pandas.DataFrame
1225            The mass spectrum as a Pandas dataframe.
1226        """
1227        from corems.mass_spectrum.output.export import HighResMassSpecExport
1228
1229        exportMS = HighResMassSpecExport(self.filename, self)
1230        return exportMS.get_pandas_df(additional_columns=additional_columns)
1231
1232    def to_json(self):
1233        """Return the mass spectrum as a JSON file."""
1234        from corems.mass_spectrum.output.export import HighResMassSpecExport
1235
1236        exportMS = HighResMassSpecExport(self.filename, self)
1237        return exportMS.to_json()
1238
1239    def parameters_json(self):
1240        """Return the parameters of the mass spectrum as a JSON string."""
1241        from corems.mass_spectrum.output.export import HighResMassSpecExport
1242
1243        exportMS = HighResMassSpecExport(self.filename, self)
1244        return exportMS.parameters_to_json()
1245
1246    def parameters_toml(self):
1247        """Return the parameters of the mass spectrum as a TOML string."""
1248        from corems.mass_spectrum.output.export import HighResMassSpecExport
1249
1250        exportMS = HighResMassSpecExport(self.filename, self)
1251        return exportMS.parameters_to_toml()
1252
1253
1254class MassSpecProfile(MassSpecBase):
1255    """A mass spectrum class when the entry point is on profile format
1256
1257    Notes
1258    -----
1259    Stores the profile data and instrument settings.
1260    Iteration over a list of MSPeaks classes stored at the _mspeaks attributes.
1261    _mspeaks is populated under the hood by calling process_mass_spec method.
1262    Iteration is null if _mspeaks is empty. Many more attributes and methods inherited from MassSpecBase().
1263
1264    Parameters
1265    ----------
1266    data_dict : dict
1267        A dictionary containing the profile data.
1268    d_params : dict{'str': float, int or str}
1269        contains the instrument settings and processing settings
1270    auto_process : bool, optional
1271        Whether to automatically process the mass spectrum. Defaults to True.
1272
1273
1274    Attributes
1275    ----------
1276    _abundance : ndarray
1277        The abundance values of the mass spectrum.
1278    _mz_exp : ndarray
1279        The m/z values of the mass spectrum.
1280    _mspeaks : list
1281        A list of mass peaks.
1282
1283    Methods
1284    ----------
1285    * process_mass_spec(). Process the mass spectrum.
1286
1287    see also: MassSpecBase(), MassSpecfromFreq(), MassSpecCentroid()
1288    """
1289
1290    def __init__(self, data_dict, d_params, auto_process=True):
1291        # print(data_dict.keys())
1292        super().__init__(
1293            data_dict.get(Labels.mz), data_dict.get(Labels.abundance), d_params
1294        )
1295
1296        if auto_process:
1297            self.process_mass_spec()
1298
1299
1300class MassSpecfromFreq(MassSpecBase):
1301    """A mass spectrum class when data entry is on frequency domain
1302
1303    Notes
1304    -----
1305    - Transform to m/z based on the settings stored at d_params
1306    - Stores the profile data and instrument settings
1307    - Iteration over a list of MSPeaks classes stored at the _mspeaks attributes
1308    - _mspeaks is populated under the hood by calling process_mass_spec method
1309    - iteration is null if _mspeaks is empty
1310
1311    Parameters
1312    ----------
1313    frequency_domain : list(float)
1314        all datapoints in frequency domain in Hz
1315    magnitude :  frequency_domain : list(float)
1316        all datapoints in for magnitude of each frequency datapoint
1317    d_params : dict{'str': float, int or str}
1318        contains the instrument settings and processing settings
1319    auto_process : bool, optional
1320        Whether to automatically process the mass spectrum. Defaults to True.
1321    keep_profile : bool, optional
1322        Whether to keep the profile data. Defaults to True.
1323
1324    Attributes
1325    ----------
1326    has_frequency : bool
1327        Whether the mass spectrum has frequency data.
1328    _frequency_domain : list(float)
1329        Frequency domain in Hz
1330    label : str
1331        store label (Bruker, Midas Transient, see Labels class ). It across distinct processing points
1332    _abundance : ndarray
1333        The abundance values of the mass spectrum.
1334    _mz_exp : ndarray
1335        The m/z values of the mass spectrum.
1336    _mspeaks : list
1337        A list of mass peaks.
1338    See Also: all the attributes of MassSpecBase class
1339
1340    Methods
1341    ----------
1342    * _set_mz_domain().
1343        calculates the m_z based on the setting of d_params
1344    * process_mass_spec().  Process the mass spectrum.
1345
1346    see also: MassSpecBase(), MassSpecProfile(), MassSpecCentroid()
1347    """
1348
1349    def __init__(
1350        self,
1351        frequency_domain,
1352        magnitude,
1353        d_params,
1354        auto_process=True,
1355        keep_profile=True,
1356    ):
1357        super().__init__(None, magnitude, d_params)
1358
1359        self._frequency_domain = frequency_domain
1360        self.has_frequency = True
1361        self._set_mz_domain()
1362        self._sort_mz_domain()
1363
1364        self.magnetron_frequency = None
1365        self.magnetron_frequency_sigma = None
1366
1367        # use this call to automatically process data as the object is created, Setting need to be changed before initiating the class to be in effect
1368
1369        if auto_process:
1370            self.process_mass_spec(keep_profile=keep_profile)
1371
1372    def _sort_mz_domain(self):
1373        """Sort the mass spectrum by m/z values."""
1374
1375        if self._mz_exp[0] > self._mz_exp[-1]:
1376            self._mz_exp = self._mz_exp[::-1]
1377            self._abundance = self._abundance[::-1]
1378            self._frequency_domain = self._frequency_domain[::-1]
1379
1380    def _set_mz_domain(self):
1381        """Set the m/z domain of the mass spectrum based on the settings of d_params."""
1382        if self.label == Labels.bruker_frequency:
1383            self._mz_exp = self._f_to_mz_bruker()
1384
1385        else:
1386            self._mz_exp = self._f_to_mz()
1387
1388    @property
1389    def transient_settings(self):
1390        """Return the transient settings of the mass spectrum."""
1391        return self.parameters.transient
1392
1393    @transient_settings.setter
1394    def transient_settings(self, instance_TransientSetting):
1395        self.parameters.transient = instance_TransientSetting
1396
1397    def calc_magnetron_freq(self, max_magnetron_freq=50, magnetron_freq_bins=300):
1398        """Calculates the magnetron frequency of the mass spectrum.
1399
1400        Parameters
1401        ----------
1402        max_magnetron_freq : float, optional
1403            The maximum magnetron frequency. Defaults to 50.
1404        magnetron_freq_bins : int, optional
1405            The number of bins to use for the histogram. Defaults to 300.
1406
1407        Returns
1408        -------
1409        None
1410
1411        Notes
1412        -----
1413        Calculates the magnetron frequency by examining all the picked peaks and the distances between them in the frequency domain.
1414        A histogram of those values below the threshold 'max_magnetron_freq' with the 'magnetron_freq_bins' number of bins is calculated.
1415        A gaussian model is fit to this histogram - the center value of this (statistically probably) the magnetron frequency.
1416        This appears to work well or nOmega datasets, but may not work well for 1x datasets or those with very low magnetron peaks.
1417        """
1418        ms_df = DataFrame(self.freq_exp(), columns=["Freq"])
1419        ms_df["FreqDelta"] = ms_df["Freq"].diff()
1420
1421        freq_hist = histogram(
1422            ms_df[ms_df["FreqDelta"] < max_magnetron_freq]["FreqDelta"],
1423            bins=magnetron_freq_bins,
1424        )
1425
1426        mod = GaussianModel()
1427        pars = mod.guess(freq_hist[0], x=freq_hist[1][:-1])
1428        out = mod.fit(freq_hist[0], pars, x=freq_hist[1][:-1])
1429        self.magnetron_frequency = out.best_values["center"]
1430        self.magnetron_frequency_sigma = out.best_values["sigma"]
1431
1432
1433class MassSpecCentroid(MassSpecBase):
1434    """A mass spectrum class when the entry point is on centroid format
1435
1436    Notes
1437    -----
1438    - Stores the centroid data and instrument settings
1439    - Simulate profile data based on Gaussian or Lorentzian peak shape
1440    - Iteration over a list of MSPeaks classes stored at the _mspeaks attributes
1441    - _mspeaks is populated under the hood by calling process_mass_spec method
1442    - iteration is null if _mspeaks is empty
1443
1444    Parameters
1445    ----------
1446    data_dict : dict {string: numpy array float64 )
1447        contains keys [m/z, Abundance, Resolving Power, S/N]
1448    d_params : dict{'str': float, int or str}
1449        contains the instrument settings and processing settings
1450    auto_process : bool, optional
1451        Whether to automatically process the mass spectrum. Defaults to True.
1452
1453    Attributes
1454    ----------
1455    label : str
1456        store label (Bruker, Midas Transient, see Labels class)
1457    _baseline_noise : float
1458        store baseline noise
1459    _baseline_noise_std : float
1460        store baseline noise std
1461    _abundance : ndarray
1462        The abundance values of the mass spectrum.
1463    _mz_exp : ndarray
1464        The m/z values of the mass spectrum.
1465    _mspeaks : list
1466        A list of mass peaks.
1467
1468
1469    Methods
1470    ----------
1471    * process_mass_spec().
1472        Process the mass spectrum. Overriden from MassSpecBase. Populates the _mspeaks list with MSpeaks class using the centroid data.
1473    * __simulate_profile__data__().
1474        Simulate profile data based on Gaussian or Lorentzian peak shape. Needs theoretical resolving power calculation and define peak shape, intended for plotting and inspection purposes only.
1475
1476    see also: MassSpecBase(), MassSpecfromFreq(), MassSpecProfile()
1477    """
1478
1479    def __init__(self, data_dict, d_params, auto_process=True):
1480        super().__init__([], [], d_params)
1481
1482        self._set_parameters_objects(d_params)
1483
1484        if self.label == Labels.thermo_centroid:
1485            self._baseline_noise = d_params.get("baseline_noise")
1486            self._baseline_noise_std = d_params.get("baseline_noise_std")
1487
1488        self.is_centroid = True
1489        self.data_dict = data_dict
1490        self._mz_exp = data_dict[Labels.mz]
1491        self._abundance = data_dict[Labels.abundance]
1492
1493        if auto_process:
1494            self.process_mass_spec()
1495
1496    def __simulate_profile__data__(self, exp_mz_centroid, magnitude_centroid):
1497        """Simulate profile data based on Gaussian or Lorentzian peak shape
1498
1499        Notes
1500        -----
1501        Needs theoretical resolving power calculation and define peak shape.
1502        This is a quick fix to trick a line plot be able to plot as sticks for plotting and inspection purposes only.
1503
1504        Parameters
1505        ----------
1506        exp_mz_centroid : list(float)
1507            list of m/z values
1508        magnitude_centroid : list(float)
1509            list of abundance values
1510
1511
1512        Returns
1513        -------
1514        x : list(float)
1515            list of m/z values
1516        y : list(float)
1517            list of abundance values
1518        """
1519
1520        x, y = [], []
1521        for i in range(len(exp_mz_centroid)):
1522            x.append(exp_mz_centroid[i] - 0.0000001)
1523            x.append(exp_mz_centroid[i])
1524            x.append(exp_mz_centroid[i] + 0.0000001)
1525            y.append(0)
1526            y.append(magnitude_centroid[i])
1527            y.append(0)
1528        return x, y
1529
1530    @property
1531    def mz_exp_profile(self):
1532        """Return the m/z profile of the mass spectrum."""
1533        mz_list = []
1534        for mz in self.mz_exp:
1535            mz_list.append(mz - 0.0000001)
1536            mz_list.append(mz)
1537            mz_list.append(mz + 0.0000001)
1538        return mz_list
1539
1540    @mz_exp_profile.setter
1541    def mz_exp_profile(self, _mz_exp):
1542        self._mz_exp = _mz_exp
1543
1544    @property
1545    def abundance_profile(self):
1546        """Return the abundance profile of the mass spectrum."""
1547        ab_list = []
1548        for ab in self.abundance:
1549            ab_list.append(0)
1550            ab_list.append(ab)
1551            ab_list.append(0)
1552        return ab_list
1553
1554    @abundance_profile.setter
1555    def abundance_profile(self, abundance):
1556        self._abundance = abundance
1557
1558    @property
1559    def tic(self):
1560        """Return the total ion current of the mass spectrum."""
1561        return sum(self.abundance)
1562
1563    def process_mass_spec(self):
1564        """Process the mass spectrum."""
1565        import tqdm
1566
1567        # overwrite process_mass_spec
1568        # mspeak objs are usually added inside the PeaKPicking class
1569        # for profile and freq based data
1570        data_dict = self.data_dict
1571        ion_charge = self.polarity
1572
1573        # Check if resolving power is present
1574        rp_present = True
1575        if not data_dict.get(Labels.rp):
1576            rp_present = False
1577        if rp_present and list(data_dict.get(Labels.rp)) == [None] * len(
1578            data_dict.get(Labels.rp)
1579        ):
1580            rp_present = False
1581
1582        # Check if s2n is present
1583        s2n_present = True
1584        if not data_dict.get(Labels.s2n):
1585            s2n_present = False
1586        if s2n_present and list(data_dict.get(Labels.s2n)) == [None] * len(
1587            data_dict.get(Labels.s2n)
1588        ):
1589            s2n_present = False
1590
1591        # Warning if no s2n data but noise thresholding is set to signal_noise
1592        if (
1593            not s2n_present
1594            and self.parameters.mass_spectrum.noise_threshold_method == "signal_noise"
1595        ):
1596            raise Exception("Signal to Noise data is missing for noise thresholding")
1597
1598        # Pull out abundance data
1599        abun = array(data_dict.get(Labels.abundance)).astype(float)
1600
1601        # Get the threshold for filtering if using minima, relative, or absolute abundance thresholding
1602        abundance_threshold, factor = self.get_threshold(abun)
1603
1604        # Set rp_i and s2n_i to None which will be overwritten if present
1605        rp_i, s2n_i = np.nan, np.nan
1606        for index, mz in enumerate(data_dict.get(Labels.mz)):
1607            if rp_present:
1608                if not data_dict.get(Labels.rp)[index]:
1609                    rp_i = np.nan
1610                else:
1611                    rp_i = float(data_dict.get(Labels.rp)[index])
1612            if s2n_present:
1613                if not data_dict.get(Labels.s2n)[index]:
1614                    s2n_i = np.nan
1615                else:
1616                    s2n_i = float(data_dict.get(Labels.s2n)[index])
1617
1618            # centroid peak does not have start and end peak index pos
1619            massspec_indexes = (index, index, index)
1620
1621            # Add peaks based on the noise thresholding method
1622            if (
1623                self.parameters.mass_spectrum.noise_threshold_method
1624                in ["minima", "relative_abundance", "absolute_abundance"]
1625                and abun[index] / factor >= abundance_threshold
1626            ):
1627                self.add_mspeak(
1628                    ion_charge,
1629                    mz,
1630                    abun[index],
1631                    rp_i,
1632                    s2n_i,
1633                    massspec_indexes,
1634                    ms_parent=self,
1635                )
1636            if (
1637                self.parameters.mass_spectrum.noise_threshold_method == "signal_noise"
1638                and s2n_i >= self.parameters.mass_spectrum.noise_threshold_min_s2n
1639            ):
1640                self.add_mspeak(
1641                    ion_charge,
1642                    mz,
1643                    abun[index],
1644                    rp_i,
1645                    s2n_i,
1646                    massspec_indexes,
1647                    ms_parent=self,
1648                )
1649
1650        self.mspeaks = self._mspeaks
1651        self._dynamic_range = self.max_abundance / self.min_abundance
1652        self._set_nominal_masses_start_final_indexes()
1653
1654        if self.label != Labels.thermo_centroid:
1655            if self.settings.noise_threshold_method == "log":
1656                raise Exception("log noise Not tested for centroid data")
1657                # self._baseline_noise, self._baseline_noise_std = self.run_log_noise_threshold_calc()
1658
1659            else:
1660                self._baseline_noise, self._baseline_noise_std = (
1661                    self.run_noise_threshold_calc()
1662                )
1663
1664        del self.data_dict
1665
1666
1667class MassSpecCentroidLowRes(MassSpecCentroid):
1668    """A mass spectrum class when the entry point is on low resolution centroid format
1669
1670    Notes
1671    -----
1672    Does not store MSPeak Objs, will iterate over mz, abundance pairs instead
1673
1674    Parameters
1675    ----------
1676    data_dict : dict {string: numpy array float64 )
1677        contains keys [m/z, Abundance, Resolving Power, S/N]
1678    d_params : dict{'str': float, int or str}
1679        contains the instrument settings and processing settings
1680
1681    Attributes
1682    ----------
1683    _processed_tic : float
1684        store processed total ion current
1685    _abundance : ndarray
1686        The abundance values of the mass spectrum.
1687    _mz_exp : ndarray
1688        The m/z values of the mass spectrum.
1689    """
1690
1691    def __init__(self, data_dict, d_params):
1692        self._set_parameters_objects(d_params)
1693        self._mz_exp = array(data_dict.get(Labels.mz))
1694        self._abundance = array(data_dict.get(Labels.abundance))
1695        self._processed_tic = None
1696
1697    def __len__(self):
1698        return len(self.mz_exp)
1699
1700    def __getitem__(self, position):
1701        return (self.mz_exp[position], self.abundance[position])
1702
1703    @property
1704    def mz_exp(self):
1705        """Return the m/z values of the mass spectrum."""
1706        return self._mz_exp
1707
1708    @property
1709    def abundance(self):
1710        """Return the abundance values of the mass spectrum."""
1711        return self._abundance
1712
1713    @property
1714    def processed_tic(self):
1715        """Return the processed total ion current of the mass spectrum."""
1716        return sum(self._processed_tic)
1717
1718    @property
1719    def tic(self):
1720        """Return the total ion current of the mass spectrum."""
1721        if self._processed_tic:
1722            return self._processed_tic
1723        else:
1724            return sum(self.abundance)
1725
1726    @property
1727    def mz_abun_tuples(self):
1728        """Return the m/z and abundance values of the mass spectrum as a list of tuples."""
1729        r = lambda x: (int(round(x[0], 0), int(round(x[1], 0))))
1730
1731        return [r(i) for i in self]
1732
1733    @property
1734    def mz_abun_dict(self):
1735        """Return the m/z and abundance values of the mass spectrum as a dictionary."""
1736        r = lambda x: int(round(x, 0))
1737
1738        return {r(i[0]): r(i[1]) for i in self}