def test_aif_with_fixed_chems(self): fs = EvenMZFormulaSampler() ms = FixedMS2Sampler(n_frags=2) cs = ConstantChromatogramSampler() ri = UniformRTAndIntensitySampler(min_rt=0, max_rt=1) cs = ChemicalMixtureCreator(fs, ms2_sampler=ms, chromatogram_sampler=cs, rt_and_intensity_sampler=ri) d = cs.sample(1, 2) ms1_source_cid_energy = 30 controller = AIF(ms1_source_cid_energy) ionisation_mode = POSITIVE mass_spec = IndependentMassSpectrometer(ionisation_mode, d) env = Environment(mass_spec, controller, 10, 20, progress_bar=True) set_log_level_warning() env.run() for i, s in enumerate(controller.scans[1]): if i % 2 == 1: # odd scan, AIF, should have two peaks at 81 and 91 integer_mzs = [int(i) for i in s.mzs] integer_mzs.sort() assert integer_mzs[0] == 81 assert integer_mzs[1] == 91 else: # even scan, MS1 - should have a single peak at integer value of 101 integer_mzs = [int(i) for i in s.mzs] assert integer_mzs[0] == 101
def run_single_WeightedDEW(params): out_file = 'WeightedDEW_{}_{}_{}.mzml'.format(params['sample_name'], params['t0'], params['r']) logger.warning('Generating %s' % out_file) if os.path.isfile(os.path.join(params['out_dir'], out_file)): logger.warning('Already done') return if params['t0'] > params['r']: logger.warning('Impossible combination') return controller = WeightedDEWController(params['ionisation_mode'], params['N'], params['isolation_width'], params['mz_tol'], params['r'], params['min_ms1_intensity'], exclusion_t_0=params['t0'], log_intensity=True) mass_spec = IndependentMassSpectrometer( params['ionisation_mode'], params['chems'], scan_duration=params['scan_duration']) env = Environment(mass_spec, controller, params['min_rt'], params['max_rt'], progress_bar=True, out_dir=params['out_dir'], out_file=out_file) env.run()
def run_TopN(chems, scan_duration, params, out_dir): """ Simulate TopN controller :param chems: a list of UnknownChemicals present in the injection :param ps: old PeakSampler object, now only used to generate MS2 scans (TODO: should be removed as part of issue #46) :param params: a dictionary of parameters :param out_file: output mzML file :param out_dir: output directory :return: None """ logger.info('Running TopN simulation') logger.info(params) out_file = '%s_%s.mzML' % (params['controller_name'], params['sample_name']) controller = TopNController(params['ionisation_mode'], params['N'], params['isolation_width'], params['mz_tol'], params['rt_tol'], params['min_ms1_intensity']) mass_spec = IndependentMassSpectrometer(params['ionisation_mode'], chems, scan_duration=scan_duration) env = Environment(mass_spec, controller, params['min_rt'], params['max_rt'], progress_bar=True, out_dir=out_dir, out_file=out_file) logger.info('Generating %s' % out_file) env.run()
def test_fullscan_from_mzml(self, chems_from_mzml): ionisation_mode = POSITIVE controller = SimpleMs1Controller() ms = IndependentMassSpectrometer(ionisation_mode, chems_from_mzml) env = Environment(ms, controller, 500, 600, progress_bar=True) set_log_level_warning() env.run() filename = 'fullscan_from_mzml.mzML' check_mzML(env, OUT_DIR, filename)
def test_roi_controller_with_beer_chems(self): logger.info('Testing ROI controller with QC beer chemicals') isolation_width = 1 # the isolation window in Dalton around a selected precursor ion N = 10 rt_tol = 15 mz_tol = 10 min_roi_intensity = 5000 min_roi_length = 10 ionisation_mode = POSITIVE # create a simulated mass spec with noise and ROI controller mass_spec = IndependentMassSpectrometer(ionisation_mode, BEER_CHEMS) controller = TopN_RoiController(ionisation_mode, isolation_width, mz_tol, MIN_MS1_INTENSITY, min_roi_intensity, min_roi_length, N, rt_tol) # create an environment to run both the mass spec and controller env = Environment(mass_spec, controller, BEER_MIN_BOUND, BEER_MAX_BOUND, progress_bar=True) run_environment(env) # check that there is at least one non-empty MS2 scan check_non_empty_MS2(controller) # write simulated output to mzML file filename = 'roi_controller_qcbeer_chems.mzML' check_mzML(env, OUT_DIR, filename)
def test_peaks_in_range(self): min_mz = 100. max_mz = 200. logger.info('Testing MS1 controller with narrow m/z range') # create a simulated mass spec and MS1 controller mass_spec = IndependentMassSpectrometer(POSITIVE, BEER_CHEMS) params = AdvancedParams() params.default_ms1_scan_window = (min_mz, max_mz) controller = SimpleMs1Controller(params=params) # create an environment to run both the mass spec and controller env = Environment(mass_spec, controller, BEER_MIN_BOUND, BEER_MAX_BOUND, progress_bar=True) run_environment(env) # write simulated output to mzML file filename = 'ms1_controller_qcbeer_chems_narrow.mzML' check_mzML(env, OUT_DIR, filename) for scan_level, scans in controller.scans.items(): for s in scans: assert min(s.mzs) >= min_mz assert max(s.mzs) <= max_mz
def test_topn_from_mzml(self, chems_from_mzml): ionisation_mode = POSITIVE N = 10 isolation_width = 0.7 mz_tol = 0.01 rt_tol = 15 min_ms1_intensity = 10 controller = TopNController(ionisation_mode, N, isolation_width, mz_tol, rt_tol, min_ms1_intensity) ms = IndependentMassSpectrometer(ionisation_mode, chems_from_mzml) env = Environment(ms, controller, 500, 600, progress_bar=True) set_log_level_warning() env.run() check_non_empty_MS2(controller) filename = 'topn_from_mzml.mzML' check_mzML(env, OUT_DIR, filename)
def test_TopN_controller_with_beer_chems_and_scan_duration_dict(self): logger.info('Testing Top-N controller with QC beer chemicals ' 'passing in the scan durations') isolation_width = 1 N = 10 rt_tol = 15 mz_tol = 10 ionisation_mode = POSITIVE # ps = None scan_duration_dict = {1: 0.2, 2: 0.1} # create a simulated mass spec without noise and Top-N controller and passing # in the scan_duration dict mass_spec = IndependentMassSpectrometer( ionisation_mode, BEER_CHEMS, scan_duration=scan_duration_dict) controller = TopNController(ionisation_mode, N, isolation_width, mz_tol, rt_tol, MIN_MS1_INTENSITY) # create an environment to run both the mass spec and controller env = Environment(mass_spec, controller, BEER_MIN_BOUND, BEER_MAX_BOUND, progress_bar=True) run_environment(env) # check that there is at least one non-empty MS2 scan check_non_empty_MS2(controller) # write simulated output to mzML file filename = 'topN_controller_qcbeer_chems_no_noise_with_scan_duration.mzML' check_mzML(env, OUT_DIR, filename)
def test_neg(self, even_chems): mass_spec = IndependentMassSpectrometer(NEGATIVE, even_chems) N = 10 controller = TopNController(NEGATIVE, N, 0.7, 10, 15, 0, force_N=True) env = Environment(mass_spec, controller, 200, 300, progress_bar=True) run_environment(env) for level in controller.scans: for scan in controller.scans[level]: assert scan.scan_params.get( ScanParameters.POLARITY) == NEGATIVE ms1_peaks = [int(m) for m in controller.scans[1][0].mzs] ms1_peaks.sort() assert 98 in ms1_peaks assert 198 in ms1_peaks assert 298 in ms1_peaks assert 398 in ms1_peaks filename = 'topn_negative.mzML' check_mzML(env, OUT_DIR, filename) # load the file and check polarity in the mzml run = pymzml.run.Reader(os.path.join(OUT_DIR, filename)) for n, spec in enumerate(run): assert spec.get( 'MS:1000129') # this is the negative scan accession
def test_TopN_controller_with_simulated_chems(self, fragscan_dataset): logger.info( 'Testing Top-N controller with simulated chemicals -- no noise') assert len(fragscan_dataset) == N_CHEMS isolation_width = 1 N = 10 rt_tol = 15 mz_tol = 10 ionisation_mode = POSITIVE # create a simulated mass spec without noise and Top-N controller mass_spec = IndependentMassSpectrometer(ionisation_mode, fragscan_dataset) controller = TopNController(ionisation_mode, N, isolation_width, mz_tol, rt_tol, MIN_MS1_INTENSITY) min_bound, max_bound = get_rt_bounds(fragscan_dataset, CENTRE_RANGE) # create an environment to run both the mass spec and controller env = Environment(mass_spec, controller, min_bound, max_bound, progress_bar=True) run_environment(env) # check that there is at least one non-empty MS2 scan check_non_empty_MS2(controller) filename = 'topN_controller_simulated_chems_no_noise.mzML' check_mzML(env, OUT_DIR, filename)
def test_targeted(self): fs = EvenMZFormulaSampler() ri = UniformRTAndIntensitySampler(min_rt=0, max_rt=10) cr = ConstantChromatogramSampler() ms = FixedMS2Sampler() cs = ChemicalMixtureCreator(fs, rt_and_intensity_sampler=ri, chromatogram_sampler=cr, ms2_sampler=ms) d = cs.sample(2, 2) # sample chems with m/z = 100 and 200 ionisation_mode = POSITIVE targets = [] targets.append(Target(101, 100, 102, 10, 20, adduct='M+H')) targets.append(Target(201, 200, 202, 10, 20, metadata={'a': 1})) ce_values = [10, 20, 30] n_replicates = 4 controller = TargetedController(targets, ce_values, n_replicates=n_replicates, limit_acquisition=True) mass_spec = IndependentMassSpectrometer(ionisation_mode, d) env = Environment(mass_spec, controller, 5, 25, progress_bar=True) set_log_level_warning() env.run() # check that we go all the scans we wanted for ms_level in controller.scans: assert len(controller.scans[ms_level]) > 0 set_log_level_debug() target_counts = {t: {c: 0 for c in ce_values} for t in targets} for s in controller.scans[2]: params = s.scan_params pmz = params.get(ScanParameters.PRECURSOR_MZ)[0].precursor_mz filtered_targets = list( filter( lambda x: (x.from_rt <= s.rt <= x.to_rt) and (x.from_mz <= pmz <= x.to_mz), targets)) assert len(filtered_targets) == 1 target = filtered_targets[0] ce = params.get(ScanParameters.COLLISION_ENERGY) target_counts[target][ce] += 1 for t in target_counts: for ce, count in target_counts[t].items(): assert count == n_replicates
def top_n_box_experiment(datasets, base_chemicals, rt_range, boxes_params, dataset_group_list, isolation_width, mz_tol, min_ms1_intensity, min_roi_intensity, min_roi_length, N, rt_tol, ionisation_mode=POSITIVE): env_list = [] aligner = RoiAligner() boxes = None boxes_intensity = None for i in range(len(datasets)): mass_spec = IndependentMassSpectrometer(ionisation_mode, datasets[i]) controller = TopNBoxRoiController(ionisation_mode, isolation_width, mz_tol, min_ms1_intensity, min_roi_intensity, min_roi_length, boxes_params=boxes_params, boxes=boxes, boxes_intensity=boxes_intensity, N=N, rt_tol=rt_tol) env = Environment(mass_spec, controller, rt_range[0], rt_range[1], progress_bar=True) env.run() env_list.append(env) rois = env.controller.live_roi + env.controller.dead_roi aligner.add_sample(rois, 'sample_' + str(i), dataset_group_list[i]) boxes = aligner.get_boxes() boxes_intensity = aligner.get_max_frag_intensities() final_evaluation = evaluate_multiple_simulated_env( env_list, base_chemicals=base_chemicals) return env_list, final_evaluation
def test_default_scan_time(self, chems_from_mzml): ionisation_mode = POSITIVE N = 10 isolation_width = 0.7 mz_tol = 0.01 rt_tol = 15 min_ms1_intensity = 10 controller = TopNController(ionisation_mode, N, isolation_width, mz_tol, rt_tol, min_ms1_intensity) # run simulation using default scan times ms = IndependentMassSpectrometer(ionisation_mode, chems_from_mzml, scan_duration=DEFAULT_SCAN_TIME_DICT) env = Environment(ms, controller, 500, 600, progress_bar=True) set_log_level_warning() env.run() filename = 'test_scan_time_default.mzML' check_mzML(env, OUT_DIR, filename)
def test_multiple_isolation(self): N = 3 fs = EvenMZFormulaSampler() ri = UniformRTAndIntensitySampler(min_rt=0, max_rt=10) cr = ConstantChromatogramSampler() ms = FixedMS2Sampler() cs = ChemicalMixtureCreator(fs, rt_and_intensity_sampler=ri, chromatogram_sampler=cr, ms2_sampler=ms) d = cs.sample(3, 2) # sample chems with m/z = 100 and 200 # ionisation_mode = POSITIVE controller = MultiIsolationController(N) ms = IndependentMassSpectrometer(POSITIVE, d) env = Environment(ms, controller, 10, 20, progress_bar=True) set_log_level_warning() env.run() assert len(controller.scans[1]) > 0 assert len(controller.scans[2]) > 0 # look at the first block of MS2 scans # and check that they are the correct super-positions mm = {} # first three scans hit the individual precursors mm[(0, )] = controller.scans[2][0] mm[(1, )] = controller.scans[2][1] mm[(2, )] = controller.scans[2][2] # next three should hit the pairs mm[(0, 1)] = controller.scans[2][3] mm[(0, 2)] = controller.scans[2][4] mm[(1, 2)] = controller.scans[2][5] # final should hit all three mm[(0, 1, 2)] = controller.scans[2][6] for key, value in mm.items(): actual_mz_vals = set(mm[key].mzs) expected_mz_vals = set() for k in key: for m in mm[(k, )].mzs: expected_mz_vals.add(m) assert expected_mz_vals == actual_mz_vals
def non_overlap_experiment(datasets, base_chemicals, rt_range, isolation_width, mz_tol, min_ms1_intensity, min_roi_intensity, min_roi_length, N, rt_tol, min_roi_length_for_fragmentation, rt_box_size, mz_box_size, ionisation_mode=POSITIVE): env_list = [] grid = GridEstimator( LocatorGrid(rt_range[0], rt_range[1], rt_box_size, 0, 3000, mz_box_size), IdentityDrift()) for i in range(len(datasets)): mass_spec = IndependentMassSpectrometer(ionisation_mode, datasets[i]) controller = NonOverlapController( ionisation_mode, isolation_width, mz_tol, min_ms1_intensity, min_roi_intensity, min_roi_length, N, grid, rt_tol=rt_tol, min_roi_length_for_fragmentation=min_roi_length_for_fragmentation) env = Environment(mass_spec, controller, rt_range[0], rt_range[1], progress_bar=True) env.run() env_list.append(env) final_evaluation = evaluate_multiple_simulated_env( env_list, base_chemicals=base_chemicals) return env_list, final_evaluation
def run_experiment(self, idx): controller_name = self.controller_schedule['Sample ID'][idx] mzml_files = glob.glob(os.path.join(self.base_dir, '*.mzML')) if controller_name + '.mzML' not in [ os.path.basename(file) for file in mzml_files ]: controller, ms_params = super().run_experiment(idx) # load data and set up MS logger.info(self.controller_schedule.iloc[[idx]].to_dict()) method = self.controller_schedule['Controller Method'][idx] dataset = self.controller_schedule['Dataset'][idx] if method is not None and dataset is not None: dataset = load_obj(self.controller_schedule['Dataset'][idx]) mass_spec = IndependentMassSpectrometer( ms_params['ionisation_mode'], dataset) # Run sample env = Environment(mass_spec, controller, self.rt_range[0][0], self.rt_range[0][1], progress_bar=self.progress_bar) env.run() env.write_mzML(self.base_dir, controller_name + '.mzML') if self.write_env: save_obj( controller, os.path.join(self.base_dir, controller_name + '.p')) else: logger.info('Experiment already completed. Skipping...') mzml_file = os.path.join(self.base_dir, controller_name + '.mzML') return mzml_file, controller_name
def run_single_SmartROI(params): out_file = 'SMART_{}_{}_{}.mzml'.format(params['sample_name'], params['iif'], params['dp']) logger.warning('Generating %s' % out_file) if os.path.isfile(os.path.join(params['out_dir'], out_file)): logger.warning('Already done') return intensity_increase_factor = params[ 'iif'] # fragment ROI again if intensity increases 10 fold drop_perc = params['dp'] / 100 reset_length_seconds = 1e6 # set so reset never happens controller = TopN_SmartRoiController( params['ionisation_mode'], params['isolation_width'], params['mz_tol'], params['min_ms1_intensity'], params['min_roi_intensity'], params['min_roi_length'], N=params['N'], rt_tol=params['rt_tol'], min_roi_length_for_fragmentation=params[ 'min_roi_length_for_fragmentation'], reset_length_seconds=reset_length_seconds, intensity_increase_factor=intensity_increase_factor, drop_perc=drop_perc) mass_spec = IndependentMassSpectrometer( params['ionisation_mode'], params['chems'], scan_duration=params['scan_duration']) env = Environment(mass_spec, controller, params['min_rt'], params['max_rt'], progress_bar=True, out_dir=params['out_dir'], out_file=out_file) env.run()
def generate_mzmls(self, output_dir, params): scan_duration_dicts = self.time_gen(params) if (self.filenames is None): self.filenames = [ os.path.join(output_dir, "time_exp_data_{:04d}.mzML".format(i)) for i, _ in enumerate(scan_duration_dicts) ] self.file_counter += len(scan_duration_dicts) if (len(params) != len(self.filenames)): raise ValueError( "Parameter and filename list not the same length!") for f, d in zip(self.filenames, scan_duration_dicts): mass_spec = IndependentMassSpectrometer(POSITIVE, self.chems, None, scan_duration_dict=d) controller = SimpleMs1Controller() env = Environment(mass_spec, controller, self.min_rt, self.max_rt, progress_bar=True) set_log_level_warning() env.run() set_log_level_warning() env.write_mzML(output_dir, os.path.basename(f))
def test_ms1_controller_with_qcbeer_chems(self): logger.info('Testing MS1 controller with QC beer chemicals') # create a simulated mass spec and MS1 controller mass_spec = IndependentMassSpectrometer(POSITIVE, beer_chems, self.ps) controller = SimpleMs1Controller() # create an environment to run both the mass spec and controller env = Environment(mass_spec, controller, min_rt, max_rt, progress_bar=True) # set the log level to WARNING so we don't see too many messages when environment is running set_log_level_warning() # run the simulation env.run() # set the log level back to DEBUG set_log_level_debug() # write simulated output to mzML file filename = 'ms1_controller_qcbeer_chems.mzML' out_file = os.path.join(out_dir, filename) env.write_mzML(out_dir, filename) self.assertTrue(os.path.exists(out_file)) print()
def test_ms1_controller_with_simulated_chems(self): logger.info('Testing MS1 controller with simulated chemicals') # create some chemical objects chems = ChemicalCreator(self.ps, ROI_Sources, hmdb) dataset = chems.sample(mz_range, rt_range, min_ms1_intensity, n_chems, self.ms_level) self.assertEqual(len(dataset), n_chems) # create a simulated mass spec and MS1 controller mass_spec = IndependentMassSpectrometer(POSITIVE, dataset, self.ps) controller = SimpleMs1Controller() # create an environment to run both the mass spec and controller env = Environment(mass_spec, controller, min_rt, max_rt, progress_bar=True) # set the log level to WARNING so we don't see too many messages when environment is running set_log_level_warning() # run the simulation env.run() # set the log level back to DEBUG set_log_level_debug() # write simulated output to mzML file filename = 'ms1_controller_simulated_chems.mzML' out_file = os.path.join(out_dir, filename) env.write_mzML(out_dir, filename) self.assertTrue(os.path.exists(out_file)) print()
def test_roi_controller_with_beer_chems(self): logger.info('Testing ROI controller with QC beer chemicals') isolation_width = 1 # the isolation window in Dalton around a selected precursor ion N = 10 rt_tol = 15 mz_tol = 10 min_roi_intensity = 5000 min_roi_length = 10 ionisation_mode = POSITIVE # create a simulated mass spec with noise and ROI controller mass_spec = IndependentMassSpectrometer(ionisation_mode, beer_chems, self.ps, add_noise=True) controller = RoiController(ionisation_mode, isolation_width, mz_tol, min_ms1_intensity, min_roi_intensity, min_roi_length, "Top N", N, rt_tol) # create an environment to run both the mass spec and controller env = Environment(mass_spec, controller, min_rt, max_rt, progress_bar=True) # set the log level to WARNING so we don't see too many messages when environment is running set_log_level_warning() # run the simulation env.run() # set the log level back to DEBUG set_log_level_debug() # write simulated output to mzML file filename = 'roi_controller_qcbeer_chems.mzML' out_file = os.path.join(out_dir, filename) env.write_mzML(out_dir, filename) self.assertTrue(os.path.exists(out_file)) print()
def test_TopN_controller_with_beer_chems(self): logger.info('Testing Top-N controller with QC beer chemicals') isolation_width = 1 N = 10 rt_tol = 15 mz_tol = 10 ionisation_mode = POSITIVE # create a simulated mass spec without noise and Top-N controller mass_spec = IndependentMassSpectrometer(ionisation_mode, beer_chems, self.ps, add_noise=False) controller = TopNController(ionisation_mode, N, isolation_width, mz_tol, rt_tol, min_ms1_intensity) # create an environment to run both the mass spec and controller env = Environment(mass_spec, controller, min_rt, max_rt, progress_bar=True) # set the log level to WARNING so we don't see too many messages when environment is running set_log_level_warning() # run the simulation env.run() # set the log level back to DEBUG set_log_level_debug() # write simulated output to mzML file filename = 'topN_controller_qcbeer_chems_no_noise.mzML' out_file = os.path.join(out_dir, filename) env.write_mzML(out_dir, filename) self.assertTrue(os.path.exists(out_file)) print()
def test_AIF_controller_with_beer_chems(self): logger.info('Testing Top-N controller with QC beer chemicals') # isolation_width = 1 # N = 10 # rt_tol = 15 # mz_tol = 10 ionisation_mode = POSITIVE min_mz = 100 max_mz = 500 # min_rt = 0 # max_rt = 500 # create a simulated mass spec without noise and Top-N controller scan_time_dict = {1: 0.124, 2: 0.124} mass_spec = IndependentMassSpectrometer(ionisation_mode, BEER_CHEMS, scan_duration=scan_time_dict) params = AdvancedParams(default_ms1_scan_window=[min_mz, max_mz]) ms1_source_cid_energy = 30 controller = AIF(ms1_source_cid_energy, params=params) # create an environment to run both the mass spec and controller env = Environment(mass_spec, controller, BEER_MIN_BOUND, BEER_MAX_BOUND, progress_bar=True) # set the log level to WARNING so we don't see too many messages # when environment is running set_log_level_warning() # run the simulation env.run() # set the log level back to DEBUG set_log_level_debug() # write simulated output to mzML file filename = 'AIF_qcbeer_chems_no_noise.mzML' check_mzML(env, OUT_DIR, filename)
def simple_ms1_processor(): print( '#' * 10, 'Load previously trained spectral feature database and the list of extracted metabolites, \ created in 01. Download Data') #----------------- mypath = 'documents/simple_ms1/example_data' #----------------- base_dir = os.path.abspath(mypath) ps = load_obj(Path(base_dir, 'peak_sampler_mz_rt_int_19_beers_fullscan.p')) hmdb = load_obj(Path(base_dir, 'hmdb_compounds.p')) # set_log_level_debug() out_dir = Path(base_dir, 'results', 'MS1_single') # the list of ROI sources created in the previous notebook '01. Download Data.ipynb' ROI_Sources = [ str(Path(base_dir, 'DsDA', 'DsDA_Beer', 'beer_t10_simulator_files')) ] # minimum MS1 intensity of chemicals min_ms1_intensity = 1.75E5 # m/z and RT range of chemicals rt_range = [(0, 1440)] mz_range = [(0, 1050)] # the number of chemicals in the sample n_chems = 6500 # maximum MS level (we do not generate fragmentation peaks when this value is 1) ms_level = 1 chems = ChemicalCreator(ps, ROI_Sources, hmdb) dataset = chems.sample(mz_range, rt_range, min_ms1_intensity, n_chems, ms_level) save_obj(dataset, Path(out_dir, 'dataset.p')) for chem in dataset[0:10]: print(chem) print('#' * 10, 'Run MS1 controller on the samples and generate .mzML files') min_rt = rt_range[0][0] max_rt = rt_range[0][1] mass_spec = IndependentMassSpectrometer(POSITIVE, dataset, ps) controller = SimpleMs1Controller() # create an environment to run both the mass spec and controller env = Environment(mass_spec, controller, min_rt, max_rt, progress_bar=True) # set the log level to WARNING so we don't see too many messages when environment is running set_log_level_warning() # run the simulation env.run() set_log_level_debug() mzml_filename = 'ms1_controller.mzML' env.write_mzML(out_dir, mzml_filename) return str(Path(mypath, 'results', 'MS1_single')) + '/' + mzml_filename
def test_intensity_nonoverlap_controller_with_simulated_chems( self, fragscan_dataset): logger.info( 'Testing intensity non-overlap controller with simulated chemicals' ) assert len(fragscan_dataset) == N_CHEMS isolation_width = 1 # the isolation window in Dalton around a selected precursor ion N = 10 rt_tol = 15 mz_tol = 10 min_roi_intensity = 50 min_roi_length = 0 ionisation_mode = POSITIVE min_bound, max_bound = get_rt_bounds(fragscan_dataset, CENTRE_RANGE) rt_box_size, mz_box_size = 1, 0.3 # create a simulated mass spec with noise and ROI controller mass_spec = IndependentMassSpectrometer(ionisation_mode, fragscan_dataset) grid = GridEstimator( AllOverlapGrid(min_bound, max_bound, rt_box_size, 0, 3000, mz_box_size), IdentityDrift()) controller = IntensityNonOverlapController( ionisation_mode, isolation_width, mz_tol, MIN_MS1_INTENSITY, min_roi_intensity, min_roi_length, N, grid, rt_tol=rt_tol, min_roi_length_for_fragmentation=0) # create an environment to run both the mass spec and controller env = Environment(mass_spec, controller, min_bound, max_bound, progress_bar=True) run_environment(env) assert len(controller.scans[2]) > 0 # check that there is at least one non-empty MS2 scan check_non_empty_MS2(controller) # write simulated output to mzML file filename = 'intensity_non_overlap_controller_simulated_chems.mzML' check_mzML(env, OUT_DIR, filename)
def test_ms1_controller_with_qcbeer_chems(self): logger.info('Testing MS1 controller with QC beer chemicals') # create a simulated mass spec and MS1 controller mass_spec = IndependentMassSpectrometer(POSITIVE, BEER_CHEMS) controller = SimpleMs1Controller() # create an environment to run both the mass spec and controller env = Environment(mass_spec, controller, BEER_MIN_BOUND, BEER_MAX_BOUND, progress_bar=True) run_environment(env) # write simulated output to mzML file filename = 'ms1_controller_qcbeer_chems.mzML' check_mzML(env, OUT_DIR, filename)
def test_flexible_non_overlap_controller_with_beer_chems_and_smartROI_rules( self): logger.info( 'Testing flexible non-overlap controller with QC beer chemicals and ' 'SmartROI rules') isolation_width = 1 # the isolation window in Dalton around a selected precursor ion N = 10 rt_tol = 15 mz_tol = 10 min_roi_intensity = 5000 min_roi_length = 10 ionisation_mode = POSITIVE rt_box_size, mz_box_size = 1, 0.3 # create a simulated mass spec with noise and ROI controller mass_spec = IndependentMassSpectrometer(ionisation_mode, BEER_CHEMS) grid = GridEstimator( AllOverlapGrid(BEER_MIN_BOUND, BEER_MAX_BOUND, rt_box_size, 0, 3000, mz_box_size), IdentityDrift()) controller = FlexibleNonOverlapController( ionisation_mode, isolation_width, mz_tol, MIN_MS1_INTENSITY, min_roi_intensity, min_roi_length, N, grid, rt_tol=rt_tol, min_roi_length_for_fragmentation=0, roi_type=ROI_TYPE_SMART, reset_length_seconds=1e6, intensity_increase_factor=10, drop_perc=0.1 / 100) # create an environment to run both the mass spec and controller env = Environment(mass_spec, controller, BEER_MIN_BOUND, BEER_MAX_BOUND, progress_bar=True) run_environment(env) # check that there is at least one non-empty MS2 scan check_non_empty_MS2(controller) # write simulated output to mzML file filename = 'flexible_non_overlap_qcbeer_chems_smartroi.mzML' check_mzML(env, OUT_DIR, filename)
def test_intensity_non_overlap_controller_with_beer_chems_and_weighteddew_rules( self): logger.info( 'Testing intensity non-overlap controller with QC beer chemicals ' 'and WeightedDEW rules') isolation_width = 1 # the isolation window in Dalton around a selected precursor ion N = 10 rt_tol = 120 exclusion_t_0 = 15 mz_tol = 10 min_roi_intensity = 5000 min_roi_length = 10 ionisation_mode = POSITIVE rt_box_size, mz_box_size = 1, 0.3 # create a simulated mass spec with noise and ROI controller mass_spec = IndependentMassSpectrometer(ionisation_mode, BEER_CHEMS) grid = GridEstimator( AllOverlapGrid(BEER_MIN_BOUND, BEER_MAX_BOUND, rt_box_size, 0, 3000, mz_box_size), IdentityDrift()) controller = IntensityNonOverlapController( ionisation_mode, isolation_width, mz_tol, MIN_MS1_INTENSITY, min_roi_intensity, min_roi_length, N, grid, rt_tol=rt_tol, min_roi_length_for_fragmentation=0, exclusion_method=ROI_EXCLUSION_WEIGHTED_DEW, exclusion_t_0=exclusion_t_0) # create an environment to run both the mass spec and controller env = Environment(mass_spec, controller, BEER_MIN_BOUND, BEER_MAX_BOUND, progress_bar=True) run_environment(env) # check that there is at least one non-empty MS2 scan check_non_empty_MS2(controller) # write simulated output to mzML file filename = 'intensity_non_overlap_qcbeer_chems_weighteddew.mzML' check_mzML(env, OUT_DIR, filename)
def run_vimms(no_injections, rt_box_size, mz_box_size): rt_range = [(0, 1440)] min_rt, max_rt = rt_range[0] ionisation_mode, isolation_width = POSITIVE, 1 N, rt_tol, mz_tol, min_ms1_intensity = 10, 15, 10, 5000 min_roi_intensity, min_roi_length, min_roi_length_for_fragmentation = \ 500, 3, 3 grid = GridEstimator( LocatorGrid(min_rt, max_rt, rt_box_size, 0, 3000, mz_box_size), IdentityDrift()) hmdbpath = os.path.join(os.path.abspath(os.getcwd()), "..", "..", "tests", "fixtures", "hmdb_compounds.p") hmdb = load_obj(hmdbpath) df = DatabaseFormulaSampler(hmdb, min_mz=100, max_mz=1000) cm = ChemicalMixtureCreator(df, adduct_prior_dict={POSITIVE: {"M+H": 1}}) chemicals = cm.sample(2000, 1) boxes = [] for i in range(no_injections): mz_noise = GaussianPeakNoise(0.1) mass_spec = IndependentMassSpectrometer(POSITIVE, chemicals, mz_noise=mz_noise) controller = NonOverlapController( ionisation_mode, isolation_width, mz_tol, min_ms1_intensity, min_roi_intensity, min_roi_length, N, grid, rt_tol=rt_tol, min_roi_length_for_fragmentation=min_roi_length_for_fragmentation ) env = Environment(mass_spec, controller, min_rt, max_rt, progress_bar=True) set_log_level_warning() env.run() boxes.append( [r.to_box(0.01, 0.01) for r in controller.roi_builder.get_rois()]) return boxes
def top_n_roi_experiment_evaluation(datasets, min_rt, max_rt, N, isolation_window, mz_tol, rt_tol, min_ms1_intensity, min_roi_intensity, min_roi_length, base_chemicals=None, mzmine_files=None, rt_tolerance=100, experiment_dir=None, progress_bar=False): if base_chemicals is not None or mzmine_files is not None: env_list = [] mzml_files = [] source_files = ['sample_' + str(i) for i in range(len(datasets))] for i in range(len(datasets)): mass_spec = IndependentMassSpectrometer(POSITIVE, datasets[i]) controller = TopN_RoiController(POSITIVE, isolation_window, mz_tol, min_ms1_intensity, min_roi_intensity, min_roi_length, N=N, rt_tol=rt_tol) env = Environment(mass_spec, controller, min_rt, max_rt, progress_bar=progress_bar) env.run() if progress_bar is False: print('Processed dataset ' + str(i)) env_list.append(env) if base_chemicals is None: file_link = os.path.join(experiment_dir, source_files[i] + '.mzml') mzml_files.append(file_link) env.write_mzML(experiment_dir, source_files[i] + '.mzml') if base_chemicals is not None: evaluation = evaluate_multiple_simulated_env( env_list, base_chemicals=base_chemicals) else: roi_aligner = RoiAligner(rt_tolerance=rt_tolerance) for i in range(len(mzml_files)): roi_aligner.add_picked_peaks(mzml_files[i], mzmine_files[i], source_files[i], 'mzmine') evaluation = evaluate_multi_peak_roi_aligner( roi_aligner, source_files) return env_list, evaluation else: return None, None