MassSpectrumClasses.py

from pathlib import Path

import numpy as np
from lmfit.models import GaussianModel

# from matplotlib import rcParamsDefault, rcParams
from numpy import array, float64, histogram, trapz, where
from pandas import DataFrame

from corems.encapsulation.constant import Labels
from corems.encapsulation.factory.parameters import MSParameters
from corems.encapsulation.input.parameter_from_json import (
    load_and_set_parameters_ms,
    load_and_set_toml_parameters_ms,
)
from corems.mass_spectrum.calc.KendrickGroup import KendrickGrouping
from corems.mass_spectrum.calc.MassSpectrumCalc import MassSpecCalc
from corems.mass_spectrum.calc.MeanResolvingPowerFilter import MeanResolvingPowerFilter
from corems.ms_peak.factory.MSPeakClasses import ICRMassPeak as MSPeak

__author__ = "Yuri E. Corilo"
__date__ = "Jun 12, 2019"


def overrides(interface_class):
    """Checks if the method overrides a method from an interface class."""

    def overrider(method):
        assert method.__name__ in dir(interface_class)
        return method

    return overrider


class MassSpecBase(MassSpecCalc, KendrickGrouping):
    """A mass spectrum base class, stores the profile data and instrument settings.

    Iteration over a list of MSPeaks classes stored at the _mspeaks attributes.
    _mspeaks is populated under the hood by calling process_mass_spec method.
    Iteration is null if _mspeaks is empty.

    Parameters
    ----------
    mz_exp : array_like
        The m/z values of the mass spectrum.
    abundance : array_like
        The abundance values of the mass spectrum.
    d_params : dict
        A dictionary of parameters for the mass spectrum.
    **kwargs
        Additional keyword arguments.

    Attributes
    ----------

    mspeaks : list
        A list of mass peaks.
    is_calibrated : bool
        Whether the mass spectrum is calibrated.
    is_centroid : bool
        Whether the mass spectrum is centroided.
    has_frequency : bool
        Whether the mass spectrum has a frequency domain.
    calibration_order : None or int
        The order of the mass spectrum's calibration.
    calibration_points : None or ndarray
        The calibration points of the mass spectrum.
    calibration_ref_mzs: None or ndarray
        The reference m/z values of the mass spectrum's calibration.
    calibration_meas_mzs : None or ndarray
        The measured m/z values of the mass spectrum's calibration.
    calibration_RMS : None or float
        The root mean square of the mass spectrum's calibration.
    calibration_segment : None or CalibrationSegment
        The calibration segment of the mass spectrum.
    _abundance : ndarray
        The abundance values of the mass spectrum.
    _mz_exp : ndarray
        The m/z values of the mass spectrum.
    _mspeaks : list
        A list of mass peaks.
    _dict_nominal_masses_indexes : dict
        A dictionary of nominal masses and their indexes.
    _baseline_noise : float
        The baseline noise of the mass spectrum.
    _baseline_noise_std : float
        The standard deviation of the baseline noise of the mass spectrum.
    _dynamic_range : float or None
        The dynamic range of the mass spectrum.
    _transient_settings : None or TransientSettings
        The transient settings of the mass spectrum.
    _frequency_domain : None or FrequencyDomain
        The frequency domain of the mass spectrum.
    _mz_cal_profile : None or MzCalibrationProfile
        The m/z calibration profile of the mass spectrum.

    Methods
    -------
    * process_mass_spec(). Main function to process the mass spectrum,
    including calculating the noise threshold, peak picking, and resetting the MSpeak indexes.

    See also: MassSpecCentroid(), MassSpecfromFreq(), MassSpecProfile()
    """

    def __init__(self, mz_exp, abundance, d_params, **kwargs):
        self._abundance = array(abundance, dtype=float64)
        self._mz_exp = array(mz_exp, dtype=float64)

        # objects created after process_mass_spec() function
        self._mspeaks = list()
        self.mspeaks = list()
        self._dict_nominal_masses_indexes = dict()
        self._baseline_noise = 0.001
        self._baseline_noise_std = 0.001
        self._dynamic_range = None
        # set to None: initialization occurs inside subclass MassSpecfromFreq
        self._transient_settings = None
        self._frequency_domain = None
        self._mz_cal_profile = None
        self.is_calibrated = False

        self._set_parameters_objects(d_params)
        self._init_settings()

        self.is_centroid = False
        self.has_frequency = False

        self.calibration_order = None
        self.calibration_points = None
        self.calibration_ref_mzs = None
        self.calibration_meas_mzs = None
        self.calibration_RMS = None
        self.calibration_segment = None
        self.calibration_raw_error_median = None
        self.calibration_raw_error_stdev = None

    def _init_settings(self):
        """Initializes the settings for the mass spectrum."""
        self._parameters = MSParameters()

    def __len__(self):
        return len(self.mspeaks)

    def __getitem__(self, position) -> MSPeak:
        return self.mspeaks[position]

    def set_indexes(self, list_indexes):
        """Set the mass spectrum to iterate over only the selected MSpeaks indexes.

        Parameters
        ----------
        list_indexes : list of int
            A list of integers representing the indexes of the MSpeaks to iterate over.

        """
        self.mspeaks = [self._mspeaks[i] for i in list_indexes]

        for i, mspeak in enumerate(self.mspeaks):
            mspeak.index = i

        self._set_nominal_masses_start_final_indexes()

    def reset_indexes(self):
        """Reset the mass spectrum to iterate over all MSpeaks objects.

        This method resets the mass spectrum to its original state, allowing iteration over all MSpeaks objects.
        It also sets the index of each MSpeak object to its corresponding position in the mass spectrum.

        """
        self.mspeaks = self._mspeaks

        for i, mspeak in enumerate(self.mspeaks):
            mspeak.index = i

        self._set_nominal_masses_start_final_indexes()

    def add_mspeak(
        self,
        ion_charge,
        mz_exp,
        abundance,
        resolving_power,
        signal_to_noise,
        massspec_indexes,
        exp_freq=None,
        ms_parent=None,
    ):
        """Add a new MSPeak object to the MassSpectrum object.

        Parameters
        ----------
        ion_charge : int
            The ion charge of the MSPeak.
        mz_exp : float
            The experimental m/z value of the MSPeak.
        abundance : float
            The abundance of the MSPeak.
        resolving_power : float
            The resolving power of the MSPeak.
        signal_to_noise : float
            The signal-to-noise ratio of the MSPeak.
        massspec_indexes : list
            A list of indexes of the MSPeak in the MassSpectrum object.
        exp_freq : float, optional
            The experimental frequency of the MSPeak. Defaults to None.
        ms_parent : MSParent, optional
            The MSParent object associated with the MSPeak. Defaults to None.
        """
        mspeak = MSPeak(
            ion_charge,
            mz_exp,
            abundance,
            resolving_power,
            signal_to_noise,
            massspec_indexes,
            len(self._mspeaks),
            exp_freq=exp_freq,
            ms_parent=ms_parent,
        )

        self._mspeaks.append(mspeak)

    def _set_parameters_objects(self, d_params):
        """Set the parameters of the MassSpectrum object.

        Parameters
        ----------
        d_params : dict
            A dictionary containing the parameters to set.

        Notes
        -----
        This method sets the following parameters of the MassSpectrum object:
        - _calibration_terms
        - label
        - analyzer
        - acquisition_time
        - instrument_label
        - polarity
        - scan_number
        - retention_time
        - mobility_rt
        - mobility_scan
        - _filename
        - _dir_location
        - _baseline_noise
        - _baseline_noise_std
        - sample_name
        """
        self._calibration_terms = (
            d_params.get("Aterm"),
            d_params.get("Bterm"),
            d_params.get("Cterm"),
        )

        self.label = d_params.get(Labels.label)

        self.analyzer = d_params.get("analyzer")

        self.acquisition_time = d_params.get("acquisition_time")

        self.instrument_label = d_params.get("instrument_label")

        self.polarity = int(d_params.get("polarity"))

        self.scan_number = d_params.get("scan_number")

        self.retention_time = d_params.get("rt")

        self.mobility_rt = d_params.get("mobility_rt")

        self.mobility_scan = d_params.get("mobility_scan")

        self._filename = d_params.get("filename_path")

        self._dir_location = d_params.get("dir_location")

        self._baseline_noise = d_params.get("baseline_noise")

        self._baseline_noise_std = d_params.get("baseline_noise_std")

        if d_params.get("sample_name") != "Unknown":
            self.sample_name = d_params.get("sample_name")
            if not self.sample_name:
                self.sample_name = self.filename.stem
        else:
            self.sample_name = self.filename.stem

    def reset_cal_therms(self, Aterm, Bterm, C, fas=0):
        """Reset calibration terms and recalculate the mass-to-charge ratio and abundance.

        Parameters
        ----------
        Aterm : float
            The A-term calibration coefficient.
        Bterm : float
            The B-term calibration coefficient.
        C : float
            The C-term calibration coefficient.
        fas : float, optional
            The frequency amplitude scaling factor. Default is 0.
        """
        self._calibration_terms = (Aterm, Bterm, C)

        self._mz_exp = self._f_to_mz()
        self._abundance = self._abundance
        self.find_peaks()
        self.reset_indexes()

    def clear_molecular_formulas(self):
        """Clear the molecular formulas for all mspeaks in the MassSpectrum.

        Returns
        -------
        numpy.ndarray
            An array of the cleared molecular formulas for each mspeak in the MassSpectrum.
        """
        self.check_mspeaks()
        return array([mspeak.clear_molecular_formulas() for mspeak in self.mspeaks])

    def process_mass_spec(self, keep_profile=True):
        """Process the mass spectrum.

        Parameters
        ----------
        keep_profile : bool, optional
            Whether to keep the profile data after processing. Defaults to True.

        Notes
        -----
        This method does the following:
        - calculates the noise threshold
        - does peak picking (creates mspeak_objs)
        - resets the mspeak_obj indexes
        """

        # if runned mannually make sure to rerun filter_by_noise_threshold
        # calculates noise threshold
        # do peak picking( create mspeak_objs)
        # reset mspeak_obj the indexes

        self.cal_noise_threshold()

        self.find_peaks()
        self.reset_indexes()

        if self.mspeaks:
            self._dynamic_range = self.max_abundance / self.min_abundance
        else:
            self._dynamic_range = 0
        if not keep_profile:
            self._abundance *= 0
            self._mz_exp *= 0

    def cal_noise_threshold(self):
        """Calculate the noise threshold of the mass spectrum."""

        if self.label == Labels.simulated_profile:
            self._baseline_noise, self._baseline_noise_std = 0.1, 1

        if self.settings.noise_threshold_method == "log":
            self._baseline_noise, self._baseline_noise_std = (
                self.run_log_noise_threshold_calc()
            )

        else:
            self._baseline_noise, self._baseline_noise_std = (
                self.run_noise_threshold_calc()
            )

    @property
    def parameters(self):
        """Return the parameters of the mass spectrum."""
        return self._parameters

    @parameters.setter
    def parameters(self, instance_MSParameters):
        self._parameters = instance_MSParameters

    def set_parameter_from_json(self, parameters_path):
        """Set the parameters of the mass spectrum from a JSON file.

        Parameters
        ----------
        parameters_path : str
            The path to the JSON file containing the parameters.
        """
        load_and_set_parameters_ms(self, parameters_path=parameters_path)

    def set_parameter_from_toml(self, parameters_path):
        load_and_set_toml_parameters_ms(self, parameters_path=parameters_path)

    @property
    def mspeaks_settings(self):
        """Return the MS peak settings of the mass spectrum."""
        return self.parameters.ms_peak

    @mspeaks_settings.setter
    def mspeaks_settings(self, instance_MassSpecPeakSetting):
        self.parameters.ms_peak = instance_MassSpecPeakSetting

    @property
    def settings(self):
        """Return the settings of the mass spectrum."""
        return self.parameters.mass_spectrum

    @settings.setter
    def settings(self, instance_MassSpectrumSetting):
        self.parameters.mass_spectrum = instance_MassSpectrumSetting

    @property
    def molecular_search_settings(self):
        """Return the molecular search settings of the mass spectrum."""
        return self.parameters.molecular_search

    @molecular_search_settings.setter
    def molecular_search_settings(self, instance_MolecularFormulaSearchSettings):
        self.parameters.molecular_search = instance_MolecularFormulaSearchSettings

    @property
    def mz_cal_profile(self):
        """Return the calibrated m/z profile of the mass spectrum."""
        return self._mz_cal_profile

    @mz_cal_profile.setter
    def mz_cal_profile(self, mz_cal_list):
        if len(mz_cal_list) == len(self._mz_exp):
            self._mz_cal_profile = mz_cal_list
        else:
            raise Exception(
                "calibrated array (%i) is not of the same size of the data (%i)"
                % (len(mz_cal_list), len(self.mz_exp_profile))
            )

    @property
    def mz_cal(self):
        """Return the calibrated m/z values of the mass spectrum."""
        return array([mspeak.mz_cal for mspeak in self.mspeaks])

    @mz_cal.setter
    def mz_cal(self, mz_cal_list):
        if len(mz_cal_list) == len(self.mspeaks):
            self.is_calibrated = True
            for index, mz_cal in enumerate(mz_cal_list):
                self.mspeaks[index].mz_cal = mz_cal
        else:
            raise Exception(
                "calibrated array (%i) is not of the same size of the data (%i)"
                % (len(mz_cal_list), len(self._mspeaks))
            )

    @property
    def mz_exp(self):
        """Return the experimental m/z values of the mass spectrum."""
        self.check_mspeaks()

        if self.is_calibrated:
            return array([mspeak.mz_cal for mspeak in self.mspeaks])

        else:
            return array([mspeak.mz_exp for mspeak in self.mspeaks])

    @property
    def freq_exp_profile(self):
        """Return the experimental frequency profile of the mass spectrum."""
        return self._frequency_domain

    @freq_exp_profile.setter
    def freq_exp_profile(self, new_data):
        self._frequency_domain = array(new_data)

    @property
    def freq_exp_pp(self):
        """Return the experimental frequency values of the mass spectrum that are used for peak picking."""
        _, _, freq = self.prepare_peak_picking_data()
        return freq

    @property
    def mz_exp_profile(self):
        """Return the experimental m/z profile of the mass spectrum."""
        if self.is_calibrated:
            return self.mz_cal_profile
        else:
            return self._mz_exp

    @mz_exp_profile.setter
    def mz_exp_profile(self, new_data):
        self._mz_exp = array(new_data)

    @property
    def mz_exp_pp(self):
        """Return the experimental m/z values of the mass spectrum that are used for peak picking."""
        mz, _, _ = self.prepare_peak_picking_data()
        return mz

    @property
    def abundance_profile(self):
        """Return the abundance profile of the mass spectrum."""
        return self._abundance

    @abundance_profile.setter
    def abundance_profile(self, new_data):
        self._abundance = array(new_data)

    @property
    def abundance_profile_pp(self):
        """Return the abundance profile of the mass spectrum that is used for peak picking."""
        _, abundance, _ = self.prepare_peak_picking_data()
        return abundance

    @property
    def abundance(self):
        """Return the abundance values of the mass spectrum."""
        self.check_mspeaks()
        return array([mspeak.abundance for mspeak in self.mspeaks])

    def freq_exp(self):
        """Return the experimental frequency values of the mass spectrum."""
        self.check_mspeaks()
        return array([mspeak.freq_exp for mspeak in self.mspeaks])

    @property
    def resolving_power(self):
        """Return the resolving power values of the mass spectrum."""
        self.check_mspeaks()
        return array([mspeak.resolving_power for mspeak in self.mspeaks])

    @property
    def signal_to_noise(self):
        self.check_mspeaks()
        return array([mspeak.signal_to_noise for mspeak in self.mspeaks])

    @property
    def nominal_mz(self):
        """Return the nominal m/z values of the mass spectrum."""
        if self._dict_nominal_masses_indexes:
            return sorted(list(self._dict_nominal_masses_indexes.keys()))
        else:
            raise ValueError("Nominal indexes not yet set")

    def get_mz_and_abundance_peaks_tuples(self):
        """Return a list of tuples containing the m/z and abundance values of the mass spectrum."""
        self.check_mspeaks()
        return [(mspeak.mz_exp, mspeak.abundance) for mspeak in self.mspeaks]

    @property
    def kmd(self):
        """Return the Kendrick mass defect values of the mass spectrum."""
        self.check_mspeaks()
        return array([mspeak.kmd for mspeak in self.mspeaks])

    @property
    def kendrick_mass(self):
        """Return the Kendrick mass values of the mass spectrum."""
        self.check_mspeaks()
        return array([mspeak.kendrick_mass for mspeak in self.mspeaks])

    @property
    def max_mz_exp(self):
        """Return the maximum experimental m/z value of the mass spectrum."""
        return max([mspeak.mz_exp for mspeak in self.mspeaks])

    @property
    def min_mz_exp(self):
        """Return the minimum experimental m/z value of the mass spectrum."""
        return min([mspeak.mz_exp for mspeak in self.mspeaks])

    @property
    def max_abundance(self):
        """Return the maximum abundance value of the mass spectrum."""
        return max([mspeak.abundance for mspeak in self.mspeaks])

    @property
    def max_signal_to_noise(self):
        """Return the maximum signal-to-noise ratio of the mass spectrum."""
        return max([mspeak.signal_to_noise for mspeak in self.mspeaks])

    @property
    def most_abundant_mspeak(self):
        """Return the most abundant MSpeak object of the mass spectrum."""
        return max(self.mspeaks, key=lambda m: m.abundance)

    @property
    def min_abundance(self):
        """Return the minimum abundance value of the mass spectrum."""
        return min([mspeak.abundance for mspeak in self.mspeaks])

    # takes too much cpu time
    @property
    def dynamic_range(self):
        """Return the dynamic range of the mass spectrum."""
        return self._dynamic_range

    @property
    def baseline_noise(self):
        """Return the baseline noise of the mass spectrum."""
        if self._baseline_noise:
            return self._baseline_noise
        else:
            return None

    @property
    def baseline_noise_std(self):
        """Return the standard deviation of the baseline noise of the mass spectrum."""
        if self._baseline_noise_std == 0:
            return self._baseline_noise_std
        if self._baseline_noise_std:
            return self._baseline_noise_std
        else:
            return None

    @property
    def Aterm(self):
        """Return the A-term calibration coefficient of the mass spectrum."""
        return self._calibration_terms[0]

    @property
    def Bterm(self):
        """Return the B-term calibration coefficient of the mass spectrum."""
        return self._calibration_terms[1]

    @property
    def Cterm(self):
        """Return the C-term calibration coefficient of the mass spectrum."""
        return self._calibration_terms[2]

    @property
    def filename(self):
        """Return the filename of the mass spectrum."""
        return Path(self._filename)

    @property
    def dir_location(self):
        """Return the directory location of the mass spectrum."""
        return self._dir_location

    def sort_by_mz(self):
        """Sort the mass spectrum by m/z values."""
        return sorted(self, key=lambda m: m.mz_exp)

    def sort_by_abundance(self, reverse=False):
        """Sort the mass spectrum by abundance values."""
        return sorted(self, key=lambda m: m.abundance, reverse=reverse)

    @property
    def tic(self):
        """Return the total ion current of the mass spectrum."""
        return trapz(self.abundance_profile, self.mz_exp_profile)

    def check_mspeaks_warning(self):
        """Check if the mass spectrum has MSpeaks objects.

        Raises
        ------
        Warning
            If the mass spectrum has no MSpeaks objects.
        """
        import warnings

        if self.mspeaks:
            pass
        else:
            warnings.warn("mspeaks list is empty, continuing without filtering data")

    def check_mspeaks(self):
        """Check if the mass spectrum has MSpeaks objects.

        Raises
        ------
        Exception
            If the mass spectrum has no MSpeaks objects.
        """
        if self.mspeaks:
            pass
        else:
            raise Exception(
                "mspeaks list is empty, please run process_mass_spec() first"
            )

    def remove_assignment_by_index(self, indexes):
        """Remove the molecular formula assignment of the MSpeaks objects at the specified indexes.

        Parameters
        ----------
        indexes : list of int
            A list of indexes of the MSpeaks objects to remove the molecular formula assignment from.
        """
        for i in indexes:
            self.mspeaks[i].clear_molecular_formulas()

    def filter_by_index(self, list_indexes):
        """Filter the mass spectrum by the specified indexes.

        Parameters
        ----------
        list_indexes : list of int
            A list of indexes of the MSpeaks objects to drop.

        """

        self.mspeaks = [
            self.mspeaks[i] for i in range(len(self.mspeaks)) if i not in list_indexes
        ]

        for i, mspeak in enumerate(self.mspeaks):
            mspeak.index = i

        self._set_nominal_masses_start_final_indexes()

    def filter_by_mz(self, min_mz, max_mz):
        """Filter the mass spectrum by the specified m/z range.

        Parameters
        ----------
        min_mz : float
            The minimum m/z value to keep.
        max_mz : float
            The maximum m/z value to keep.

        """
        self.check_mspeaks_warning()
        indexes = [
            index
            for index, mspeak in enumerate(self.mspeaks)
            if not min_mz <= mspeak.mz_exp <= max_mz
        ]
        self.filter_by_index(indexes)

    def filter_by_s2n(self, min_s2n, max_s2n=False):
        """Filter the mass spectrum by the specified signal-to-noise ratio range.

        Parameters
        ----------
        min_s2n : float
            The minimum signal-to-noise ratio to keep.
        max_s2n : float, optional
            The maximum signal-to-noise ratio to keep. Defaults to False (no maximum).

        """
        self.check_mspeaks_warning()
        if max_s2n:
            indexes = [
                index
                for index, mspeak in enumerate(self.mspeaks)
                if not min_s2n <= mspeak.signal_to_noise <= max_s2n
            ]
        else:
            indexes = [
                index
                for index, mspeak in enumerate(self.mspeaks)
                if mspeak.signal_to_noise <= min_s2n
            ]
        self.filter_by_index(indexes)

    def filter_by_abundance(self, min_abund, max_abund=False):
        """Filter the mass spectrum by the specified abundance range.

        Parameters
        ----------
        min_abund : float
            The minimum abundance to keep.
        max_abund : float, optional
            The maximum abundance to keep. Defaults to False (no maximum).

        """
        self.check_mspeaks_warning()
        if max_abund:
            indexes = [
                index
                for index, mspeak in enumerate(self.mspeaks)
                if not min_abund <= mspeak.abundance <= max_abund
            ]
        else:
            indexes = [
                index
                for index, mspeak in enumerate(self.mspeaks)
                if mspeak.abundance <= min_abund
            ]
        self.filter_by_index(indexes)

    def filter_by_max_resolving_power(self, B, T):
        """Filter the mass spectrum by the specified maximum resolving power.

        Parameters
        ----------
        B : float
        T : float

        """

        rpe = lambda m, z: (1.274e7 * z * B * T) / (m * z)

        self.check_mspeaks_warning()

        indexes_to_remove = [
            index
            for index, mspeak in enumerate(self.mspeaks)
            if mspeak.resolving_power >= rpe(mspeak.mz_exp, mspeak.ion_charge)
        ]
        self.filter_by_index(indexes_to_remove)

    def filter_by_mean_resolving_power(
        self, ndeviations=3, plot=False, guess_pars=False
    ):
        """Filter the mass spectrum by the specified mean resolving power.

        Parameters
        ----------
        ndeviations : float, optional
            The number of standard deviations to use for filtering. Defaults to 3.
        plot : bool, optional
            Whether to plot the resolving power distribution. Defaults to False.
        guess_pars : bool, optional
            Whether to guess the parameters for the Gaussian model. Defaults to False.

        """
        self.check_mspeaks_warning()
        indexes_to_remove = MeanResolvingPowerFilter(
            self, ndeviations, plot, guess_pars
        ).main()
        self.filter_by_index(indexes_to_remove)

    def filter_by_min_resolving_power(self, B, T, apodization_method: str=None, tolerance: float=0):
        """Filter the mass spectrum by the calculated minimum theoretical resolving power.

        This is currently designed only for FTICR data, and accounts only for magnitude mode data
        Accurate results require passing the apodisaion method used to calculate the resolving power.
        see the ICRMassPeak function `resolving_power_calc` for more details.

        Parameters
        ----------
        B : Magnetic field strength in Tesla, float
        T : transient length in seconds, float
        apodization_method : str, optional
            The apodization method to use for calculating the resolving power. Defaults to None.
        tolerance : float, optional
            The tolerance for the threshold. Defaults to 0, i.e. no tolerance

        """
        if self.analyzer != "ICR":
            raise Exception(
                "This method is only applicable to ICR mass spectra. "
            )

        self.check_mspeaks_warning()

        indexes_to_remove = [
            index
            for index, mspeak in enumerate(self.mspeaks)
            if mspeak.resolving_power < (1-tolerance) * mspeak.resolving_power_calc(B, T, apodization_method=apodization_method)
        ]
        self.filter_by_index(indexes_to_remove)

    def filter_by_noise_threshold(self):
        """Filter the mass spectrum by the noise threshold."""

        threshold = self.get_noise_threshold()[1][0]

        self.check_mspeaks_warning()

        indexes_to_remove = [
            index
            for index, mspeak in enumerate(self.mspeaks)
            if mspeak.abundance <= threshold
        ]
        self.filter_by_index(indexes_to_remove)

    def find_peaks(self):
        """Find the peaks of the mass spectrum."""
        # needs to clear previous results from peak_picking
        self._mspeaks = list()

        # then do peak picking
        self.do_peak_picking()
        # print("A total of %i peaks were found" % len(self._mspeaks))

    def change_kendrick_base_all_mspeaks(self, kendrick_dict_base):
        """Change the Kendrick base of all MSpeaks objects.

        Parameters
        ----------
        kendrick_dict_base : dict
            A dictionary of the Kendrick base to change to.

        Notes
        -----
        Example of kendrick_dict_base parameter: kendrick_dict_base = {"C": 1, "H": 2} or {"C": 1, "H": 1, "O":1} etc
        """
        self.parameters.ms_peak.kendrick_base = kendrick_dict_base

        for mspeak in self.mspeaks:
            mspeak.change_kendrick_base(kendrick_dict_base)

    def get_nominal_mz_first_last_indexes(self, nominal_mass):
        """Return the first and last indexes of the MSpeaks objects with the specified nominal mass.

        Parameters
        ----------
        nominal_mass : int
            The nominal mass to get the indexes for.

        Returns
        -------
        tuple
            A tuple containing the first and last indexes of the MSpeaks objects with the specified nominal mass.
        """
        if self._dict_nominal_masses_indexes:
            if nominal_mass in self._dict_nominal_masses_indexes.keys():
                return (
                    self._dict_nominal_masses_indexes.get(nominal_mass)[0],
                    self._dict_nominal_masses_indexes.get(nominal_mass)[1] + 1,
                )

            else:
                # import warnings
                # uncomment warn to distribution
                # warnings.warn("Nominal mass not found in _dict_nominal_masses_indexes, returning (0, 0) for nominal mass %i"%nominal_mass)
                return (0, 0)
        else:
            raise Exception(
                "run process_mass_spec() function before trying to access the data"
            )

    def get_masses_count_by_nominal_mass(self):
        """Return a dictionary of the nominal masses and their counts."""

        dict_nominal_masses_count = {}

        all_nominal_masses = list(set([i.nominal_mz_exp for i in self.mspeaks]))

        for nominal_mass in all_nominal_masses:
            if nominal_mass not in dict_nominal_masses_count:
                dict_nominal_masses_count[nominal_mass] = len(
                    list(self.get_nominal_mass_indexes(nominal_mass))
                )

        return dict_nominal_masses_count

    def datapoints_count_by_nominal_mz(self, mz_overlay=0.1):
        """Return a dictionary of the nominal masses and their counts.

        Parameters
        ----------
        mz_overlay : float, optional
            The m/z overlay to use for counting. Defaults to 0.1.

        Returns
        -------
        dict
            A dictionary of the nominal masses and their counts.
        """
        dict_nominal_masses_count = {}

        all_nominal_masses = list(set([i.nominal_mz_exp for i in self.mspeaks]))

        for nominal_mass in all_nominal_masses:
            if nominal_mass not in dict_nominal_masses_count:
                min_mz = nominal_mass - mz_overlay

                max_mz = nominal_mass + 1 + mz_overlay

                indexes = indexes = where(
                    (self.mz_exp_profile > min_mz) & (self.mz_exp_profile < max_mz)
                )

                dict_nominal_masses_count[nominal_mass] = indexes[0].size

        return dict_nominal_masses_count

    def get_nominal_mass_indexes(self, nominal_mass, overlay=0.1):
        """Return the indexes of the MSpeaks objects with the specified nominal mass.

        Parameters
        ----------
        nominal_mass : int
            The nominal mass to get the indexes for.
        overlay : float, optional
            The m/z overlay to use for counting. Defaults to 0.1.

        Returns
        -------
        generator
            A generator of the indexes of the MSpeaks objects with the specified nominal mass.
        """
        min_mz_to_look = nominal_mass - overlay
        max_mz_to_look = nominal_mass + 1 + overlay

        return (
            i
            for i in range(len(self.mspeaks))
            if min_mz_to_look <= self.mspeaks[i].mz_exp <= max_mz_to_look
        )

        # indexes = (i for i in range(len(self.mspeaks)) if min_mz_to_look <= self.mspeaks[i].mz_exp <= max_mz_to_look)
        # return indexes

    def _set_nominal_masses_start_final_indexes(self):
        """Set the start and final indexes of the MSpeaks objects for all nominal masses."""
        dict_nominal_masses_indexes = {}

        all_nominal_masses = set(i.nominal_mz_exp for i in self.mspeaks)

        for nominal_mass in all_nominal_masses:
            # indexes = self.get_nominal_mass_indexes(nominal_mass)
            # Convert the iterator to a list to avoid multiple calls
            indexes = list(self.get_nominal_mass_indexes(nominal_mass))

            # If the list is not empty, find the first and last; otherwise, set None
            if indexes:
                first, last = indexes[0], indexes[-1]
            else:
                first = last = None
            # defaultvalue = None
            # first = last = next(indexes, defaultvalue)
            # for last in indexes:
            #    pass

            dict_nominal_masses_indexes[nominal_mass] = (first, last)

        self._dict_nominal_masses_indexes = dict_nominal_masses_indexes

    def plot_centroid(self, ax=None, c="g"):
        """Plot the centroid data of the mass spectrum.

        Parameters
        ----------
        ax : matplotlib.axes.Axes, optional
            The matplotlib axes to plot on. Defaults to None.
        c : str, optional
            The color to use for the plot. Defaults to 'g' (green).

        Returns
        -------
        matplotlib.axes.Axes
            The matplotlib axes containing the plot.

        Raises
        ------
        Exception
            If no centroid data is found.
        """

        import matplotlib.pyplot as plt

        if self._mspeaks:
            if ax is None:
                ax = plt.gca()

            markerline_a, stemlines_a, baseline_a = ax.stem(
                self.mz_exp, self.abundance, linefmt="-", markerfmt=" "
            )

            plt.setp(markerline_a, "color", c, "linewidth", 2)
            plt.setp(stemlines_a, "color", c, "linewidth", 2)
            plt.setp(baseline_a, "color", c, "linewidth", 2)

            ax.set_xlabel("$\t{m/z}$", fontsize=12)
            ax.set_ylabel("Abundance", fontsize=12)
            ax.tick_params(axis="both", which="major", labelsize=12)

            ax.axes.spines["top"].set_visible(False)
            ax.axes.spines["right"].set_visible(False)

            ax.get_yaxis().set_visible(False)
            ax.spines["left"].set_visible(False)

        else:
            raise Exception("No centroid data found, please run process_mass_spec")

        return ax

    def plot_profile_and_noise_threshold(self, ax=None, legend=False):
        """Plot the profile data and noise threshold of the mass spectrum.

        Parameters
        ----------
        ax : matplotlib.axes.Axes, optional
            The matplotlib axes to plot on. Defaults to None.
        legend : bool, optional
            Whether to show the legend. Defaults to False.

        Returns
        -------
        matplotlib.axes.Axes
            The matplotlib axes containing the plot.

        Raises
        ------
        Exception
            If no noise threshold is found.
        """
        import matplotlib.pyplot as plt

        if self.baseline_noise is not None and self.baseline_noise_std is not None:
            # x = (self.mz_exp_profile.min(), self.mz_exp_profile.max())
            baseline = (self.baseline_noise, self.baseline_noise)

            # std = self.parameters.mass_spectrum.noise_threshold_min_std
            # threshold = self.baseline_noise_std + (std * self.baseline_noise_std)
            x, y = self.get_noise_threshold()

            if ax is None:
                ax = plt.gca()

            ax.plot(
                self.mz_exp_profile,
                self.abundance_profile,
                color="green",
                label="Spectrum",
            )
            ax.plot(x, (baseline, baseline), color="yellow", label="Baseline Noise")
            ax.plot(x, y, color="red", label="Noise Threshold")

            ax.set_xlabel("$\t{m/z}$", fontsize=12)
            ax.set_ylabel("Abundance", fontsize=12)
            ax.tick_params(axis="both", which="major", labelsize=12)

            ax.axes.spines["top"].set_visible(False)
            ax.axes.spines["right"].set_visible(False)

            ax.get_yaxis().set_visible(False)
            ax.spines["left"].set_visible(False)
            if legend:
                ax.legend()

        else:
            raise Exception("Calculate noise threshold first")

        return ax

    def plot_mz_domain_profile(self, color="green", ax=None):
        """Plot the m/z domain profile of the mass spectrum.

        Parameters
        ----------
        color : str, optional
            The color to use for the plot. Defaults to 'green'.
        ax : matplotlib.axes.Axes, optional
            The matplotlib axes to plot on. Defaults to None.

        Returns
        -------
        matplotlib.axes.Axes
            The matplotlib axes containing the plot.
        """

        import matplotlib.pyplot as plt

        if ax is None:
            ax = plt.gca()
        ax.plot(self.mz_exp_profile, self.abundance_profile, color=color)
        ax.set(xlabel="m/z", ylabel="abundance")

        return ax

    def to_excel(self, out_file_path, write_metadata=True):
        """Export the mass spectrum to an Excel file.

        Parameters
        ----------
        out_file_path : str
            The path to the Excel file to export to.
        write_metadata : bool, optional
            Whether to write the metadata to the Excel file. Defaults to True.

        Returns
        -------
        None
        """
        from corems.mass_spectrum.output.export import HighResMassSpecExport

        exportMS = HighResMassSpecExport(out_file_path, self)
        exportMS.to_excel(write_metadata=write_metadata)

    def to_hdf(self, out_file_path):
        """Export the mass spectrum to an HDF file.

        Parameters
        ----------
        out_file_path : str
            The path to the HDF file to export to.

        Returns
        -------
        None
        """
        from corems.mass_spectrum.output.export import HighResMassSpecExport

        exportMS = HighResMassSpecExport(out_file_path, self)
        exportMS.to_hdf()

    def to_csv(self, out_file_path, write_metadata=True):
        """Export the mass spectrum to a CSV file.

        Parameters
        ----------
        out_file_path : str
            The path to the CSV file to export to.
        write_metadata : bool, optional
            Whether to write the metadata to the CSV file. Defaults to True.

        """
        from corems.mass_spectrum.output.export import HighResMassSpecExport

        exportMS = HighResMassSpecExport(out_file_path, self)
        exportMS.to_csv(write_metadata=write_metadata)

    def to_pandas(self, out_file_path, write_metadata=True):
        """Export the mass spectrum to a Pandas dataframe with pkl extension.

        Parameters
        ----------
        out_file_path : str
            The path to the CSV file to export to.
        write_metadata : bool, optional
            Whether to write the metadata to the CSV file. Defaults to True.

        """
        from corems.mass_spectrum.output.export import HighResMassSpecExport

        exportMS = HighResMassSpecExport(out_file_path, self)
        exportMS.to_pandas(write_metadata=write_metadata)

    def to_dataframe(self, additional_columns=None):
        """Return the mass spectrum as a Pandas dataframe.

        Parameters
        ----------
        additional_columns : list, optional
            A list of additional columns to include in the dataframe. Defaults to None.
            Suitable columns are: "Aromaticity Index", "Aromaticity Index (modified)", and "NOSC"

        Returns
        -------
        pandas.DataFrame
            The mass spectrum as a Pandas dataframe.
        """
        from corems.mass_spectrum.output.export import HighResMassSpecExport

        exportMS = HighResMassSpecExport(self.filename, self)
        return exportMS.get_pandas_df(additional_columns=additional_columns)

    def to_json(self):
        """Return the mass spectrum as a JSON file."""
        from corems.mass_spectrum.output.export import HighResMassSpecExport

        exportMS = HighResMassSpecExport(self.filename, self)
        return exportMS.to_json()

    def parameters_json(self):
        """Return the parameters of the mass spectrum as a JSON string."""
        from corems.mass_spectrum.output.export import HighResMassSpecExport

        exportMS = HighResMassSpecExport(self.filename, self)
        return exportMS.parameters_to_json()

    def parameters_toml(self):
        """Return the parameters of the mass spectrum as a TOML string."""
        from corems.mass_spectrum.output.export import HighResMassSpecExport

        exportMS = HighResMassSpecExport(self.filename, self)
        return exportMS.parameters_to_toml()


class MassSpecProfile(MassSpecBase):
    """A mass spectrum class when the entry point is on profile format

    Notes
    -----
    Stores the profile data and instrument settings.
    Iteration over a list of MSPeaks classes stored at the _mspeaks attributes.
    _mspeaks is populated under the hood by calling process_mass_spec method.
    Iteration is null if _mspeaks is empty. Many more attributes and methods inherited from MassSpecBase().

    Parameters
    ----------
    data_dict : dict
        A dictionary containing the profile data.
    d_params : dict{'str': float, int or str}
        contains the instrument settings and processing settings
    auto_process : bool, optional
        Whether to automatically process the mass spectrum. Defaults to True.


    Attributes
    ----------
    _abundance : ndarray
        The abundance values of the mass spectrum.
    _mz_exp : ndarray
        The m/z values of the mass spectrum.
    _mspeaks : list
        A list of mass peaks.

    Methods
    ----------
    * process_mass_spec(). Process the mass spectrum.

    see also: MassSpecBase(), MassSpecfromFreq(), MassSpecCentroid()
    """

    def __init__(self, data_dict, d_params, auto_process=True):
        # print(data_dict.keys())
        super().__init__(
            data_dict.get(Labels.mz), data_dict.get(Labels.abundance), d_params
        )

        if auto_process:
            self.process_mass_spec()


class MassSpecfromFreq(MassSpecBase):
    """A mass spectrum class when data entry is on frequency domain

    Notes
    -----
    - Transform to m/z based on the settings stored at d_params
    - Stores the profile data and instrument settings
    - Iteration over a list of MSPeaks classes stored at the _mspeaks attributes
    - _mspeaks is populated under the hood by calling process_mass_spec method
    - iteration is null if _mspeaks is empty

    Parameters
    ----------
    frequency_domain : list(float)
        all datapoints in frequency domain in Hz
    magnitude :  frequency_domain : list(float)
        all datapoints in for magnitude of each frequency datapoint
    d_params : dict{'str': float, int or str}
        contains the instrument settings and processing settings
    auto_process : bool, optional
        Whether to automatically process the mass spectrum. Defaults to True.
    keep_profile : bool, optional
        Whether to keep the profile data. Defaults to True.

    Attributes
    ----------
    has_frequency : bool
        Whether the mass spectrum has frequency data.
    _frequency_domain : list(float)
        Frequency domain in Hz
    label : str
        store label (Bruker, Midas Transient, see Labels class ). It across distinct processing points
    _abundance : ndarray
        The abundance values of the mass spectrum.
    _mz_exp : ndarray
        The m/z values of the mass spectrum.
    _mspeaks : list
        A list of mass peaks.
    See Also: all the attributes of MassSpecBase class

    Methods
    ----------
    * _set_mz_domain().
        calculates the m_z based on the setting of d_params
    * process_mass_spec().  Process the mass spectrum.

    see also: MassSpecBase(), MassSpecProfile(), MassSpecCentroid()
    """

    def __init__(
        self,
        frequency_domain,
        magnitude,
        d_params,
        auto_process=True,
        keep_profile=True,
    ):
        super().__init__(None, magnitude, d_params)

        self._frequency_domain = frequency_domain
        self.has_frequency = True
        self._set_mz_domain()
        self._sort_mz_domain()

        self.magnetron_frequency = None
        self.magnetron_frequency_sigma = None

        # 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

        if auto_process:
            self.process_mass_spec(keep_profile=keep_profile)

    def _sort_mz_domain(self):
        """Sort the mass spectrum by m/z values."""

        if self._mz_exp[0] > self._mz_exp[-1]:
            self._mz_exp = self._mz_exp[::-1]
            self._abundance = self._abundance[::-1]
            self._frequency_domain = self._frequency_domain[::-1]

    def _set_mz_domain(self):
        """Set the m/z domain of the mass spectrum based on the settings of d_params."""
        if self.label == Labels.bruker_frequency:
            self._mz_exp = self._f_to_mz_bruker()

        else:
            self._mz_exp = self._f_to_mz()

    @property
    def transient_settings(self):
        """Return the transient settings of the mass spectrum."""
        return self.parameters.transient

    @transient_settings.setter
    def transient_settings(self, instance_TransientSetting):
        self.parameters.transient = instance_TransientSetting

    def calc_magnetron_freq(self, max_magnetron_freq=50, magnetron_freq_bins=300):
        """Calculates the magnetron frequency of the mass spectrum.

        Parameters
        ----------
        max_magnetron_freq : float, optional
            The maximum magnetron frequency. Defaults to 50.
        magnetron_freq_bins : int, optional
            The number of bins to use for the histogram. Defaults to 300.

        Returns
        -------
        None

        Notes
        -----
        Calculates the magnetron frequency by examining all the picked peaks and the distances between them in the frequency domain.
        A histogram of those values below the threshold 'max_magnetron_freq' with the 'magnetron_freq_bins' number of bins is calculated.
        A gaussian model is fit to this histogram - the center value of this (statistically probably) the magnetron frequency.
        This appears to work well or nOmega datasets, but may not work well for 1x datasets or those with very low magnetron peaks.
        """
        ms_df = DataFrame(self.freq_exp(), columns=["Freq"])
        ms_df["FreqDelta"] = ms_df["Freq"].diff()

        freq_hist = histogram(
            ms_df[ms_df["FreqDelta"] < max_magnetron_freq]["FreqDelta"],
            bins=magnetron_freq_bins,
        )

        mod = GaussianModel()
        pars = mod.guess(freq_hist[0], x=freq_hist[1][:-1])
        out = mod.fit(freq_hist[0], pars, x=freq_hist[1][:-1])
        self.magnetron_frequency = out.best_values["center"]
        self.magnetron_frequency_sigma = out.best_values["sigma"]


class MassSpecCentroid(MassSpecBase):
    """A mass spectrum class when the entry point is on centroid format

    Notes
    -----
    - Stores the centroid data and instrument settings
    - Simulate profile data based on Gaussian or Lorentzian peak shape
    - Iteration over a list of MSPeaks classes stored at the _mspeaks attributes
    - _mspeaks is populated under the hood by calling process_mass_spec method
    - iteration is null if _mspeaks is empty

    Parameters
    ----------
    data_dict : dict {string: numpy array float64 )
        contains keys [m/z, Abundance, Resolving Power, S/N]
    d_params : dict{'str': float, int or str}
        contains the instrument settings and processing settings
    auto_process : bool, optional
        Whether to automatically process the mass spectrum. Defaults to True.

    Attributes
    ----------
    label : str
        store label (Bruker, Midas Transient, see Labels class)
    _baseline_noise : float
        store baseline noise
    _baseline_noise_std : float
        store baseline noise std
    _abundance : ndarray
        The abundance values of the mass spectrum.
    _mz_exp : ndarray
        The m/z values of the mass spectrum.
    _mspeaks : list
        A list of mass peaks.


    Methods
    ----------
    * process_mass_spec().
        Process the mass spectrum. Overriden from MassSpecBase. Populates the _mspeaks list with MSpeaks class using the centroid data.
    * __simulate_profile__data__().
        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.

    see also: MassSpecBase(), MassSpecfromFreq(), MassSpecProfile()
    """

    def __init__(self, data_dict, d_params, auto_process=True):
        super().__init__([], [], d_params)

        self._set_parameters_objects(d_params)

        if self.label == Labels.thermo_centroid:
            self._baseline_noise = d_params.get("baseline_noise")
            self._baseline_noise_std = d_params.get("baseline_noise_std")

        self.is_centroid = True
        self.data_dict = data_dict
        self._mz_exp = data_dict[Labels.mz]
        self._abundance = data_dict[Labels.abundance]

        if auto_process:
            self.process_mass_spec()

    def __simulate_profile__data__(self, exp_mz_centroid, magnitude_centroid):
        """Simulate profile data based on Gaussian or Lorentzian peak shape

        Notes
        -----
        Needs theoretical resolving power calculation and define peak shape.
        This is a quick fix to trick a line plot be able to plot as sticks for plotting and inspection purposes only.

        Parameters
        ----------
        exp_mz_centroid : list(float)
            list of m/z values
        magnitude_centroid : list(float)
            list of abundance values


        Returns
        -------
        x : list(float)
            list of m/z values
        y : list(float)
            list of abundance values
        """

        x, y = [], []
        for i in range(len(exp_mz_centroid)):
            x.append(exp_mz_centroid[i] - 0.0000001)
            x.append(exp_mz_centroid[i])
            x.append(exp_mz_centroid[i] + 0.0000001)
            y.append(0)
            y.append(magnitude_centroid[i])
            y.append(0)
        return x, y

    @property
    def mz_exp_profile(self):
        """Return the m/z profile of the mass spectrum."""
        mz_list = []
        for mz in self.mz_exp:
            mz_list.append(mz - 0.0000001)
            mz_list.append(mz)
            mz_list.append(mz + 0.0000001)
        return mz_list

    @mz_exp_profile.setter
    def mz_exp_profile(self, _mz_exp):
        self._mz_exp = _mz_exp

    @property
    def abundance_profile(self):
        """Return the abundance profile of the mass spectrum."""
        ab_list = []
        for ab in self.abundance:
            ab_list.append(0)
            ab_list.append(ab)
            ab_list.append(0)
        return ab_list

    @abundance_profile.setter
    def abundance_profile(self, abundance):
        self._abundance = abundance

    @property
    def tic(self):
        """Return the total ion current of the mass spectrum."""
        return sum(self.abundance)

    def process_mass_spec(self):
        """Process the mass spectrum."""
        import tqdm

        # overwrite process_mass_spec
        # mspeak objs are usually added inside the PeaKPicking class
        # for profile and freq based data
        data_dict = self.data_dict
        ion_charge = self.polarity

        # Check if resolving power is present
        rp_present = True
        if not data_dict.get(Labels.rp):
            rp_present = False
        if rp_present and list(data_dict.get(Labels.rp)) == [None] * len(
            data_dict.get(Labels.rp)
        ):
            rp_present = False

        # Check if s2n is present
        s2n_present = True
        if not data_dict.get(Labels.s2n):
            s2n_present = False
        if s2n_present and list(data_dict.get(Labels.s2n)) == [None] * len(
            data_dict.get(Labels.s2n)
        ):
            s2n_present = False

        # Warning if no s2n data but noise thresholding is set to signal_noise
        if (
            not s2n_present
            and self.parameters.mass_spectrum.noise_threshold_method == "signal_noise"
        ):
            raise Exception("Signal to Noise data is missing for noise thresholding")

        # Pull out abundance data
        abun = array(data_dict.get(Labels.abundance)).astype(float)

        # Get the threshold for filtering if using minima, relative, or absolute abundance thresholding
        abundance_threshold, factor = self.get_threshold(abun)

        # Set rp_i and s2n_i to None which will be overwritten if present
        rp_i, s2n_i = np.nan, np.nan
        for index, mz in enumerate(data_dict.get(Labels.mz)):
            if rp_present:
                if not data_dict.get(Labels.rp)[index]:
                    rp_i = np.nan
                else:
                    rp_i = float(data_dict.get(Labels.rp)[index])
            if s2n_present:
                if not data_dict.get(Labels.s2n)[index]:
                    s2n_i = np.nan
                else:
                    s2n_i = float(data_dict.get(Labels.s2n)[index])

            # centroid peak does not have start and end peak index pos
            massspec_indexes = (index, index, index)

            # Add peaks based on the noise thresholding method
            if (
                self.parameters.mass_spectrum.noise_threshold_method
                in ["minima", "relative_abundance", "absolute_abundance"]
                and abun[index] / factor >= abundance_threshold
            ):
                self.add_mspeak(
                    ion_charge,
                    mz,
                    abun[index],
                    rp_i,
                    s2n_i,
                    massspec_indexes,
                    ms_parent=self,
                )
            if (
                self.parameters.mass_spectrum.noise_threshold_method == "signal_noise"
                and s2n_i >= self.parameters.mass_spectrum.noise_threshold_min_s2n
            ):
                self.add_mspeak(
                    ion_charge,
                    mz,
                    abun[index],
                    rp_i,
                    s2n_i,
                    massspec_indexes,
                    ms_parent=self,
                )

        self.mspeaks = self._mspeaks
        self._dynamic_range = self.max_abundance / self.min_abundance
        self._set_nominal_masses_start_final_indexes()

        if self.label != Labels.thermo_centroid:
            if self.settings.noise_threshold_method == "log":
                raise Exception("log noise Not tested for centroid data")
                # self._baseline_noise, self._baseline_noise_std = self.run_log_noise_threshold_calc()

            else:
                self._baseline_noise, self._baseline_noise_std = (
                    self.run_noise_threshold_calc()
                )

        del self.data_dict


class MassSpecCentroidLowRes(MassSpecCentroid):
    """A mass spectrum class when the entry point is on low resolution centroid format

    Notes
    -----
    Does not store MSPeak Objs, will iterate over mz, abundance pairs instead

    Parameters
    ----------
    data_dict : dict {string: numpy array float64 )
        contains keys [m/z, Abundance, Resolving Power, S/N]
    d_params : dict{'str': float, int or str}
        contains the instrument settings and processing settings

    Attributes
    ----------
    _processed_tic : float
        store processed total ion current
    _abundance : ndarray
        The abundance values of the mass spectrum.
    _mz_exp : ndarray
        The m/z values of the mass spectrum.
    """

    def __init__(self, data_dict, d_params):
        self._set_parameters_objects(d_params)
        self._mz_exp = array(data_dict.get(Labels.mz))
        self._abundance = array(data_dict.get(Labels.abundance))
        self._processed_tic = None

    def __len__(self):
        return len(self.mz_exp)

    def __getitem__(self, position):
        return (self.mz_exp[position], self.abundance[position])

    @property
    def mz_exp(self):
        """Return the m/z values of the mass spectrum."""
        return self._mz_exp

    @property
    def abundance(self):
        """Return the abundance values of the mass spectrum."""
        return self._abundance

    @property
    def processed_tic(self):
        """Return the processed total ion current of the mass spectrum."""
        return sum(self._processed_tic)

    @property
    def tic(self):
        """Return the total ion current of the mass spectrum."""
        if self._processed_tic:
            return self._processed_tic
        else:
            return sum(self.abundance)

    @property
    def mz_abun_tuples(self):
        """Return the m/z and abundance values of the mass spectrum as a list of tuples."""
        r = lambda x: (int(round(x[0], 0), int(round(x[1], 0))))

        return [r(i) for i in self]

    @property
    def mz_abun_dict(self):
        """Return the m/z and abundance values of the mass spectrum as a dictionary."""
        r = lambda x: int(round(x, 0))

        return {r(i[0]): r(i[1]) for i in self}