CoreMS 4.0.0__py3-none-any.whl

examples/archive/scripts/LCMS_isotopes.py

@@ -0,0 +1,283 @@
+##### CWD 2021-09-29
+####Replicate isotope pattern algorithm in python for a single file and peak pair.
+
+import warnings
+warnings.filterwarnings("ignore")
+
+import sys
+sys.path.append("./")
+
+from tqdm import tqdm 
+
+import os
+import pandas as pd
+import numpy as np
+
+from pathlib import Path
+
+import matplotlib.pyplot as plt
+# from PySide2.QtWidgets import QFileDialog, QApplication
+# from PySide2.QtCore import Qt
+
+from corems.mass_spectra.input import rawFileReader
+from corems.molecular_id.factory.classification import HeteroatomsClassification, Labels
+from corems.molecular_id.search.priorityAssignment import OxygenPriorityAssignment
+from corems.molecular_id.search.molecularFormulaSearch import SearchMolecularFormulas
+from corems.encapsulation.factory.parameters import MSParameters
+
+
+#set file here
+file_location = "tests/tests_data/icpms/rmb_161221_kansas_h2o_2"
+
+#Set peak detection threshold method
+MSParameters.mass_spectrum.noise_threshold_method = 'relative_abundance'
+MSParameters.mass_spectrum.noise_threshold_min_relative_abundance = 1
+
+MSParameters.mass_spectrum.noise_threshold_method = 'log'
+MSParameters.mass_spectrum.noise_threshold_min_s2n = 10
+
+#Parser for thermo RAW files. 
+parser = rawFileReader.ImportMassSpectraThermoMSFileReader(file_location)
+
+t_ion_chromatogram = parser.get_tic()
+
+t_ion_subset=t_ion_chromatogram[(t_ion_chromatogram["Time"]>8) & (t_ion_chromatogram["Time"]<9)]
+
+#print(t_ion_chromatogram['Time'])
+#print(parser.start_scan)
+#print(parser.end_scan)
+
+
+#Function for obtaining extracted ion chromatogram 
+def get_EIC(parser,mass,dmz,scanrange):
+    
+    EIC = np.zeros((len(scanrange),3))  ## scan, time, eic
+    EIC[:,0] = scanrange
+    for scan in tqdm(scanrange, desc = 'extracting ion chromatogram'):    
+
+        scanStatistics = parser.iRawDataPlus.GetScanStatsForScanNumber(scan)
+        EIC[np.where(EIC[:,0] == scan),1] = scanStatistics.StartTime
+
+        current_dictionary = parser.get_data(scan,1,scan_type="Profile")
+        current = np.zeros((len(current_dictionary['m/z']),2))
+        current[:,0] = current_dictionary['m/z']
+        current[:,1] = current_dictionary['Peak Height']
+        subset = current[abs(current[:,0] - mass) < dmz]
+
+        EIC[np.where(EIC[:,0] == scan),2] =sum(subset[:,1])
+    return(EIC)
+
+scanrange=range(parser.start_scan,parser.end_scan)
+mass=677
+dmz=1
+
+EIC=get_EIC(parser,mass,dmz,scanrange)
+
+fig, host = plt.subplots()
+host.plot(EIC[:,1],EIC[:,2])
+host.set_xlabel('Time (min)')
+host.set_ylabel('Intensity (counts)')
+plt.show()
+
+
+
+
+#Get MS1 scans numbers only.
+first_scan = parser.start_scan
+final_scan =parser.end_scan
+scanrange = range(first_scan, final_scan)
+
+MSn = np.zeros((len(scanrange),3))  ## scan, time, n
+MSn[:,0] = scanrange
+for scan in tqdm(range(parser.start_scan, parser.end_scan), desc = 'extracting MS1 scans'):    
+
+	scanStatistics = parser.iRawDataPlus.GetScanStatsForScanNumber(scan)
+	MSn[np.where(MSn[:,0] == scan),1] = scanStatistics.StartTime
+	MSn[np.where(MSn[:,0] == scan),2] = int(parser.get_scan_header(scan)['Master Scan Number:'])
+
+
+MS1scans=MSn[np.where(MSn[:,2] == 0)]
+#MS1scans={'scan':MS1scans[:,0], 'time':MS1scans[:,1], 'n':MS1scans[:,2]}
+#MSn_dict={'scan':MSn[:,0], 'time':MSn[:,1], 'n':MSn[:,2]}
+#scanrange=MS1scans['scan']
+scanrange=MS1scans[:,0]
+
+mass=677
+dmz=1
+
+EIC=get_EIC(parser,mass,dmz,scanrange)
+
+fig, host = plt.subplots()
+host.plot(EIC[:,1],EIC[:,2])
+host.set_xlabel('Time (min)')
+host.set_ylabel('Intensity (counts)')
+plt.show()
+
+
+
+#Import LC-ICPMS data and plot it:
+
+import csv
+
+icpfile = "tests/tests_data/icpms/161220_soils_hypercarb_3_kansas_qH2O.csv"
+
+icpdata = np.genfromtxt(icpfile, dtype=float, delimiter=',', names=True) 
+
+fig, host = plt.subplots()
+host.plot(icpdata['Time_56Fe'],icpdata['56Fe'])
+host.set_xlabel('Time (s)')
+host.set_ylabel('56Fe intensity (counts)')
+plt.show()
+
+fig, host = plt.subplots()
+host.plot(icpdata['Time_63Cu'],icpdata['63Cu'])
+host.set_xlabel('Time (s)')
+host.set_ylabel('63Cu intensity (counts)')
+plt.show()
+
+fig, host = plt.subplots()
+host.plot(icpdata['Time_59Co'],icpdata['59Co'])
+host.set_xlabel('Time (s)')
+host.set_ylabel('59Co intensity (counts)')
+plt.show()
+
+
+
+
+#Pick out a time-slice of the ICPMS data that will be correlated w/ EIC data. 
+
+timestart=535
+timestop=575
+icpi="59Co"
+icpt="Time_" + icpi
+icpslice = icpdata[np.where((icpdata[icpt] >= timestart) & (icpdata[icpt] <= timestop))]
+
+fig, host = plt.subplots()
+host.plot(icpslice[icpt],icpslice[icpi])
+host.set_xlabel('Time (s)')
+host.set_ylabel(icpi+' intensity (counts)')
+plt.show()
+
+
+
+#Correlate every ESIMS mz detected across the time range with the metal intensity. 
+#This section obtains EIC's for every m/z over the time range. 
+
+MS1scans=MSn[np.where(MSn[:,2] == 0)]
+scans=MS1scans[np.where((MS1scans[:,1] >= timestart/60) & (MS1scans[:,1] <= timestop/60))][:,0].tolist()
+parser.chromatogram_settings.scans = scans
+
+AverageMS = parser.get_average_mass_spectrum()
+AverageMS.plot_mz_domain_profile()
+
+plt.show()
+
+print(AverageMS.mz_exp.size)
+
+scanrange=scans
+
+EICdict = {}
+
+for mz in AverageMS.mz_exp[1:20]:
+    #EIC = pd.DataFrame(index=scanrange, columns=['Time', 'EIC'])
+    EIC = np.zeros((len(scanrange),3))  ## scan, time, eic
+    EIC[:,0] = scanrange   
+    mass=mz
+    dmz=0.002
+    print('m/z: ',mz)
+    EIC=get_EIC(parser,mass,dmz,scanrange)
+    EICdict[mz]=EIC
+
+# sums all the mass spectra
+mass_spectrum = parser.get_average_mass_spectrum()
+
+
+mass_spectrum.plot_mz_domain_profile()
+plt.show()
+
+mass_spectrum.plot_profile_and_noise_threshold()
+plt.show()
+
+
+mass_spectrum.molecular_search_settings.error_method = 'None'
+mass_spectrum.molecular_search_settings.min_ppm_error = -5
+mass_spectrum.molecular_search_settings.max_ppm_error = 5
+
+mass_spectrum.molecular_search_settings.url_database = None
+mass_spectrum.molecular_search_settings.min_dbe = 0
+mass_spectrum.molecular_search_settings.max_dbe = 50
+
+mass_spectrum.molecular_search_settings.usedAtoms['C'] = (1, 100)
+mass_spectrum.molecular_search_settings.usedAtoms['H'] = (4, 200)
+mass_spectrum.molecular_search_settings.usedAtoms['O'] = (1, 30)
+mass_spectrum.molecular_search_settings.usedAtoms['N'] = (0, 0)
+mass_spectrum.molecular_search_settings.usedAtoms['S'] = (0, 0)
+mass_spectrum.molecular_search_settings.usedAtoms['Cl'] = (0, 0)
+mass_spectrum.molecular_search_settings.usedAtoms['Br'] = (0, 0)
+mass_spectrum.molecular_search_settings.usedAtoms['P'] = (0, 0)
+mass_spectrum.molecular_search_settings.usedAtoms['Na'] = (0, 0)
+
+mass_spectrum.molecular_search_settings.isProtonated = True
+mass_spectrum.molecular_search_settings.isRadical = False
+mass_spectrum.molecular_search_settings.isAdduct = False
+
+# mass_spectrum.filter_by_max_resolving_power(15, 2)
+SearchMolecularFormulas(mass_spectrum, first_hit=False).run_worker_mass_spectrum()
+
+mass_spectrum.percentile_assigned(report_error=True)
+mass_spectrum.molecular_search_settings.score_method = "prob_score"
+mass_spectrum.molecular_search_settings.output_score_method = "prob_score"
+
+# export_calc_isotopologues(mass_spectrum, "15T_Neg_ESI_SRFA_Calc_Isotopologues")
+
+mass_spectrum_by_classes = HeteroatomsClassification(mass_spectrum, choose_molecular_formula=True)
+
+mass_spectrum_by_classes.plot_ms_assigned_unassigned()
+plt.show()
+mass_spectrum_by_classes.plot_mz_error()
+plt.show()
+mass_spectrum_by_classes.plot_ms_class("O2")
+plt.show()
+
+
+
+
+mass_spectrum.molecular_search_settings.error_method = 'None'
+mass_spectrum.molecular_search_settings.min_ppm_error = -2
+mass_spectrum.molecular_search_settings.max_ppm_error = 4
+
+mass_spectrum.molecular_search_settings.url_database = None
+mass_spectrum.molecular_search_settings.min_dbe = 0
+mass_spectrum.molecular_search_settings.max_dbe = 50
+
+mass_spectrum.molecular_search_settings.usedAtoms['C'] = (1, 100)
+mass_spectrum.molecular_search_settings.usedAtoms['H'] = (4, 200)
+mass_spectrum.molecular_search_settings.usedAtoms['O'] = (1, 30)
+mass_spectrum.molecular_search_settings.usedAtoms['N'] = (0, 6)
+mass_spectrum.molecular_search_settings.usedAtoms['S'] = (0, 0)
+mass_spectrum.molecular_search_settings.usedAtoms['Cl'] = (0, 0)
+mass_spectrum.molecular_search_settings.usedAtoms['Br'] = (0, 0)
+mass_spectrum.molecular_search_settings.usedAtoms['P'] = (0, 0)
+mass_spectrum.molecular_search_settings.usedAtoms['Na'] = (0, 0)
+
+mass_spectrum.molecular_search_settings.isProtonated = True
+mass_spectrum.molecular_search_settings.isRadical = False
+mass_spectrum.molecular_search_settings.isAdduct = False
+
+# mass_spectrum.filter_by_max_resolving_power(15, 2)
+SearchMolecularFormulas(mass_spectrum, first_hit=False).run_worker_mass_spectrum()
+
+mass_spectrum.percentile_assigned(report_error=True)
+mass_spectrum.molecular_search_settings.score_method = "prob_score"
+mass_spectrum.molecular_search_settings.output_score_method = "prob_score"
+
+# export_calc_isotopologues(mass_spectrum, "15T_Neg_ESI_SRFA_Calc_Isotopologues")
+
+mass_spectrum_by_classes = HeteroatomsClassification(mass_spectrum, choose_molecular_formula=True)
+
+mass_spectrum_by_classes.plot_ms_assigned_unassigned()
+plt.show()
+mass_spectrum_by_classes.plot_mz_error()
+plt.show()
+mass_spectrum_by_classes.plot_ms_class("O2")
+plt.show()

examples/archive/scripts/MSParams_example.py

@@ -0,0 +1,21 @@
+# This script demonstrates how to set global parameters and instantiate a mass spectrum object using them
+
+from corems.encapsulation.factory.parameters import MSParameters
+from corems.transient.input.brukerSolarix import ReadBrukerSolarix
+
+# Set global parameters and instantiate a mass spectrum object using them
+## Note that the default noise_threshold_method is 'log'
+MSParameters.mass_spectrum.noise_threshold_method = 'relative_abundance'
+
+parser = ReadBrukerSolarix("tests/tests_data/ftms/ESI_NEG_SRFA.d")
+bruker_transient = parser.get_transient()
+mass_spectrum_i = bruker_transient.get_mass_spectrum(plot_result=False, auto_process=False)
+print(mass_spectrum_i.parameters.mass_spectrum.noise_threshold_method) # relative_abundance
+
+# Create a new MSParameters instance with default parameters and assign it to the mass spectrum object
+new_msparams = MSParameters(use_defaults=True)
+mass_spectrum_i.parameters = new_msparams
+print(mass_spectrum_i.parameters.mass_spectrum.noise_threshold_method) # log
+
+
+

examples/archive/scripts/Molecular Formula Data Aggreation.py

@@ -0,0 +1,84 @@
+
+from pathlib import Path
+
+import pandas as pd
+
+def merge_files(file_paths: list, output_filename:str, variable: str = 'Peak Height'):
+
+        master_data_dict = []
+        list_filenames = []
+        for filepath in file_paths:
+            
+            filepath = Path(filepath)
+            
+            with filepath.open('r') as f:
+                
+                #data = json.loads(json.load(f))
+                
+                df = pd.read_csv(f)
+                idx = df.groupby(['Molecular Formula'])['Confidence Score'].transform(max) == df['Confidence Score']
+
+                df = df[idx]
+                df.fillna(0, inplace=True)
+
+                name_column = "{} ({})".format(variable, filepath.stem)
+                
+                df.rename({variable: name_column}, inplace=True, axis=1)
+
+                list_filenames.append(name_column)
+                master_data_dict.extend(df.to_dict('records'))
+
+        formula_dict = {}
+        for record in master_data_dict:
+            molecular_formula = record.get('Molecular Formula')
+            
+            if molecular_formula in formula_dict.keys():
+                formula_dict[molecular_formula].append(record)
+            else:
+                formula_dict[molecular_formula] = [record]
+        
+        def dict_mean(dict_list, average_keys):
+            mean_dict = {}
+            
+            for key in average_keys:
+                
+                mean_dict[key] = sum(d[key] for d in dict_list) / len(dict_list)
+            
+            return mean_dict
+            
+        average_records = []
+        
+        average_keys = ['m/z', 'Calibrated m/z', 'Calculated m/z', 'Peak Area', 'Resolving Power', 'S/N', 'm/z Error (ppm)', 'm/z Error Score', 
+                        'Isotopologue Similarity', 'Mono Isotopic Index', 'Confidence Score']
+        average_keys.extend(list_filenames)
+
+        for formula, records in formula_dict.items():
+            
+            #mean_dict = dict_mean(records, average_keys)
+            mean_dict = {}
+            for record in  records: 
+                #get the selected variable
+                for filename in list_filenames:
+                    if filename in record.keys():
+                        mean_dict[filename] = record[filename]
+                
+            for record in  records: 
+                #than get the rest of the data
+                for key in record.keys():
+                    if key not in average_keys:
+                        mean_dict[key] = record[key]
+        
+            average_records.append(mean_dict)                
+        master_df = pd.DataFrame(average_records)
+        
+        master_df.set_index('Molecular Formula', inplace=True)
+        print(master_df)
+
+        master_df.to_csv('{}.csv'.format(output_filename))
+        #grouped = master_df.groupby(["Molecular Formula", "Sample Name", "Peak Height"])
+
+if __name__ == '__main__':
+    
+    file_paths = ['tests/tests_data/ftms/Auto_SRFA_QC.csv', 'tests/tests_data/ftms/Auto_SRFA_QC II.csv']
+    output_path = 'test_aggregation'
+    merge_files(file_paths, output_path)

examples/archive/scripts/Single Mz Search.py

@@ -0,0 +1,69 @@
+import pprint, sys
+from pathlib import Path
+
+
+sys.path.append("./")
+from corems.encapsulation.factory.parameters import MSParameters
+from corems.encapsulation.input import parameter_from_json
+from corems.mass_spectrum.input.numpyArray import ms_from_array_centroid
+from corems.molecular_id.search.molecularFormulaSearch import SearchMolecularFormulas
+
+
+def run_molecular_formula_search(mz, parameters_filepath=None):
+    
+    mz = [mz]
+    abundance = [1]
+    rp, s2n = [[1],[1]]
+    
+    MSParameters.mass_spectrum.noise_threshold_method = 'relative_abundance'
+    MSParameters.mass_spectrum.noise_threshold_absolute_abundance = 0 
+    
+    MSParameters.molecular_search.url_database = ''
+    MSParameters.molecular_search.error_method = 'None'
+    MSParameters.molecular_search.min_ppm_error  = -10
+    MSParameters.molecular_search.max_ppm_error = 10
+    MSParameters.molecular_search.mz_error_range = 1
+    MSParameters.molecular_search.isProtonated = True 
+    MSParameters.molecular_search.isRadical= False 
+    MSParameters.molecular_search.isAdduct= False 
+
+    usedatoms = {'C': (1,100) , 'H': (4,200), 'O': (0,10), 'N': (0,1), 'P': (0,1)}
+    MSParameters.molecular_search.usedAtoms = usedatoms
+    MSParameters.molecular_search.usedAtoms = usedatoms
+    mass_spectrum_obj = ms_from_array_centroid(mz, abundance, rp, s2n, 'single mf search', polarity=1, auto_process=True)
+    
+    if parameters_filepath:
+        
+        parameter_from_json.load_and_set_parameters_ms(mass_spectrum_obj, parameters_path=parameters_filepath)
+
+    mass_spectrum_obj.settings.noise_threshold_method = 'relative threshold'
+    mass_spectrum_obj.molecular_search_settings.use_min_peaks_filter = False
+    mass_spectrum_obj.molecular_search_settings.use_min_peaks_filter = 10
+    mass_spectrum_obj.molecular_search_settings.use_isotopologue_filter = False
+
+    print('Searching for molecular formulas within %.3f and %.3f ppm' % (mass_spectrum_obj.molecular_search_settings.min_ppm_error, mass_spectrum_obj.molecular_search_settings.max_ppm_error))
+
+    SearchMolecularFormulas(mass_spectrum_obj, find_isotopologues=True).run_worker_ms_peaks([mass_spectrum_obj[0]])
+    
+    ms_peak = mass_spectrum_obj[0]
+    
+    if ms_peak:
+        
+        header = ['Molecular Formula',  'Calculated m/z', 'Mass Error', 'DBE', 'Ion Type']
+        
+        results = []
+        
+        for formula in ms_peak:
+            
+            results.append([formula.string, formula.mz_calc, formula.mz_error, formula.dbe, formula.ion_type])
+              
+        pprint.pprint(results)
+        
+        
+    else:        
+        
+        print("Could not find a possible molecular formula match for the m/z %.5f" % mz[0])
+        
+if __name__ == "__main__":
+    
+    run_molecular_formula_search(760.58156938877)        

examples/test_notebooks.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+"""
+Test script to validate all example notebooks can execute without errors.
+"""
+import subprocess
+import sys
+from pathlib import Path
+import argparse
+
+# Patterns in stderr that indicate an external service is unavailable.
+# Failures matching these patterns are treated as warnings (skipped) rather
+# than hard failures so that transient infrastructure outages do not break CI.
+EXTERNAL_SERVICE_ERROR_PATTERNS = [
+    "HTTPError",
+    "ConnectionError",
+    "requests.exceptions",
+    "503 Server Error",
+    "502 Bad Gateway",
+    "504 Gateway",
+    "Service Temporarily Unavailable",
+]
+
+
+def _is_external_service_failure(stderr: str) -> bool:
+    """Return True if stderr indicates an unavailable external service."""
+    return any(pattern in stderr for pattern in EXTERNAL_SERVICE_ERROR_PATTERNS)
+
+
+# Return values: True = pass, False = fail, None = skipped (external service)
+def test_notebook(notebook_path):
+    """Test a single notebook by converting it."""
+    print(f"\n{'='*60}")
+    print(f"Testing: {notebook_path.name}")
+    print(f"{'='*60}")
+    
+    try:
+        subprocess.run(
+            [
+                sys.executable,
+                "-m",
+                "nbconvert",
+                "--to",
+                "notebook",
+                "--execute",
+                "--ExecutePreprocessor.timeout=300",
+                "--output",
+                f"/tmp/{notebook_path.stem}_test.ipynb",
+                str(notebook_path),
+            ],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        print(f"✓ {notebook_path.name} passed")
+        return True
+    except subprocess.CalledProcessError as e:
+        if _is_external_service_failure(e.stderr):
+            print(f"⚠ {notebook_path.name} skipped (external service unavailable)")
+            print(f"STDERR:\n{e.stderr[-2000:]}")
+            return None
+        print(f"✗ {notebook_path.name} failed")
+        print(f"STDOUT:\n{e.stdout}")
+        print(f"STDERR:\n{e.stderr}")
+        return False
+
+
+def discover_notebooks(notebooks_dir):
+    """Discover all notebooks in the notebooks directory (non-recursive)."""
+    all_notebooks = []
+    for notebook_path in sorted(notebooks_dir.glob("*.ipynb")):
+        # Exclude checkpoint files
+        if ".ipynb_checkpoints" not in str(notebook_path):
+            all_notebooks.append(notebook_path)
+    return all_notebooks
+
+
+def main():
+    """Run tests on all notebooks or a selected notebook."""
+    parser = argparse.ArgumentParser(description="Execute example notebooks with nbconvert")
+    parser.add_argument(
+        "--notebook",
+        "-n",
+        help="Notebook filename or path to run (e.g., LCMS_Tutorial.ipynb)",
+    )
+    args = parser.parse_args()
+
+    notebooks_dir = Path(__file__).parent / "notebooks"
+    
+    if not notebooks_dir.exists():
+        print(f"Error: notebooks directory not found at {notebooks_dir}")
+        sys.exit(1)
+    
+    if args.notebook:
+        notebook_arg = Path(args.notebook)
+        candidate = notebook_arg if notebook_arg.is_absolute() else notebooks_dir / notebook_arg
+        candidate = candidate.resolve()
+
+        if not candidate.exists():
+            print(f"Error: notebook not found: {args.notebook}")
+            sys.exit(1)
+        notebooks = [candidate]
+    else:
+        # Discover all notebooks automatically
+        notebooks = discover_notebooks(notebooks_dir)
+    
+    if not notebooks:
+        print("No notebooks found to test")
+        sys.exit(1)
+    
+    print(f"Found {len(notebooks)} notebook(s) to test")
+    
+    results = {}
+    for notebook_path in notebooks:
+        results[notebook_path.name] = test_notebook(notebook_path)
+    
+    print(f"\n{'='*60}")
+    print("SUMMARY")
+    print(f"{'='*60}")
+    
+    passed = sum(1 for v in results.values() if v is True)
+    skipped = sum(1 for v in results.values() if v is None)
+    failed = sum(1 for v in results.values() if v is False)
+    total = len(results)
+    
+    for notebook, result in results.items():
+        if result is True:
+            status = "✓ PASS"
+        elif result is None:
+            status = "⚠ SKIP"
+        else:
+            status = "✗ FAIL"
+        print(f"{status}: {notebook}")
+    
+    print(f"\n{passed}/{total} notebooks passed, {skipped} skipped (external service), {failed} failed")
+    
+    if failed > 0:
+        sys.exit(1)
+    
+    if skipped > 0:
+        print("\nSome notebooks were skipped due to unavailable external services.")
+    else:
+        print("\nAll tests passed!")
+
+if __name__ == "__main__":
+    main()