corems.encapsulation.factory.parameters

View Source

  1import dataclasses
  2
  3from corems.encapsulation.factory.processingSetting import (
  4    LiquidChromatographSetting,
  5    MolecularFormulaSearchSettings,
  6    TransientSetting,
  7    MassSpecPeakSetting,
  8    MassSpectrumSetting,
  9)
 10from corems.encapsulation.factory.processingSetting import (
 11    CompoundSearchSettings,
 12    GasChromatographSetting,
 13)
 14from corems.encapsulation.factory.processingSetting import DataInputSetting
 15
 16def hush_output():
 17    """Toggle all the verbose_processing flags to False on the MSParameters, GCMSParameters and LCMSParameters classes"""
 18    MSParameters.molecular_search.verbose_processing = False
 19    MSParameters.mass_spectrum.verbose_processing = False
 20    GCMSParameters.gc_ms.verbose_processing = False
 21    LCMSParameters.lc_ms.verbose_processing = False
 22
 23def reset_ms_parameters():
 24    """Reset the MSParameter class to the default values"""
 25    MSParameters.molecular_search = MolecularFormulaSearchSettings()
 26    MSParameters.transient = TransientSetting()
 27    MSParameters.mass_spectrum = MassSpectrumSetting()
 28    MSParameters.ms_peak = MassSpecPeakSetting()
 29    MSParameters.data_input = DataInputSetting()
 30
 31
 32def reset_gcms_parameters():
 33    """Reset the GCMSParameters class to the default values"""
 34    GCMSParameters.molecular_search = CompoundSearchSettings()
 35    GCMSParameters.gc_ms = GasChromatographSetting()
 36
 37
 38def reset_lcms_parameters():
 39    """Reset the LCMSParameters class to the default values"""
 40    reset_ms_parameters()
 41    LCMSParameters.lc_ms = LiquidChromatographSetting()
 42
 43
 44class MSParameters:
 45    """MSParameters class is used to store the parameters used for the processing of the mass spectrum
 46
 47    Each attibute is a class that contains the parameters for the processing of the mass spectrum, see the corems.encapsulation.factory.processingSetting module for more details.
 48
 49    Parameters
 50    ----------
 51    use_defaults: bool, optional
 52        if True, the class will be instantiated with the default values, otherwise the current values will be used. Default is False.
 53
 54    Attributes
 55    -----------
 56    molecular_search: MolecularFormulaSearchSettings
 57        MolecularFormulaSearchSettings object
 58    transient: TransientSetting
 59        TransientSetting object
 60    mass_spectrum: MassSpectrumSetting
 61        MassSpectrumSetting object
 62    ms_peak: MassSpecPeakSetting
 63        MassSpecPeakSetting object
 64    data_input: DataInputSetting
 65        DataInputSetting object
 66
 67    Notes
 68    -----
 69    One can use the use_defaults parameter to reset the parameters to the default values.
 70    Alternatively, to use the current values - modify the class's contents before instantiating the class.
 71    """
 72
 73    molecular_search = MolecularFormulaSearchSettings()
 74    transient = TransientSetting()
 75    mass_spectrum = MassSpectrumSetting()
 76    ms_peak = MassSpecPeakSetting()
 77    data_input = DataInputSetting()
 78
 79    def __init__(self, use_defaults=False) -> None:
 80        if not use_defaults:
 81            self.molecular_search = dataclasses.replace(MSParameters.molecular_search)
 82            self.transient = dataclasses.replace(MSParameters.transient)
 83            self.mass_spectrum = dataclasses.replace(MSParameters.mass_spectrum)
 84            self.ms_peak = dataclasses.replace(MSParameters.ms_peak)
 85            self.data_input = dataclasses.replace(MSParameters.data_input)
 86        else:
 87            self.molecular_search = MolecularFormulaSearchSettings()
 88            self.transient = TransientSetting()
 89            self.mass_spectrum = MassSpectrumSetting()
 90            self.ms_peak = MassSpecPeakSetting()
 91            self.data_input = DataInputSetting()
 92
 93    def copy(self):
 94        """Create a copy of the MSParameters object"""
 95        new_ms_parameters = MSParameters()
 96        new_ms_parameters.molecular_search = dataclasses.replace(self.molecular_search)
 97        new_ms_parameters.transient = dataclasses.replace(self.transient)
 98        new_ms_parameters.mass_spectrum = dataclasses.replace(self.mass_spectrum)
 99        new_ms_parameters.ms_peak = dataclasses.replace(self.ms_peak)
100        new_ms_parameters.data_input = dataclasses.replace(self.data_input)
101
102        return new_ms_parameters
103
104    def print(self):
105        """Print the MSParameters object"""
106        for k, v in self.__dict__.items():
107            print(k, type(v).__name__)
108
109            for k2, v2 in v.__dict__.items():
110                print("    {}: {}".format(k2, v2))
111
112    def __eq__(self, value: object) -> bool:
113        # Check that the object is of the same type
114        if not isinstance(value, MSParameters):
115            return False
116        equality_check = []
117        equality_check.append(self.molecular_search == value.molecular_search)
118        equality_check.append(self.transient == value.transient)
119        equality_check.append(self.mass_spectrum == value.mass_spectrum)
120        equality_check.append(self.ms_peak == value.ms_peak)
121        equality_check.append(self.data_input == value.data_input)
122
123        return all(equality_check)
124
125
126class GCMSParameters:
127    """GCMSParameters class is used to store the parameters used for the processing of the gas chromatograph mass spectrum
128
129    Each attibute is a class that contains the parameters for the processing of the data, see the corems.encapsulation.factory.processingSetting module for more details.
130
131    Parameters
132    ----------
133    use_defaults: bool, optional
134        if True, the class will be instantiated with the default values, otherwise the current values will be used. Default is False.
135
136    Attributes
137    -----------
138    molecular_search: MolecularFormulaSearchSettings
139        MolecularFormulaSearchSettings object
140    gc_ms: GasChromatographSetting
141        GasChromatographSetting object
142
143    Notes
144    -----
145    One can use the use_defaults parameter to reset the parameters to the default values.
146    Alternatively, to use the current values - modify the class's contents before instantiating the class.
147    """
148
149    molecular_search = CompoundSearchSettings()
150    gc_ms = GasChromatographSetting()
151
152    def __init__(self, use_defaults=False) -> None:
153        if not use_defaults:
154            self.molecular_search = dataclasses.replace(GCMSParameters.molecular_search)
155            self.gc_ms = dataclasses.replace(GCMSParameters.gc_ms)
156        else:
157            self.molecular_search = CompoundSearchSettings()
158            self.gc_ms = GasChromatographSetting()
159
160    def copy(self):
161        """Create a copy of the GCMSParameters object"""
162        new_gcms_parameters = GCMSParameters()
163        new_gcms_parameters.molecular_search = dataclasses.replace(
164            self.molecular_search
165        )
166        new_gcms_parameters.gc_ms = dataclasses.replace(self.gc_ms)
167
168        return new_gcms_parameters
169
170    def __eq__(self, value: object) -> bool:
171        # Check that the object is of the same type
172        if not isinstance(value, GCMSParameters):
173            return False
174        equality_check = []
175        equality_check.append(self.molecular_search == value.molecular_search)
176        equality_check.append(self.gc_ms == value.gc_ms)
177
178        return all(equality_check)
179
180    def print(self):
181        """Print the GCMSParameters object"""
182        for k, v in self.__dict__.items():
183            print(k, type(v).__name__)
184
185            for k2, v2 in v.__dict__.items():
186                print("    {}: {}".format(k2, v2))
187
188
189class LCMSParameters:
190    """LCMSParameters class is used to store the parameters used for the processing of the liquid chromatograph mass spectrum
191
192    Each attibute is a class that contains the parameters for the processing of the data, see the corems.encapsulation.factory.processingSetting module for more details.
193
194    Parameters
195    ----------
196    use_defaults: bool, optional
197        if True, the class will be instantiated with the default values, otherwise the current values will be used. Default is False.
198
199    Attributes
200    -----------
201    lc_ms: LiquidChromatographSetting
202        LiquidChromatographSetting object
203    mass_spectrum: dict
204        dictionary with the mass spectrum parameters for ms1 and ms2, each value is a MSParameters object
205
206    Notes
207    -----
208    One can use the use_defaults parameter to reset the parameters to the default values.
209    Alternatively, to use the current values - modify the class's contents before instantiating the class.
210    """
211
212    lc_ms = LiquidChromatographSetting()
213    mass_spectrum = {"ms1": MSParameters(), "ms2": MSParameters()}
214
215    def __init__(self, use_defaults=False) -> None:
216        if not use_defaults:
217            self.lc_ms = dataclasses.replace(LCMSParameters.lc_ms)
218            self.mass_spectrum = {
219                "ms1": MSParameters(use_defaults=False),
220                "ms2": MSParameters(use_defaults=False),
221            }
222        else:
223            self.lc_ms = LiquidChromatographSetting()
224            self.mass_spectrum = {
225                "ms1": MSParameters(use_defaults=True),
226                "ms2": MSParameters(use_defaults=True),
227            }
228
229    def copy(self):
230        """Create a copy of the LCMSParameters object"""
231        new_lcms_parameters = LCMSParameters()
232        new_lcms_parameters.lc_ms = dataclasses.replace(self.lc_ms)
233        for key in self.mass_spectrum:
234            new_lcms_parameters.mass_spectrum[key] = self.mass_spectrum[key].copy()
235
236        return new_lcms_parameters
237
238    def __eq__(self, value: object) -> bool:
239        # Check that the object is of the same type
240        if not isinstance(value, LCMSParameters):
241            return False
242        equality_check = []
243        equality_check.append(self.lc_ms == value.lc_ms)
244
245        # Check that the mass_spectrum dictionary has the same keys
246        equality_check.append(self.mass_spectrum.keys() == value.mass_spectrum.keys())
247
248        # Check that the values of the mass_spectrum dictionary are equal
249        for key in self.mass_spectrum.keys():
250            equality_check.append(
251                self.mass_spectrum[key].mass_spectrum
252                == value.mass_spectrum[key].mass_spectrum
253            )
254            equality_check.append(
255                self.mass_spectrum[key].ms_peak == value.mass_spectrum[key].ms_peak
256            )
257            equality_check.append(
258                self.mass_spectrum[key].molecular_search
259                == value.mass_spectrum[key].molecular_search
260            )
261            equality_check.append(
262                self.mass_spectrum[key].transient == value.mass_spectrum[key].transient
263            )
264            equality_check.append(
265                self.mass_spectrum[key].data_input
266                == value.mass_spectrum[key].data_input
267            )
268
269        return all(equality_check)
270
271    def print(self):
272        """Print the LCMSParameters object"""
273        # Print the lcms paramters
274        for k, v in self.__dict__.items():
275            if k == "lc_ms":
276                print(k, type(v).__name__)
277
278        for k2, v2 in self.mass_spectrum.items():
279            """Print the MSParameters object"""
280            for k3, v3 in v2.__dict__.items():
281                print("{} - {}: {}".format(k2, k3, type(v3).__name__))
282
283                for k4, v4 in v3.__dict__.items():
284                    print("    {}: {}".format(k4, v4))
285
286
287def default_parameters(file_location):  # pragma: no cover
288    """Generate parameters dictionary with the default parameters for data processing
289       To gather parameters from instrument data during the data parsing step, a parameters dictionary with the default parameters needs to be generated.
290       This dictionary acts as a placeholder and is later used as an argument for all the class constructor methods during instantiation.
291       The data gathered from the instrument is added to the class properties.
292
293    Parameters
294    ----------
295    file_location: str
296        path to the file
297
298    Returns
299    -------
300    parameters: dict
301        dictionary with the default parameters for data processing
302    """
303
304    parameters = dict()
305
306    parameters["Aterm"] = 0
307
308    parameters["Bterm"] = 0
309
310    parameters["Cterm"] = 0
311
312    parameters["exc_high_freq"] = 0
313
314    parameters["exc_low_freq"] = 0
315
316    parameters["mw_low"] = 0
317
318    parameters["mw_high"] = 0
319
320    parameters["qpd_enabled"] = 0
321
322    parameters["bandwidth"] = 0
323
324    parameters["analyzer"] = "Unknown"
325
326    parameters["acquisition_time"] = None
327
328    parameters["instrument_label"] = "Unknown"
329
330    parameters["sample_name"] = "Unknown"
331
332    parameters["number_data_points"] = 0
333
334    parameters["polarity"] = "Unknown"
335
336    parameters["filename_path"] = str(file_location)
337
338    """scan_number and rt will be need to lc ms"""
339
340    parameters["mobility_scan"] = 0
341
342    parameters["mobility_rt"] = 0
343
344    parameters["scan_number"] = 0
345
346    parameters["rt"] = 0
347
348    return parameters

def hush_output(): View Source

17def hush_output():
18    """Toggle all the verbose_processing flags to False on the MSParameters, GCMSParameters and LCMSParameters classes"""
19    MSParameters.molecular_search.verbose_processing = False
20    MSParameters.mass_spectrum.verbose_processing = False
21    GCMSParameters.gc_ms.verbose_processing = False
22    LCMSParameters.lc_ms.verbose_processing = False

Toggle all the verbose_processing flags to False on the MSParameters, GCMSParameters and LCMSParameters classes

def reset_ms_parameters(): View Source

24def reset_ms_parameters():
25    """Reset the MSParameter class to the default values"""
26    MSParameters.molecular_search = MolecularFormulaSearchSettings()
27    MSParameters.transient = TransientSetting()
28    MSParameters.mass_spectrum = MassSpectrumSetting()
29    MSParameters.ms_peak = MassSpecPeakSetting()
30    MSParameters.data_input = DataInputSetting()

Reset the MSParameter class to the default values

def reset_gcms_parameters(): View Source

33def reset_gcms_parameters():
34    """Reset the GCMSParameters class to the default values"""
35    GCMSParameters.molecular_search = CompoundSearchSettings()
36    GCMSParameters.gc_ms = GasChromatographSetting()

Reset the GCMSParameters class to the default values

def reset_lcms_parameters(): View Source

39def reset_lcms_parameters():
40    """Reset the LCMSParameters class to the default values"""
41    reset_ms_parameters()
42    LCMSParameters.lc_ms = LiquidChromatographSetting()

Reset the LCMSParameters class to the default values

class MSParameters: View Source

 45class MSParameters:
 46    """MSParameters class is used to store the parameters used for the processing of the mass spectrum
 47
 48    Each attibute is a class that contains the parameters for the processing of the mass spectrum, see the corems.encapsulation.factory.processingSetting module for more details.
 49
 50    Parameters
 51    ----------
 52    use_defaults: bool, optional
 53        if True, the class will be instantiated with the default values, otherwise the current values will be used. Default is False.
 54
 55    Attributes
 56    -----------
 57    molecular_search: MolecularFormulaSearchSettings
 58        MolecularFormulaSearchSettings object
 59    transient: TransientSetting
 60        TransientSetting object
 61    mass_spectrum: MassSpectrumSetting
 62        MassSpectrumSetting object
 63    ms_peak: MassSpecPeakSetting
 64        MassSpecPeakSetting object
 65    data_input: DataInputSetting
 66        DataInputSetting object
 67
 68    Notes
 69    -----
 70    One can use the use_defaults parameter to reset the parameters to the default values.
 71    Alternatively, to use the current values - modify the class's contents before instantiating the class.
 72    """
 73
 74    molecular_search = MolecularFormulaSearchSettings()
 75    transient = TransientSetting()
 76    mass_spectrum = MassSpectrumSetting()
 77    ms_peak = MassSpecPeakSetting()
 78    data_input = DataInputSetting()
 79
 80    def __init__(self, use_defaults=False) -> None:
 81        if not use_defaults:
 82            self.molecular_search = dataclasses.replace(MSParameters.molecular_search)
 83            self.transient = dataclasses.replace(MSParameters.transient)
 84            self.mass_spectrum = dataclasses.replace(MSParameters.mass_spectrum)
 85            self.ms_peak = dataclasses.replace(MSParameters.ms_peak)
 86            self.data_input = dataclasses.replace(MSParameters.data_input)
 87        else:
 88            self.molecular_search = MolecularFormulaSearchSettings()
 89            self.transient = TransientSetting()
 90            self.mass_spectrum = MassSpectrumSetting()
 91            self.ms_peak = MassSpecPeakSetting()
 92            self.data_input = DataInputSetting()
 93
 94    def copy(self):
 95        """Create a copy of the MSParameters object"""
 96        new_ms_parameters = MSParameters()
 97        new_ms_parameters.molecular_search = dataclasses.replace(self.molecular_search)
 98        new_ms_parameters.transient = dataclasses.replace(self.transient)
 99        new_ms_parameters.mass_spectrum = dataclasses.replace(self.mass_spectrum)
100        new_ms_parameters.ms_peak = dataclasses.replace(self.ms_peak)
101        new_ms_parameters.data_input = dataclasses.replace(self.data_input)
102
103        return new_ms_parameters
104
105    def print(self):
106        """Print the MSParameters object"""
107        for k, v in self.__dict__.items():
108            print(k, type(v).__name__)
109
110            for k2, v2 in v.__dict__.items():
111                print("    {}: {}".format(k2, v2))
112
113    def __eq__(self, value: object) -> bool:
114        # Check that the object is of the same type
115        if not isinstance(value, MSParameters):
116            return False
117        equality_check = []
118        equality_check.append(self.molecular_search == value.molecular_search)
119        equality_check.append(self.transient == value.transient)
120        equality_check.append(self.mass_spectrum == value.mass_spectrum)
121        equality_check.append(self.ms_peak == value.ms_peak)
122        equality_check.append(self.data_input == value.data_input)
123
124        return all(equality_check)

MSParameters class is used to store the parameters used for the processing of the mass spectrum

Each attibute is a class that contains the parameters for the processing of the mass spectrum, see the corems.encapsulation.factory.processingSetting module for more details.

Parameters

use_defaults (bool, optional): if True, the class will be instantiated with the default values, otherwise the current values will be used. Default is False.

Attributes

molecular_search (MolecularFormulaSearchSettings): MolecularFormulaSearchSettings object
transient (TransientSetting): TransientSetting object
mass_spectrum (MassSpectrumSetting): MassSpectrumSetting object
ms_peak (MassSpecPeakSetting): MassSpecPeakSetting object
data_input (DataInputSetting): DataInputSetting object

Notes

One can use the use_defaults parameter to reset the parameters to the default values. Alternatively, to use the current values - modify the class's contents before instantiating the class.

MSParameters(use_defaults=False) View Source

80    def __init__(self, use_defaults=False) -> None:
81        if not use_defaults:
82            self.molecular_search = dataclasses.replace(MSParameters.molecular_search)
83            self.transient = dataclasses.replace(MSParameters.transient)
84            self.mass_spectrum = dataclasses.replace(MSParameters.mass_spectrum)
85            self.ms_peak = dataclasses.replace(MSParameters.ms_peak)
86            self.data_input = dataclasses.replace(MSParameters.data_input)
87        else:
88            self.molecular_search = MolecularFormulaSearchSettings()
89            self.transient = TransientSetting()
90            self.mass_spectrum = MassSpectrumSetting()
91            self.ms_peak = MassSpecPeakSetting()
92            self.data_input = DataInputSetting()

molecular_search = MolecularFormulaSearchSettings(verbose_processing=True, use_isotopologue_filter=False, isotopologue_filter_threshold=33.0, isotopologue_filter_atoms=('Cl', 'Br'), use_runtime_kendrick_filter=False, use_min_peaks_filter=True, min_peaks_per_class=15, url_database='postgresql+psycopg2://coremsappdb:coremsapppnnl@localhost:5432/coremsapp', db_jobs=3, db_chunk_size=300, ion_charge=-1, min_hc_filter=0.3, max_hc_filter=3.0, min_oc_filter=0.0, max_oc_filter=1.2, min_op_filter=2.0, use_pah_line_rule=False, min_dbe=0.0, max_dbe=40.0, mz_error_score_weight=0.6, isotopologue_score_weight=0.4, adduct_atoms_neg=('Cl', 'Br'), adduct_atoms_pos=('Na', 'K'), score_methods=('S_P_lowest_error', 'N_S_P_lowest_error', 'lowest_error', 'prob_score', 'air_filter_error', 'water_filter_error', 'earth_filter_error'), score_method='prob_score', output_min_score=0.1, output_score_method='All Candidates', isRadical=False, isProtonated=True, isAdduct=False, usedAtoms={'C': (1, 100), 'H': (1, 200)}, ion_types_excluded=[], ionization_type='ESI', min_ppm_error=-10.0, max_ppm_error=10.0, min_abun_error=-100.0, max_abun_error=100.0, mz_error_range=1.5, error_method='None', mz_error_average=0.0, used_atom_valences={'C': 4, '13C': 4, 'N': 3, 'O': 2, 'S': 2, 'H': 1, 'F': 1, 'Cl': 1, 'Br': 1, 'I': 1, 'At': 1, 'Li': 1, 'Na': 1, 'K': 1, 'Rb': 1, 'Cs': 1, 'Fr': 1, 'B': 4, 'In': 3, 'Al': 3, 'P': 3, 'Ga': 3, 'Mg': 2, 'Be': 2, 'Ca': 2, 'Sr': 2, 'Ba': 2, 'Ra': 2, 'V': 5, 'Fe': 3, 'Si': 4, 'Sc': 3, 'Ti': 4, 'Cr': 1, 'Mn': 1, 'Co': 1, 'Ni': 1, 'Cu': 2, 'Zn': 2, 'Ge': 4, 'As': 5, 'Se': 6, 'Y': 3, 'Zr': 4, 'Nb': 5, 'Mo': 6, 'Tc': 7, 'Ru': 8, 'Rh': 6, 'Pd': 4, 'Ag': 0, 'Cd': 2, 'Sn': 4, 'Sb': 5, 'Te': 6, 'La': 3, 'Hf': 4, 'Ta': 5, 'W': 6, 'Re': 4, 'Os': 4, 'Ir': 4, 'Pt': 4, 'Au': 3, 'Hg': 1, 'Tl': 3, 'Pb': 4, 'Bi': 3, 'Po': 2, 'Ac': 3})

transient = TransientSetting(implemented_apodization_function=('Hamming', 'Hanning', 'Blackman', 'Full-Sine', 'Half-Sine', 'Kaiser', 'Half-Kaiser'), apodization_method='Hanning', number_of_truncations=0, number_of_zero_fills=1, next_power_of_two=False, kaiser_beta=8.6)

mass_spectrum = MassSpectrumSetting(noise_threshold_method='log', noise_threshold_methods_implemented=('minima', 'signal_noise', 'relative_abundance', 'absolute_abundance', 'log'), noise_threshold_min_std=6, noise_threshold_min_s2n=4.0, noise_threshold_min_relative_abundance=6.0, noise_threshold_absolute_abundance=1000000.0, noise_threshold_log_nsigma=6, noise_threshold_log_nsigma_corr_factor=0.463, noise_threshold_log_nsigma_bins=500, noise_min_mz=50.0, noise_max_mz=1200.0, min_picking_mz=50.0, max_picking_mz=1200.0, picking_point_extrapolate=3, calib_minimize_method='Powell', calib_pol_order=2, max_calib_ppm_error=1.0, min_calib_ppm_error=-1.0, calib_sn_threshold=2.0, calibration_ref_match_method='legacy', calibration_ref_match_method_implemented=('legacy', 'merged'), calibration_ref_match_tolerance=0.003, calibration_ref_match_std_raw_error_limit=1.5, do_calibration=True, verbose_processing=True)

ms_peak = MassSpecPeakSetting(kendrick_base={'C': 1, 'H': 2}, kendrick_rounding_method='floor', implemented_kendrick_rounding_methods=('floor', 'ceil', 'round'), peak_derivative_threshold=0.0, peak_min_prominence_percent=0.1, min_peak_datapoints=5.0, peak_max_prominence_percent=0.1, peak_height_max_percent=10.0, legacy_resolving_power=True, legacy_centroid_polyfit=False)

data_input = DataInputSetting(header_translate={'m/z': 'm/z', 'mOz': 'm/z', 'Mass': 'm/z', 'Resolving Power': 'Resolving Power', 'Res.': 'Resolving Power', 'resolution': 'Resolving Power', 'Intensity': 'Peak Height', 'Peak Height': 'Peak Height', 'I': 'Peak Height', 'Abundance': 'Peak Height', 'abs_abu': 'Peak Height', 'Signal/Noise': 'S/N', 'S/N': 'S/N', 'sn': 'S/N'})

def copy(self): View Source

 94    def copy(self):
 95        """Create a copy of the MSParameters object"""
 96        new_ms_parameters = MSParameters()
 97        new_ms_parameters.molecular_search = dataclasses.replace(self.molecular_search)
 98        new_ms_parameters.transient = dataclasses.replace(self.transient)
 99        new_ms_parameters.mass_spectrum = dataclasses.replace(self.mass_spectrum)
100        new_ms_parameters.ms_peak = dataclasses.replace(self.ms_peak)
101        new_ms_parameters.data_input = dataclasses.replace(self.data_input)
102
103        return new_ms_parameters

Create a copy of the MSParameters object

def print(self): View Source

105    def print(self):
106        """Print the MSParameters object"""
107        for k, v in self.__dict__.items():
108            print(k, type(v).__name__)
109
110            for k2, v2 in v.__dict__.items():
111                print("    {}: {}".format(k2, v2))

Print the MSParameters object

class GCMSParameters: View Source

127class GCMSParameters:
128    """GCMSParameters class is used to store the parameters used for the processing of the gas chromatograph mass spectrum
129
130    Each attibute is a class that contains the parameters for the processing of the data, see the corems.encapsulation.factory.processingSetting module for more details.
131
132    Parameters
133    ----------
134    use_defaults: bool, optional
135        if True, the class will be instantiated with the default values, otherwise the current values will be used. Default is False.
136
137    Attributes
138    -----------
139    molecular_search: MolecularFormulaSearchSettings
140        MolecularFormulaSearchSettings object
141    gc_ms: GasChromatographSetting
142        GasChromatographSetting object
143
144    Notes
145    -----
146    One can use the use_defaults parameter to reset the parameters to the default values.
147    Alternatively, to use the current values - modify the class's contents before instantiating the class.
148    """
149
150    molecular_search = CompoundSearchSettings()
151    gc_ms = GasChromatographSetting()
152
153    def __init__(self, use_defaults=False) -> None:
154        if not use_defaults:
155            self.molecular_search = dataclasses.replace(GCMSParameters.molecular_search)
156            self.gc_ms = dataclasses.replace(GCMSParameters.gc_ms)
157        else:
158            self.molecular_search = CompoundSearchSettings()
159            self.gc_ms = GasChromatographSetting()
160
161    def copy(self):
162        """Create a copy of the GCMSParameters object"""
163        new_gcms_parameters = GCMSParameters()
164        new_gcms_parameters.molecular_search = dataclasses.replace(
165            self.molecular_search
166        )
167        new_gcms_parameters.gc_ms = dataclasses.replace(self.gc_ms)
168
169        return new_gcms_parameters
170
171    def __eq__(self, value: object) -> bool:
172        # Check that the object is of the same type
173        if not isinstance(value, GCMSParameters):
174            return False
175        equality_check = []
176        equality_check.append(self.molecular_search == value.molecular_search)
177        equality_check.append(self.gc_ms == value.gc_ms)
178
179        return all(equality_check)
180
181    def print(self):
182        """Print the GCMSParameters object"""
183        for k, v in self.__dict__.items():
184            print(k, type(v).__name__)
185
186            for k2, v2 in v.__dict__.items():
187                print("    {}: {}".format(k2, v2))

GCMSParameters class is used to store the parameters used for the processing of the gas chromatograph mass spectrum

Each attibute is a class that contains the parameters for the processing of the data, see the corems.encapsulation.factory.processingSetting module for more details.

Parameters

use_defaults (bool, optional): if True, the class will be instantiated with the default values, otherwise the current values will be used. Default is False.

Attributes

molecular_search (MolecularFormulaSearchSettings): MolecularFormulaSearchSettings object
gc_ms (GasChromatographSetting): GasChromatographSetting object

Notes

One can use the use_defaults parameter to reset the parameters to the default values. Alternatively, to use the current values - modify the class's contents before instantiating the class.

GCMSParameters(use_defaults=False) View Source

153    def __init__(self, use_defaults=False) -> None:
154        if not use_defaults:
155            self.molecular_search = dataclasses.replace(GCMSParameters.molecular_search)
156            self.gc_ms = dataclasses.replace(GCMSParameters.gc_ms)
157        else:
158            self.molecular_search = CompoundSearchSettings()
159            self.gc_ms = GasChromatographSetting()

molecular_search = CompoundSearchSettings(url_database='sqlite:///db/pnnl_lowres_gcms_compounds.sqlite', ri_search_range=35.0, rt_search_range=1.0, correlation_threshold=0.5, score_threshold=0.0, ri_spacing=200.0, ri_std=3.0, ri_calibration_compound_names=['Methyl Caprylate', 'Methyl Caprate', 'Methyl Pelargonate', 'Methyl Laurate', 'Methyl Myristate', 'Methyl Palmitate', 'Methyl Stearate', 'Methyl Eicosanoate', 'Methyl Docosanoate', 'Methyl Linocerate', 'Methyl Hexacosanoate', 'Methyl Octacosanoate', 'Methyl Triacontanoate'], exploratory_mode=False, score_methods=('highest_sim_score', 'highest_ss'), output_score_method='All')

gc_ms = GasChromatographSetting(use_deconvolution=False, implemented_smooth_method=('savgol', 'hanning', 'blackman', 'bartlett', 'flat', 'boxcar'), smooth_window=5, smooth_method='savgol', savgol_pol_order=2, peak_derivative_threshold=0.0005, peak_height_max_percent=10.0, peak_max_prominence_percent=1.0, min_peak_datapoints=5.0, max_peak_width=0.1, noise_threshold_method='manual_relative_abundance', noise_threshold_methods_implemented=('auto_relative_abundance', 'manual_relative_abundance', 'second_derivative'), std_noise_threshold=3, peak_height_min_percent=0.1, peak_min_prominence_percent=0.1, eic_signal_threshold=0.01, max_rt_distance=0.025, verbose_processing=True)

def copy(self): View Source

161    def copy(self):
162        """Create a copy of the GCMSParameters object"""
163        new_gcms_parameters = GCMSParameters()
164        new_gcms_parameters.molecular_search = dataclasses.replace(
165            self.molecular_search
166        )
167        new_gcms_parameters.gc_ms = dataclasses.replace(self.gc_ms)
168
169        return new_gcms_parameters

Create a copy of the GCMSParameters object

def print(self): View Source

181    def print(self):
182        """Print the GCMSParameters object"""
183        for k, v in self.__dict__.items():
184            print(k, type(v).__name__)
185
186            for k2, v2 in v.__dict__.items():
187                print("    {}: {}".format(k2, v2))

Print the GCMSParameters object

class LCMSParameters: View Source

190class LCMSParameters:
191    """LCMSParameters class is used to store the parameters used for the processing of the liquid chromatograph mass spectrum
192
193    Each attibute is a class that contains the parameters for the processing of the data, see the corems.encapsulation.factory.processingSetting module for more details.
194
195    Parameters
196    ----------
197    use_defaults: bool, optional
198        if True, the class will be instantiated with the default values, otherwise the current values will be used. Default is False.
199
200    Attributes
201    -----------
202    lc_ms: LiquidChromatographSetting
203        LiquidChromatographSetting object
204    mass_spectrum: dict
205        dictionary with the mass spectrum parameters for ms1 and ms2, each value is a MSParameters object
206
207    Notes
208    -----
209    One can use the use_defaults parameter to reset the parameters to the default values.
210    Alternatively, to use the current values - modify the class's contents before instantiating the class.
211    """
212
213    lc_ms = LiquidChromatographSetting()
214    mass_spectrum = {"ms1": MSParameters(), "ms2": MSParameters()}
215
216    def __init__(self, use_defaults=False) -> None:
217        if not use_defaults:
218            self.lc_ms = dataclasses.replace(LCMSParameters.lc_ms)
219            self.mass_spectrum = {
220                "ms1": MSParameters(use_defaults=False),
221                "ms2": MSParameters(use_defaults=False),
222            }
223        else:
224            self.lc_ms = LiquidChromatographSetting()
225            self.mass_spectrum = {
226                "ms1": MSParameters(use_defaults=True),
227                "ms2": MSParameters(use_defaults=True),
228            }
229
230    def copy(self):
231        """Create a copy of the LCMSParameters object"""
232        new_lcms_parameters = LCMSParameters()
233        new_lcms_parameters.lc_ms = dataclasses.replace(self.lc_ms)
234        for key in self.mass_spectrum:
235            new_lcms_parameters.mass_spectrum[key] = self.mass_spectrum[key].copy()
236
237        return new_lcms_parameters
238
239    def __eq__(self, value: object) -> bool:
240        # Check that the object is of the same type
241        if not isinstance(value, LCMSParameters):
242            return False
243        equality_check = []
244        equality_check.append(self.lc_ms == value.lc_ms)
245
246        # Check that the mass_spectrum dictionary has the same keys
247        equality_check.append(self.mass_spectrum.keys() == value.mass_spectrum.keys())
248
249        # Check that the values of the mass_spectrum dictionary are equal
250        for key in self.mass_spectrum.keys():
251            equality_check.append(
252                self.mass_spectrum[key].mass_spectrum
253                == value.mass_spectrum[key].mass_spectrum
254            )
255            equality_check.append(
256                self.mass_spectrum[key].ms_peak == value.mass_spectrum[key].ms_peak
257            )
258            equality_check.append(
259                self.mass_spectrum[key].molecular_search
260                == value.mass_spectrum[key].molecular_search
261            )
262            equality_check.append(
263                self.mass_spectrum[key].transient == value.mass_spectrum[key].transient
264            )
265            equality_check.append(
266                self.mass_spectrum[key].data_input
267                == value.mass_spectrum[key].data_input
268            )
269
270        return all(equality_check)
271
272    def print(self):
273        """Print the LCMSParameters object"""
274        # Print the lcms paramters
275        for k, v in self.__dict__.items():
276            if k == "lc_ms":
277                print(k, type(v).__name__)
278
279        for k2, v2 in self.mass_spectrum.items():
280            """Print the MSParameters object"""
281            for k3, v3 in v2.__dict__.items():
282                print("{} - {}: {}".format(k2, k3, type(v3).__name__))
283
284                for k4, v4 in v3.__dict__.items():
285                    print("    {}: {}".format(k4, v4))

LCMSParameters class is used to store the parameters used for the processing of the liquid chromatograph mass spectrum

Each attibute is a class that contains the parameters for the processing of the data, see the corems.encapsulation.factory.processingSetting module for more details.

Parameters

use_defaults (bool, optional): if True, the class will be instantiated with the default values, otherwise the current values will be used. Default is False.

Attributes

lc_ms (LiquidChromatographSetting): LiquidChromatographSetting object
mass_spectrum (dict): dictionary with the mass spectrum parameters for ms1 and ms2, each value is a MSParameters object

Notes

One can use the use_defaults parameter to reset the parameters to the default values. Alternatively, to use the current values - modify the class's contents before instantiating the class.

LCMSParameters(use_defaults=False) View Source

216    def __init__(self, use_defaults=False) -> None:
217        if not use_defaults:
218            self.lc_ms = dataclasses.replace(LCMSParameters.lc_ms)
219            self.mass_spectrum = {
220                "ms1": MSParameters(use_defaults=False),
221                "ms2": MSParameters(use_defaults=False),
222            }
223        else:
224            self.lc_ms = LiquidChromatographSetting()
225            self.mass_spectrum = {
226                "ms1": MSParameters(use_defaults=True),
227                "ms2": MSParameters(use_defaults=True),
228            }

lc_ms = LiquidChromatographSetting(scans=(-1, -1), eic_tolerance_ppm=5.0, smooth_window=5, smooth_method='savgol', implemented_smooth_method=('savgol', 'hanning', 'blackman', 'bartlett', 'flat', 'boxcar'), savgol_pol_order=2, peak_height_max_percent=10.0, peak_max_prominence_percent=1.0, peak_derivative_threshold=0.0005, min_peak_datapoints=5.0, noise_threshold_method='manual_relative_abundance', noise_threshold_methods_implemented=('auto_relative_abundance', 'manual_relative_abundance', 'second_derivative'), peak_height_min_percent=0.1, eic_signal_threshold=0.01, peak_picking_method='persistent homology', implemented_peak_picking_methods=('persistent homology',), mass_feature_cluster_mz_tolerance_rel=5e-06, mass_feature_cluster_rt_tolerance=0.3, ms1_scans_to_average=1, ms1_deconvolution_corr_min=0.8, ms2_dda_rt_tolerance=0.15, ms2_dda_mz_tolerance=0.05, ms2_min_fe_score=0.2, search_as_lipids=False, include_fragment_types=False, export_profile_spectra=False, export_eics=True, export_unprocessed_ms1=False, verbose_processing=True)

mass_spectrum = {'ms1': <MSParameters object>, 'ms2': <MSParameters object>}

def copy(self): View Source

230    def copy(self):
231        """Create a copy of the LCMSParameters object"""
232        new_lcms_parameters = LCMSParameters()
233        new_lcms_parameters.lc_ms = dataclasses.replace(self.lc_ms)
234        for key in self.mass_spectrum:
235            new_lcms_parameters.mass_spectrum[key] = self.mass_spectrum[key].copy()
236
237        return new_lcms_parameters

Create a copy of the LCMSParameters object

def print(self): View Source

272    def print(self):
273        """Print the LCMSParameters object"""
274        # Print the lcms paramters
275        for k, v in self.__dict__.items():
276            if k == "lc_ms":
277                print(k, type(v).__name__)
278
279        for k2, v2 in self.mass_spectrum.items():
280            """Print the MSParameters object"""
281            for k3, v3 in v2.__dict__.items():
282                print("{} - {}: {}".format(k2, k3, type(v3).__name__))
283
284                for k4, v4 in v3.__dict__.items():
285                    print("    {}: {}".format(k4, v4))

Print the LCMSParameters object

def default_parameters(file_location): View Source

288def default_parameters(file_location):  # pragma: no cover
289    """Generate parameters dictionary with the default parameters for data processing
290       To gather parameters from instrument data during the data parsing step, a parameters dictionary with the default parameters needs to be generated.
291       This dictionary acts as a placeholder and is later used as an argument for all the class constructor methods during instantiation.
292       The data gathered from the instrument is added to the class properties.
293
294    Parameters
295    ----------
296    file_location: str
297        path to the file
298
299    Returns
300    -------
301    parameters: dict
302        dictionary with the default parameters for data processing
303    """
304
305    parameters = dict()
306
307    parameters["Aterm"] = 0
308
309    parameters["Bterm"] = 0
310
311    parameters["Cterm"] = 0
312
313    parameters["exc_high_freq"] = 0
314
315    parameters["exc_low_freq"] = 0
316
317    parameters["mw_low"] = 0
318
319    parameters["mw_high"] = 0
320
321    parameters["qpd_enabled"] = 0
322
323    parameters["bandwidth"] = 0
324
325    parameters["analyzer"] = "Unknown"
326
327    parameters["acquisition_time"] = None
328
329    parameters["instrument_label"] = "Unknown"
330
331    parameters["sample_name"] = "Unknown"
332
333    parameters["number_data_points"] = 0
334
335    parameters["polarity"] = "Unknown"
336
337    parameters["filename_path"] = str(file_location)
338
339    """scan_number and rt will be need to lc ms"""
340
341    parameters["mobility_scan"] = 0
342
343    parameters["mobility_rt"] = 0
344
345    parameters["scan_number"] = 0
346
347    parameters["rt"] = 0
348
349    return parameters

Generate parameters dictionary with the default parameters for data processing To gather parameters from instrument data during the data parsing step, a parameters dictionary with the default parameters needs to be generated. This dictionary acts as a placeholder and is later used as an argument for all the class constructor methods during instantiation. The data gathered from the instrument is added to the class properties.

Parameters

file_location (str): path to the file

Returns

parameters (dict): dictionary with the default parameters for data processing