CoreMS 4.0.0__py3-none-any.whl

corems/mass_spectra/input/andiNetCDF.py

@@ -0,0 +1,200 @@
+__author__ = "Yuri E. Corilo"
+__date__ = "Feb 12, 2020"
+
+from pathlib import Path
+from threading import Thread
+# from io import BytesIO
+
+from netCDF4 import Dataset
+from s3path import S3Path
+
+from corems.encapsulation.constant import Labels
+from corems.encapsulation.factory.parameters import default_parameters
+from corems.mass_spectra.factory.GC_Class import GCMSBase
+from corems.mass_spectrum.factory.MassSpectrumClasses import MassSpecCentroidLowRes
+
+
+class ReadAndiNetCDF(Thread):
+    """
+    A class for reading AndiNetCDF files and extracting mass spectra data.
+
+    Parameters
+    -----------
+    file_location : str or Path
+            The location of the AndiNetCDF file.
+    analyzer : str, optional
+            The type of analyzer used (default is 'Quadruple').
+    instrument_label : str, optional
+            The label of the instrument (default is 'GCMS-Agilent').
+    auto_process : bool, optional
+            Whether to automatically process the data (default is True).
+
+    Attributes
+    -----------
+    file_location : Path
+            The path to the AndiNetCDF file.
+    net_cdf_obj : Dataset
+            The NetCDF dataset object.
+    ionization_type : str
+            The ionization type used in the experiment.
+    experiment_type : str
+            The type of experiment.
+    list_scans : range
+            The range of scan numbers in the dataset.
+    initial_scan_number : int
+            The number of the initial scan.
+    final_scan_number : int
+            The number of the final scan.
+    analyzer : str
+            The type of analyzer used.
+    instrument_label : str
+            The label of the instrument.
+    gcms : GCMSBase
+            The GCMSBase object for storing mass spectra data.
+
+    Methods
+    --------
+    * polarity().
+            Get the polarity of the ionization.
+    * get_mass_spectrum(mz, abun, rp, d_params).
+            Add a mass spectrum to the GCMSBase object.
+    * run().
+            Populate the GCMSBase object with mass spectra data.
+    * import_mass_spectra(d_params).
+            Import mass spectra data from the AndiNetCDF file.
+    * get_gcms_obj().
+            Get the GCMSBase object.
+
+    """
+
+    def __init__(
+        self,
+        file_location: str | Path,
+        analyzer="Quadruple",
+        instrument_label="GCMS-Agilent",
+        auto_process=True,
+    ):
+        Thread.__init__(self)
+
+        if isinstance(file_location, str):
+            self.file_location = Path(file_location)
+        else:
+            self.file_location = file_location
+
+        if not self.file_location.exists():
+            raise FileNotFoundError("File does not exist at %s", file_location)
+
+        if isinstance(file_location, S3Path):
+            bytes_io = self.file_location.open("rb").read()
+            self.net_cdf_obj = Dataset(
+                self.file_location.name,
+                "r",
+                diskless=True,
+                memory=bytes_io,
+                format="NETCDF3_CLASSIC",
+            )
+        else:
+            self.net_cdf_obj = Dataset(
+                self.file_location, "r", format="NETCDF3_CLASSIC"
+            )
+
+        self.ionization_type = self.net_cdf_obj.test_ionization_mode
+        self.experiment_type = self.net_cdf_obj.experiment_type
+        self.list_scans = range(
+            len(self.net_cdf_obj.variables.get("actual_scan_number")[:])
+        )
+        self.initial_scan_number = self.list_scans[0]
+        self.final_scan_number = self.list_scans[-1]
+        self.analyzer = analyzer
+        self.instrument_label = instrument_label
+        self.gcms = GCMSBase(self.file_location, analyzer, instrument_label)
+
+    @property
+    def polarity(self):
+        """
+        Get the polarity of the ionization.
+
+        """
+        polarity = str(self.net_cdf_obj.test_ionization_polarity)
+        if polarity == "Positive Polarity":
+            return +1
+        else:
+            return -1
+
+    def get_mass_spectrum(self, mz, abun, rp, d_params):
+        """
+        Add a mass spectrum to the GCMSBase object.
+
+        Parameters
+        -----------
+        mz : array-like
+                The m/z values of the mass spectrum.
+        abun : array-like
+                The abundance values of the mass spectrum.
+        rp : array-like
+                The resolution values of the mass spectrum.
+        d_params : dict
+                Additional parameters for the mass spectrum.
+
+        """
+        data_dict = {
+            Labels.mz: mz,
+            Labels.abundance: abun,
+            Labels.rp: rp,
+            Labels.s2n: None,
+        }
+        mass_spec = MassSpecCentroidLowRes(data_dict, d_params)
+        self.gcms.add_mass_spectrum(mass_spec)
+
+    def run(self):
+        """
+        Populate the GCMSBase object with mass spectra data.
+        """
+        d_parameters = default_parameters(self.file_location)
+        self.import_mass_spectra(d_parameters)
+
+    def import_mass_spectra(self, d_params):
+        """
+        Import mass spectra data from the AndiNetCDF file.
+
+        Parameters
+        -----------
+        d_params : dict
+                Additional parameters for the mass spectra.
+
+        """
+        ms_datapoints_per_scans = self.net_cdf_obj.variables.get("point_count")[:]
+        list_tic = self.net_cdf_obj.variables.get("total_intensity")[:]
+        list_rt = self.net_cdf_obj.variables.get("scan_acquisition_time")[:] / 60
+        mass_values = self.net_cdf_obj.variables.get("mass_values")[:]
+        intensity_values = self.net_cdf_obj.variables.get("intensity_values")[:]
+        resolution = self.net_cdf_obj.variables.get("resolution")[:]
+        individual_rp = len(mass_values) == len(resolution)
+        finish_location = -1
+        for scan_index in self.list_scans:
+            datapoints = ms_datapoints_per_scans[scan_index]
+            finish_location += datapoints
+            start_location = finish_location - datapoints + 1
+            d_params["rt"] = list_rt[scan_index]
+            d_params["scan_number"] = scan_index
+            d_params["label"] = Labels.gcms_centroid
+            d_params["polarity"] = self.polarity
+            d_params["analyzer"] = self.analyzer
+            d_params["instrument_label"] = self.instrument_label
+            mz = mass_values[start_location:finish_location]
+            abun = intensity_values[start_location:finish_location]
+            if individual_rp:
+                rp = resolution[start_location:finish_location]
+            else:
+                rp = [resolution[scan_index]] * datapoints
+            self.get_mass_spectrum(mz, abun, rp, d_params)
+        self.gcms.retention_time = list_rt
+        self.gcms.tic = list_tic
+        self.gcms.scans_number = self.list_scans
+
+    def get_gcms_obj(self):
+        """
+        Get the GCMSBase object.
+
+        """
+        return self.gcms

corems/mass_spectra/input/boosterHDF5.py

@@ -0,0 +1,216 @@
+__author__ = "Yuri E. Corilo"
+__date__ = "Oct 29, 2019"
+
+from threading import Thread
+from pathlib import Path
+from io import BytesIO
+
+import h5py
+from s3path import S3Path
+
+from corems.encapsulation.constant import Labels
+from corems.mass_spectrum.factory.MassSpectrumClasses import MassSpecProfile
+from corems.mass_spectra.factory.lc_class import LCMSBase
+from corems.encapsulation.factory.parameters import default_parameters
+
+
+class ReadHDF_BoosterMassSpectra(Thread):
+    """
+    Class for reading HDF5 files containing booster mass spectra.
+
+    Parameters
+    ----------
+    file_location : Path or S3Path
+        The full path to the HDF5 file.
+    analyzer : str, optional
+        The type of analyzer used for the mass spectra. Defaults to "ICR".
+    instrument_label : str, optional
+        The label of the instrument. Defaults to "21T".
+    auto_process : bool, optional
+        Whether to automatically process the mass spectra. Defaults to True.
+    """
+
+    def __init__(
+        self,
+        file_location: Path | S3Path,
+        analyzer="ICR",
+        instrument_label="21T",
+        auto_process=True,
+    ):
+        """
+        Initialize the ReadHDF_BoosterMassSpectra class.
+
+        Parameters
+        ----------
+        file_location : Path or S3Path
+            The full path to the HDF5 file.
+        analyzer : str, optional
+            The type of analyzer used for the mass spectra. Defaults to "ICR".
+        instrument_label : str, optional
+            The label of the instrument. Defaults to "21T".
+        auto_process : bool, optional
+            Whether to automatically process the mass spectra. Defaults to True.
+        """
+        Thread.__init__(self)
+
+        if isinstance(file_location, str):
+            # if obj is a string it defaults to create a Path obj, pass the S3Path if needed
+            self.file_location = Path(file_location)
+
+        self.lcms = LCMSBase(
+            file_location, analyzer=analyzer, instrument_label=instrument_label
+        )
+
+        if isinstance(file_location, S3Path):
+            data = BytesIO(file_location.open("rb").read())
+        else:
+            data = file_location
+
+        self.hdf_obj = h5py.File(data, "r")
+
+        self.list_scans = sorted([int(i) for i in list(self.hdf_obj.keys())])
+
+        self.initial_scan_number = self.list_scans[0]
+
+        self.final_scan_number = self.list_scans[-1]
+
+        self.file_location = file_location
+
+        self.auto_process = True
+
+        self.analyzer = analyzer
+
+        self.instrument_label = instrument_label
+
+    def get_polarity(self, file_location: Path | S3Path, scan: int):
+        """
+        Get the polarity of a scan.
+
+        Parameters
+        ----------
+        file_location : Path or S3Path
+            The full path to the HDF5 file.
+        scan : int
+            The scan number.
+
+        """
+        if isinstance(file_location, S3Path):
+            data = BytesIO(file_location.open("rb").read())
+        else:
+            data = file_location
+
+        self.h5pydata = h5py.File(data, "r")
+
+        self.scans = list(self.h5pydata.keys())
+
+        polarity = self.get_attr_data(scan, "r_h_polarity")
+
+        if polarity == "negative scan":
+            return -1
+        else:
+            return +1
+
+    def get_attr_data(self, scan, attr_srt):
+        """
+        Get the attribute data of a scan.
+
+        Parameters
+        ----------
+        scan : int
+            The scan number.
+        attr_srt : str
+            The attribute name.
+
+        """
+        return self.hdf_obj[str(scan)].attrs[attr_srt]
+
+    def import_mass_spectra(self, d_params: dict):
+        """
+        Import the mass spectra from the HDF5 file.
+
+        Parameters
+        ----------
+        d_params : dict
+            The parameters for importing the mass spectra.
+        """
+        list_rt, list_tic = list(), list()
+
+        for scan_number in self.list_scans:
+            d_params["rt"] = list_rt.append(
+                self.get_attr_data(scan_number, "r_h_start_time")
+            )
+
+            d_params["scan_number"] = scan_number
+
+            d_params["label"] = Labels.booster_profile
+
+            d_params["polarity"] = self.get_polarity(self.file_location, scan_number)
+
+            d_params["Aterm"] = self.get_attr_data(scan_number, "r_cparams")[0]
+
+            d_params["Bterm"] = self.get_attr_data(scan_number, "r_cparams")[1]
+
+            d_params["analyzer"] = self.analyzer
+
+            d_params["instrument_label"] = self.instrument_label
+
+            list_rt.append(d_params["rt"])
+
+            list_tic.append(self.get_attr_data(scan_number, "r_h_tic"))
+
+            mass_spec = self.get_mass_spectrum(scan_number, d_params)
+
+            self.lcms.add_mass_spectrum(mass_spec)
+
+        self.lcms.retention_time = list_rt
+        self.lcms.tic = list_tic
+        self.lcms.scans_number = self.list_scans
+
+    def get_mass_spectrum(self, scan: int, d_params: dict):
+        """
+        Get the mass spectrum for a scan.
+
+        Parameters
+        ----------
+        scan : int
+            The scan number.
+        d_params : dict
+            The parameters for creating the mass spectrum.
+
+        """
+        booster_data = self.hdf_obj[str(scan)]
+
+        if booster_data.shape[0] != 2:
+            raise NotImplementedError(
+                "opening transient, needs read raw file here, get bandwidth, create transient class and then the mass spectrum"
+            )
+        else:
+            data_dict = {
+                Labels.mz: booster_data[0],
+                Labels.abundance: booster_data[1],
+                Labels.rp: None,
+                Labels.s2n: None,
+            }
+
+            mass_spec = MassSpecProfile(
+                data_dict, d_params, auto_process=self.auto_process
+            )
+
+        return mass_spec
+
+    def run(self):
+        """
+        Run the thread to create the LCMS object.
+        """
+        d_parameters = default_parameters(self.file_location)
+        self.import_mass_spectra(d_parameters)
+
+    def get_lcms_obj(self):
+        """
+        Get the LCMS object.
+
+        """
+        if len(self.lcms) > 0:
+            return self.lcms
+        else:
+            raise Exception("Returning an empty LCMS class")

corems/mass_spectra/input/brukerSolarix.py

@@ -0,0 +1,153 @@
+__author__ = "Yuri E. Corilo"
+__date__ = "Oct 29, 2019"
+
+from threading import Thread
+from pathlib import Path
+from s3path import S3Path
+
+# import h5py
+
+# from corems.encapsulation.constant import Labels
+from corems.mass_spectra.factory.lc_class import LCMSBase
+
+# from corems.encapsulation.factory.parameters import default_parameters
+from corems.transient.input.brukerSolarix import ReadBrukerSolarix
+
+from corems.mass_spectra.input.brukerSolarix_utils import get_scan_attributes
+
+
+class ReadBruker_SolarixTransientMassSpectra(Thread):
+    """
+    Class for reading Bruker Solarix Transient Mass Spectra.
+
+    Parameters
+    ----------
+    d_directory_location : str, pathlib.Path, or s3path.S3Path
+        Path object from pathlib containing the file location.
+    analyzer : str, optional
+        Type of analyzer used in the mass spectrometer. Defaults to "ICR".
+    instrument_label : str, optional
+        Label for the instrument. Defaults to "15T".
+    auto_process : bool, optional
+        Flag indicating whether to automatically process the mass spectra. Defaults to True.
+    keep_profile : bool, optional
+        Flag indicating whether to keep the profile data in the mass spectra. Defaults to False.
+    """
+
+    def __init__(
+        self,
+        d_directory_location: str | Path | S3Path,
+        analyzer="ICR",
+        instrument_label="15T",
+        auto_process=True,
+        keep_profile=False,
+    ):
+        Thread.__init__(self)
+
+        if isinstance(d_directory_location, str):
+            # if obj is a string it defaults to create a Path obj, pass the S3Path if needed
+            d_directory_location = Path(d_directory_location)
+
+        if not d_directory_location.exists():
+            raise FileNotFoundError("File does not exist: " + str(d_directory_location))
+
+        self.scan_attr = d_directory_location / "scan.xml"
+        self.imaging_info_attr = d_directory_location / "ImagingInfo.xml"
+
+        if not self.scan_attr.exists():
+            raise FileExistsError(
+                "%s does not seem to be a valid Solarix Mass Spectra Experiment,\
+                                maybe an Imaging experiment?\
+                                please ReadBruker_SolarixTransientImage class for Imaging dataset "
+                % d_directory_location
+            )
+
+        self.lcms = LCMSBase(d_directory_location, analyzer, instrument_label)
+
+        self.auto_process = auto_process
+        self.keep_profile = keep_profile
+
+    def get_scan_attr(self) -> dict:
+        """
+        Get the scan attributes from the scan.xml or ImagingInfo.xml file.
+        If the scan.xml file exists, it will be used; otherwise, it will look for ImagingInfo.xml.
+        If neither file exists, a FileNotFoundError will be raised.
+
+
+        TODO: - This function is replicated in the corems.transient.input.brukerSolarix module,
+                consider refactoring to avoid duplication.
+
+        Returns
+        -------
+        dict
+            Dictionary containing the scan number as key and a tuple of retention time and TIC as value.
+        """
+        return get_scan_attributes(self.scan_attr, self.imaging_info_attr)
+
+    def import_mass_spectra(self) -> None:
+        """
+        Import the mass spectra from the scan.xml file.
+        """
+        dict_scan_rt_tic = self.get_scan_attr()
+
+        list_rt, list_tic = (
+            list(),
+            list(),
+        )
+
+        list_scans = sorted(list(dict_scan_rt_tic.keys()))
+
+        for scan_number in list_scans:
+            mass_spec = self.get_mass_spectrum(scan_number)
+
+            self.lcms.add_mass_spectrum(mass_spec)
+
+            list_rt.append(dict_scan_rt_tic.get(scan_number)[0])
+
+            list_tic.append(dict_scan_rt_tic.get(scan_number)[1])
+
+        self.lcms.retention_time = list_rt
+        self.lcms.tic = list_tic
+        self.lcms.scans_number = list_scans
+
+    def get_mass_spectrum(self, scan_number: int):
+        """
+        Get the mass spectrum for a given scan number.
+
+        Parameters
+        ----------
+        scan_number : int
+            Scan number.
+
+        """
+        bruker_reader = ReadBrukerSolarix(self.lcms.file_location)
+
+        bruker_transient = bruker_reader.get_transient(scan_number)
+
+        mass_spec = bruker_transient.get_mass_spectrum(
+            plot_result=False,
+            auto_process=self.auto_process,
+            keep_profile=self.keep_profile,
+        )
+
+        return mass_spec
+
+    def run(self):
+        """
+        Run the import_mass_spectra method.
+        """
+        self.import_mass_spectra()
+
+    def get_lcms_obj(self):
+        """
+        Get the LCMSBase object.
+
+        Raises
+        ------
+        Exception
+            If the LCMSBase object is empty.
+        """
+        if self.lcms:
+            return self.lcms
+        else:
+            raise Exception("Returning an empty LCMSBase class.")

corems/mass_spectra/input/brukerSolarix_utils.py

@@ -0,0 +1,73 @@
+"""Utility functions for Bruker data processing."""
+
+from pathlib import Path
+from s3path import S3Path
+
+
+def get_scan_attributes(scan_attr, imaging_info_attr) -> dict:
+    """
+    Get the scan attributes from the scan.xml or ImagingInfo.xml file.
+    
+    Parameters
+    ----------
+    d_directory_location : str, Path, or S3Path
+        Directory containing the XML files
+        
+    Returns
+    -------
+    dict
+        Dictionary containing the scan number as key and a tuple of retention time, TIC, 
+        and optionally maxpeak and spotname as values.
+
+
+    TODO: We need to reformat the dictionary to actually include keys and values so it is self-descriptive.
+    TODO: This will break the code, so a new version is needed. 
+    TODO: Will need to make sure theres tests which capture this change.
+    
+    """
+    from bs4 import BeautifulSoup
+    
+    scan_xml_exists = scan_attr.exists()
+    imaging_info_exists = imaging_info_attr.exists()
+
+    if scan_xml_exists:
+        try:
+            soup = BeautifulSoup(scan_attr.open(), "xml")
+            list_rt = [float(rt.text) for rt in soup.find_all("minutes")]
+            list_tic = [float(tic.text) for tic in soup.find_all("tic")]
+            list_scan = [int(scan.text) for scan in soup.find_all("count")]
+            
+            # Check if maxpeak exists (more comprehensive version)
+            # TODO: Enable this, but it could break code so a new version is needed
+            enable_maxpeak = False
+            if enable_maxpeak:
+                maxpeak_elements = soup.find_all("maxpeak")
+                if maxpeak_elements:
+                    list_maxpeak = [float(maxpeak.text) for maxpeak in maxpeak_elements]
+                    dict_scan_rt_tic = dict(zip(list_scan, zip(list_rt, list_tic, list_maxpeak)))
+                else:
+                    dict_scan_rt_tic = dict(zip(list_scan, zip(list_rt, list_tic)))
+
+            dict_scan_rt_tic = dict(zip(list_scan, zip(list_rt, list_tic)))
+
+            return dict_scan_rt_tic
+        except Exception as e:
+            raise FileNotFoundError(f"Error reading scan.xml: {e}")
+    elif imaging_info_exists:
+        try:
+            soup = BeautifulSoup(imaging_info_attr.open(), "xml")
+            list_rt = [float(rt.text) for rt in soup.find_all("minutes")]
+            list_tic = [float(tic.text) for tic in soup.find_all("tic")]
+            list_maxpeak = [float(maxpeak.text) for maxpeak in soup.find_all("maxpeak")]
+            list_scan = [int(scan.find("count").text) for scan in soup.find_all("scan")]
+            list_spotname = [
+                scan.find("spotName").text for scan in soup.find_all("scan")
+            ]
+            dict_scan_rt_tic = dict(zip(list_scan, zip(list_rt, list_tic, list_maxpeak, list_spotname)))
+            return dict_scan_rt_tic
+        except Exception as e:
+            raise FileNotFoundError(f"Error reading ImagingInfo.xml: {e}")
+    else:
+        raise FileNotFoundError(
+            "Dataset does not contain a 'scan.xml' or 'ImagingInfo.xml' file."
+        )