def test_runuis_swath(self):
self.assertEqual(len(self.precursors_to_evaluate), 905)
swath_mode = False
par = self.par
R = self.R
cursor = self.db.cursor()
prepare = []
self.min_q1 = 500
self.max_q1 = 525
# Get the precursors (now for 500-525 instead of the full range)
###########################################################################
myprecursors = Precursors()
cursor = self.db.cursor()
myprecursors.getFromDB(par, cursor, self.min_q1 - par.q1_window, self.max_q1 + par.q1_window)
rtree = myprecursors.build_rangetree()
self.precursors_to_evaluate = myprecursors.getPrecursorsToEvaluate(self.min_q1, self.max_q1)
self.assertEqual(len(self.precursors_to_evaluate), 39)
isotope_correction = par.isotopes_up_to * R.mass_diffC13 / min(par.parent_charges)
temp_precursors = Precursors()
temp_precursors.getFromDB(par, self.db.cursor(), self.min_q1 - isotope_correction, self.max_q1)
all_swath_precursors = []
for p in temp_precursors.precursors:
if(p.included_in_isotopic_range(self.min_q1, self.max_q1, par) ):
all_swath_precursors.append(p)
for precursor in self.precursors_to_evaluate:
q3_low, q3_high = par.get_q3range_transitions()
transitions = precursor.calculate_transitions(q3_low, q3_high)
nr_transitions = len(transitions)
if par.ssrcalc_window > 1000:
precursors_obj = [p for p in all_swath_precursors if p.transition_group != precursor.transition_group]
else:
ssrcalc_low = precursor.ssrcalc - par.ssrcalc_window
ssrcalc_high = precursor.ssrcalc + par.ssrcalc_window
precursors_obj = [p for p in all_swath_precursors if p.transition_group != precursor.transition_group
and p.ssrcalc > ssrcalc_low and p.ssrcalc < ssrcalc_high ]
collisions_per_peptide = collider.get_coll_per_peptide_from_precursors(self.acollider,
transitions, precursors_obj, par, precursor)
non_uis_list = collider.get_nonuis_list(collisions_per_peptide, par.max_uis)
for order in range(1,min(par.max_uis+1, nr_transitions+1)):
prepare.append( (len(non_uis_list[order]), collider.choose(nr_transitions,
order), precursor.parent_id , order, -1) )
self.assertEqual(len(prepare), 39*par.max_uis)
self.assertEqual(prepare[0], (5, 8.0, 69, 1, -1) )
final_report = self.get_final_report(par, prepare)
self.check_final_report_swath(final_report)
def test_runuis_swath_rangetree(self):
self.assertEqual(len(self.precursors_to_evaluate), 905)
swath_mode = False
par = self.par
R = self.R
cursor = self.db.cursor()
prepare = []
self.min_q1 = 500
self.max_q1 = 525
# Get the precursors (now for 500-525 instead of the full range)
###########################################################################
myprecursors = Precursors()
cursor = self.db.cursor()
myprecursors.getFromDB(par, cursor, self.min_q1 - par.q1_window, self.max_q1 + par.q1_window)
rtree = myprecursors.build_rangetree()
self.precursors_to_evaluate = myprecursors.getPrecursorsToEvaluate(self.min_q1, self.max_q1)
self.assertEqual(len(self.precursors_to_evaluate), 39)
# If we dont use the DB, we use the rangetree to query and get our list of
# precursors that are interfering. In SWATH we dont include a +/- q1_window
# around our range or precursors because the precursor window is fixed to
# (min_q1,max_q1) and no other precursors are considered.
myprecursors.getFromDB(par, cursor, self.min_q1, self.max_q1)
rtree = myprecursors.build_rangetree()
for precursor in self.precursors_to_evaluate:
q3_low, q3_high = par.get_q3range_transitions()
transitions = precursor.calculate_transitions(q3_low, q3_high)
nr_transitions = len(transitions)
# Use the rangetree, whether it is swath or not
collisions_per_peptide = self.myprecursors.get_collisions_per_peptide_from_rangetree(precursor, self.min_q1, self.max_q1, transitions, par, rtree)
non_uis_list = collider.get_nonuis_list(collisions_per_peptide, par.max_uis)
for order in range(1,min(par.max_uis+1, nr_transitions+1)):
prepare.append( (len(non_uis_list[order]), collider.choose(nr_transitions,
order), precursor.parent_id , order, -1) )
self.assertEqual(len(prepare), 39*par.max_uis)
# self.assertEqual(prepare[0], (5, 8.0, 69, 1, -1) )
final_report = self.get_final_report(par, prepare)
self.check_final_report_swath(final_report)
sys.exit()
###########################################################################
# Prepare the collider
db = par.get_db()
cursor = db.cursor()
if options.insert_mysql:
assert False # you have to implement this yourself
# Get the precursors
###########################################################################
from precursor import Precursors
myprecursors = Precursors()
myprecursors.getFromDB(par, db.cursor(), min_q1 - par.q1_window, max_q1 + par.q1_window)
if not options.query_peptide_table is None and not options.query_peptide_table == "":
print "Using a different table for the query peptides than for the background peptides!"
print "Will use table %s " % options.query_peptide_table
query_precursors = Precursors()
query_par = copy(par)
query_par.peptide_tables = [options.query_peptide_table]
query_precursors.getFromDB(query_par, db.cursor(), min_q1 - par.q1_window, max_q1 + par.q1_window)
precursors_to_evaluate = query_precursors.getPrecursorsToEvaluate(min_q1, max_q1)
else:
precursors_to_evaluate = myprecursors.getPrecursorsToEvaluate(min_q1, max_q1)
myprecursors.build_parent_id_lookup()
myprecursors.build_transition_group_lookup()
# If we dont use the DB, we use the rangetree to query and get our list of
# precursors that are interfering. In SWATH we dont include a +/- q1_window
min_q1 = float(sys.argv[2])
max_q1 = float(sys.argv[3])
outfile = options.outfile
strike3_ssrcalcwindow = options.ssr3strike
myorder =options.myorder
contamination_allow =options.allow_contamination
par.eval()
print par.get_common_filename()
skip_strike2 = True
# Get the precursors
###########################################################################
from precursor import Precursors
myprecursors = Precursors()
myprecursors.getFromDB(par, db.cursor(), min_q1 - par.q1_window, max_q1 + par.q1_window)
if options.GRAVY: myprecursors.use_GRAVY_scores()
rtree = myprecursors.build_rangetree()
precursors_to_evaluate = myprecursors.getPrecursorsToEvaluate(min_q1, max_q1)
myprecursors.build_parent_id_lookup()
myprecursors.build_transition_group_lookup()
print "Want to evaluate precursors", len(precursors_to_evaluate)
"""
The idea is to find UIS combinations that are globally UIS, locally
clean and also there are no cases in which all the UIS coelute when
they are in different peptides:
* global UIS = whole RT
* locally clean = no intereferences around the peptide
* no coelution: find all peptides globally that share transitions
def setUp(self):
self.transitions = transitions_def1
self.collisions = collisions_def1
self.EPSILON = 10**-5
self.min_q1 = 400
self.max_q1 = 1500
par = collider.SRM_parameters()
par.q1_window = 1 / 2.0
par.q3_window = 1 / 2.0
par.ssrcalc_window = 10 / 2.0
par.ppm = False
par.isotopes_up_to = 3
par.q3_low = 400
par.q3_high = 1400
par.max_uis = 5
par.peptide_tables = [ PEPTIDE_TABLE_NAME ]
par.mysql_config = '~/.my.cnf'
par.sqlite_database = test_shared.SQLITE_DATABASE_LOCATION
print par.sqlite_database
par.use_sqlite = USE_SQLITE
par.quiet = False
par.bions = True
par.yions = True
par.aions = False
par.aMinusNH3 = False
par.bMinusH2O = False
par.bMinusNH3 = False
par.bPlusH2O = False
par.yMinusH2O = False
par.yMinusNH3 = False
par.cions = False
par.xions = False
par.zions = False
par.MMinusH2O = False
par.MMinusNH3 = False
par.q3_range = [par.q3_low, par.q3_high]
par.set_default_vars()
par.eval()
self.par = par
self.R = Residues('mono')
self.acollider = collider.SRMcollider()
self.aparamset = collider.testcase()
self.db = par.get_db()
# Get the precursors
###########################################################################
myprecursors = Precursors()
cursor = self.db.cursor()
myprecursors.getFromDB(par, cursor, self.min_q1 - par.q1_window, self.max_q1 + par.q1_window)
testrange = myprecursors.build_rangetree()
self.precursors_to_evaluate = myprecursors.getPrecursorsToEvaluate(self.min_q1, self.max_q1)
myprecursors.build_parent_id_lookup()
myprecursors.build_transition_group_lookup()
self.myprecursors = myprecursors
cursor.close()
