def test_mean_scan_time_from_mzml(self):
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)
# extract chemicals from mzML
roi_params = RoiParams(min_intensity=10, min_length=5)
cm = ChemicalMixtureFromMZML(MZML_FILE, roi_params=roi_params)
chems = cm.sample(None, 2)
# extract mean timing per scan level from mzML
sd = MzMLScanTimeSampler(MZML_FILE, use_mean=True)
ms = IndependentMassSpectrometer(ionisation_mode,
chems,
scan_duration=sd)
# run simulation
env = Environment(ms, controller, 500, 600, progress_bar=True)
set_log_level_warning()
env.run()
filename = 'test_scan_time_mean_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_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_TreeDiaController_percentile(self, simple_dataset):
logger.info('Testing TreeDiaController percentile')
# some parameters
window_type = 'percentile'
kaufmann_design = 'tree'
num_windows = 64
scan_overlap = 0
ionisation_mode = POSITIVE
scan_time_dict = {1: 0.12, 2: 0.06}
min_rt = 0
max_rt = 400
min_mz = 100
max_mz = 1000
# run controller
mass_spec = IndependentMassSpectrometer(ionisation_mode, simple_dataset,
scan_duration=scan_time_dict)
controller = DiaController(min_mz, max_mz, window_type, kaufmann_design, num_windows,
scan_overlap=scan_overlap)
env = Environment(mass_spec, controller, min_rt, max_rt, progress_bar=True)
set_log_level_warning()
env.run()
# check that there is at least one non-empty MS2 scan
check_non_empty_MS2(controller)
# write simulated output to mzML file
filename = 'tree_dia_percentile.mzml'
check_mzML(env, OUT_DIR, filename)
def test_swath(self, ten_chems):
min_mz = 100
max_mz = 1000
width = 100
scan_overlap = 10
ionisation_mode = POSITIVE
controller = SWATH(min_mz, max_mz, width, scan_overlap=scan_overlap)
scan_time_dict = {1: 0.124, 2: 0.124}
spike_noise = UniformSpikeNoise(0.1, 1)
mass_spec = IndependentMassSpectrometer(ionisation_mode, ten_chems,
spike_noise=spike_noise,
scan_duration=scan_time_dict)
env = Environment(mass_spec, controller, 200, 300, progress_bar=True)
set_log_level_warning()
env.run()
check_non_empty_MS2(controller)
filename = 'SWATH_ten_chems.mzML'
check_mzML(env, OUT_DIR, filename)
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_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_mass_spec(self):
logger.info(
'Testing mass spec using the Top-N controller and QC beer chemicals'
)
isolation_width = 1
N = 10
rt_tol = 15
mz_tol = 10
ionisation_mode = POSITIVE
task_manager = TaskManager(buffer_size=3)
mass_spec = IndependentMassSpectrometer(ionisation_mode,
BEER_CHEMS,
task_manager=task_manager)
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)
env.run()
# check that there is at least one non-empty MS2 scan
check_non_empty_MS2(controller)
# write simulated output to mzML file
filename = 'test_mass_spec.mzML'
check_mzML(env, OUT_DIR, filename)
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_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 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_initial_exclusion_list(self):
logger.info('Testing Top-N controller with QC beer chemicals and '
'an initial exclusion list')
isolation_width = 1
N = 10
rt_tol = 15
mz_tol = 10
ionisation_mode = POSITIVE
initial_exclusion_list = []
for i in range(3):
mass_spec = IndependentMassSpectrometer(ionisation_mode,
BEER_CHEMS)
controller = TopNController(
ionisation_mode,
N,
isolation_width,
mz_tol,
rt_tol,
MIN_MS1_INTENSITY,
initial_exclusion_list=initial_exclusion_list)
env = Environment(mass_spec,
controller,
BEER_MIN_BOUND,
BEER_MAX_BOUND,
progress_bar=True)
run_environment(env)
mz_intervals = list(
controller.exclusion.exclusion_list.boxes_mz.items())
rt_intervals = list(
controller.exclusion.exclusion_list.boxes_rt.items())
unique_items_mz = set(i.data for i in mz_intervals)
unique_items_rt = set(i.data for i in rt_intervals)
assert len(unique_items_mz) == len(unique_items_rt)
initial_exclusion_list = list(unique_items_mz)
# 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_exclusion_%d.mzML' % i
check_mzML(env, OUT_DIR, filename)
def test_ms1_controller_with_simulated_chems(self, fragscan_dataset):
logger.info('Testing MS1 controller with simulated chemicals')
min_bound, max_bound = get_rt_bounds(fragscan_dataset, CENTRE_RANGE)
logger.info('RT bounds %s %s' % (min_bound, max_bound))
assert len(fragscan_dataset) == N_CHEMS
# create a simulated mass spec and MS1 controller
mass_spec = IndependentMassSpectrometer(POSITIVE, fragscan_dataset)
controller = SimpleMs1Controller()
# 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)
# write simulated output to mzML file
filename = 'ms1_controller_simulated_chems.mzML'
check_mzML(env, OUT_DIR, filename)
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_smart_roi_controller_with_simulated_chems(self, fragscan_dataset):
logger.info('Testing ROI 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
# create a simulated mass spec with noise and ROI controller
mass_spec = IndependentMassSpectrometer(ionisation_mode,
fragscan_dataset)
controller = TopN_SmartRoiController(
ionisation_mode,
isolation_width,
mz_tol,
MIN_MS1_INTENSITY,
min_roi_intensity,
min_roi_length,
N,
rt_tol,
min_roi_length_for_fragmentation=0)
# create an environment to run both the mass spec and controller
min_bound, max_bound = get_rt_bounds(fragscan_dataset, CENTRE_RANGE)
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 = 'smart_roi_controller_simulated_chems.mzML'
check_mzML(env, OUT_DIR, filename)
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 test_WeightedDEW_controller_with_beer_chems(self):
logger.info(
'Testing excluding Top-N controller with QC beer chemicals')
test_shift = 0
isolation_width = 1
N = 10
mz_tol = 10
ionisation_mode = POSITIVE
exclusion_t_0 = 15.0
rt_tol = 120
scan_duration_dict = {1: 0.2, 2: 0.1}
# create a simulated mass spec without noise and Top-N controller
mass_spec = IndependentMassSpectrometer(
ionisation_mode, BEER_CHEMS, scan_duration=scan_duration_dict)
controller = WeightedDEWController(ionisation_mode,
N,
isolation_width,
mz_tol,
rt_tol,
MIN_MS1_INTENSITY,
ms1_shift=test_shift,
exclusion_t_0=exclusion_t_0,
log_intensity=True)
# 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_weighted_dew_controller_qcbeer_chems_no_noise.mzML'
check_mzML(env, OUT_DIR, filename)
def test_TopNDEW_agent(self):
set_log_level_debug()
fs = UniformMZFormulaSampler()
ri = UniformRTAndIntensitySampler(min_rt=0, max_rt=80)
cr = GaussianChromatogramSampler(sigma=1)
ms = FixedMS2Sampler()
cs = ChemicalMixtureCreator(fs,
rt_and_intensity_sampler=ri,
chromatogram_sampler=cr,
ms2_sampler=ms)
d = cs.sample(500, 2)
ionisation_mode = POSITIVE
# Example shows how the same Agent object can be used in consecutive controllers
agent = TopNDEWAgent(ionisation_mode, 10, 0.7, 10, 15, 1500)
controller = AgentBasedController(agent)
spike_noise = UniformSpikeNoise(0.1, 1000)
mass_spec = IndependentMassSpectrometer(ionisation_mode,
d,
spike_noise=spike_noise)
env = Environment(mass_spec, controller, 0, 100, progress_bar=True)
set_log_level_warning()
env.run()
check_non_empty_MS1(controller)
check_non_empty_MS2(controller)
check_mzML(env, OUT_DIR, 'shell.mzML')
controller = AgentBasedController(agent)
mass_spec = IndependentMassSpectrometer(ionisation_mode,
d,
spike_noise=spike_noise)
env = Environment(mass_spec, controller, 0, 100, progress_bar=True)
set_log_level_warning()
env.run()
check_non_empty_MS1(controller)
check_non_empty_MS2(controller)
check_mzML(env, OUT_DIR, 'shell2.mzML')
controller = AgentBasedController(agent)
mass_spec = IndependentMassSpectrometer(ionisation_mode,
d,
spike_noise=spike_noise)
env = Environment(mass_spec, controller, 0, 100, progress_bar=True)
set_log_level_warning()
env.run()
check_non_empty_MS1(controller)
# check_non_empty_MS2(controller) # ms2 scans have been exhausted at this point
check_mzML(env, OUT_DIR, 'shell3.mzML')
def test_AIF_controller_with_simulated_chems(self, fragscan_dataset):
logger.info('Testing Top-N controller with simulated chemicals')
# create some chemical object
assert len(fragscan_dataset) == N_CHEMS
# isolation_width = 1
# N = 10
# rt_tol = 15
# mz_tol = 10
ionisation_mode = POSITIVE
min_mz = 100
max_mz = 500
# shorten the rt range for quicker tests
# min_rt = 0
# max_rt = 400
scan_time_dict = {1: 0.12, 2: 0.06}
# create a simulated mass spec without noise and Top-N controller
logger.info('Without noise')
mass_spec = IndependentMassSpectrometer(ionisation_mode, fragscan_dataset,
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
min_bound, max_bound = get_rt_bounds(fragscan_dataset, CENTRE_RANGE)
env = Environment(mass_spec, controller, min_bound, 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_simulated_chems_no_noise.mzML'
check_mzML(env, OUT_DIR, filename)
# create a simulated mass spec with noise and Top-N controller
logger.info('With noise')
mz_noise = GaussianPeakNoiseLevelSpecific({2: 0.01})
intensity_noise = GaussianPeakNoiseLevelSpecific({2: 1000.})
mass_spec = IndependentMassSpectrometer(ionisation_mode, fragscan_dataset,
mz_noise=mz_noise,
intensity_noise=intensity_noise,
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
min_bound, max_bound = get_rt_bounds(fragscan_dataset, CENTRE_RANGE)
env = Environment(mass_spec, controller, min_bound, 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_simulated_chems_with_noise.mzML'
check_mzML(env, OUT_DIR, filename)
