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)
def setUp(self): self.limit = 100 self.limit_large = 100 self.limit = 300 self.limit_large = 600 try: import MySQLdb #db_l = MySQLdb.connect(read_default_file="~/.my.cnf.local") db = MySQLdb.connect(read_default_file="~/.srm.cnf") cursor = db.cursor() self.cursor = cursor par = test_shared.get_default_setup_parameters() par.use_sqlite = True par.q1_window = 1.2 / 2.0 par.q3_window = 2.0 / 2.0 par.ssrcalc_window = 4 / 2.0 par.ssrcalc_window = 9999 / 2.0 par.peptide_tables = ['hroest.srmPeptides_yeast'] par.transition_table = 'hroest.srmTransitions_yeast' par.isotopes_up_to = 3 self.mycollider = collider.SRMcollider() par.select_by = "id" self.par = par self.min_q1 = 440 self.max_q1 = 450 ## For debugging ##self.max_q1 = 440.18 ##par.q1_window = 0.009 / 2.0 ##par.q3_window = 2.0 / 2.0 ##par.isotopes_up_to = 1 import Residues R = Residues.Residues('mono') isotope_correction = par.isotopes_up_to * R.mass_diffC13 / min(par.parent_charges) start = time.time() query = """ select modified_sequence, transition_group, parent_id, q1_charge, q1, ssrcalc, isotope_nr, 0, 0 from %s where q1 between %s and %s #and isotope_nr = 0 """ % (par.peptide_tables[0], self.min_q1 - par.q1_window, self.max_q1 + par.q1_window) cursor.execute(query) self.alltuples = list(cursor.fetchall() ) #print "len alltuples", len(self.alltuples) query = """ select modified_sequence, transition_group, parent_id, q1_charge, q1, ssrcalc, isotope_nr, 0, 0 from %s where q1 between %s - %s and %s and isotope_nr = 0 """ % (par.peptide_tables[0], self.min_q1 - par.q1_window, isotope_correction, self.max_q1 + par.q1_window) cursor.execute(query) self.alltuples_isotope_correction = list(cursor.fetchall()) #print "len alltuples zero", len(self.alltuples_isotope_correction) self.myprecursors = Precursors() # myprecursors.getFromDB(par, db.cursor(), self.min_q1 - par.q1_window, self.max_q1 + par.q1_window) ##### LEGACY getFromDB -- have isotope_nr = 0 in there! # Get all precursors from the DB within a window of Q1 lower_q1 = self.min_q1 - par.q1_window upper_q1 = self.max_q1 + par.q1_window self.myprecursors.precursors = [] isotope_correction = par.isotopes_up_to * R.mass_diffC13 / min(par.parent_charges) q = """ select modified_sequence, transition_group, parent_id, q1_charge, q1, ssrcalc, modifications, missed_cleavages, isotopically_modified from %(peptide_table)s where q1 between %(lowq1)s - %(isotope_correction)s and %(highq1)s and isotope_nr = 0 """ % {'peptide_table' : par.peptide_tables[0], 'lowq1' : lower_q1, # min_q1 - par.q1_window 'highq1' : upper_q1, # max_q1 + par.q1_window, 'isotope_correction' : isotope_correction } cursor.execute(q) for res in cursor.fetchall(): p = Precursor() p.initialize(*res) # Only include those precursors that are actually have isotopes in the specified range if(p.included_in_isotopic_range(lower_q1, upper_q1, par) ): self.myprecursors.precursors.append(p) ##### END LEGACY getFromDB self.precursors_to_evaluate = self.myprecursors.getPrecursorsToEvaluate(self.min_q1, self.max_q1) except Exception as inst: print "something went wrong" print inst
class Test_speed_integrated(unittest.TestCase): def setUp(self): self.limit = 100 self.limit_large = 100 self.limit = 300 self.limit_large = 600 try: import MySQLdb #db_l = MySQLdb.connect(read_default_file="~/.my.cnf.local") db = MySQLdb.connect(read_default_file="~/.srm.cnf") cursor = db.cursor() self.cursor = cursor par = test_shared.get_default_setup_parameters() par.use_sqlite = True par.q1_window = 1.2 / 2.0 par.q3_window = 2.0 / 2.0 par.ssrcalc_window = 4 / 2.0 par.ssrcalc_window = 9999 / 2.0 par.peptide_tables = ['hroest.srmPeptides_yeast'] par.transition_table = 'hroest.srmTransitions_yeast' par.isotopes_up_to = 3 self.mycollider = collider.SRMcollider() par.select_by = "id" self.par = par self.min_q1 = 440 self.max_q1 = 450 ## For debugging ##self.max_q1 = 440.18 ##par.q1_window = 0.009 / 2.0 ##par.q3_window = 2.0 / 2.0 ##par.isotopes_up_to = 1 import Residues R = Residues.Residues('mono') isotope_correction = par.isotopes_up_to * R.mass_diffC13 / min(par.parent_charges) start = time.time() query = """ select modified_sequence, transition_group, parent_id, q1_charge, q1, ssrcalc, isotope_nr, 0, 0 from %s where q1 between %s and %s #and isotope_nr = 0 """ % (par.peptide_tables[0], self.min_q1 - par.q1_window, self.max_q1 + par.q1_window) cursor.execute(query) self.alltuples = list(cursor.fetchall() ) #print "len alltuples", len(self.alltuples) query = """ select modified_sequence, transition_group, parent_id, q1_charge, q1, ssrcalc, isotope_nr, 0, 0 from %s where q1 between %s - %s and %s and isotope_nr = 0 """ % (par.peptide_tables[0], self.min_q1 - par.q1_window, isotope_correction, self.max_q1 + par.q1_window) cursor.execute(query) self.alltuples_isotope_correction = list(cursor.fetchall()) #print "len alltuples zero", len(self.alltuples_isotope_correction) self.myprecursors = Precursors() # myprecursors.getFromDB(par, db.cursor(), self.min_q1 - par.q1_window, self.max_q1 + par.q1_window) ##### LEGACY getFromDB -- have isotope_nr = 0 in there! # Get all precursors from the DB within a window of Q1 lower_q1 = self.min_q1 - par.q1_window upper_q1 = self.max_q1 + par.q1_window self.myprecursors.precursors = [] isotope_correction = par.isotopes_up_to * R.mass_diffC13 / min(par.parent_charges) q = """ select modified_sequence, transition_group, parent_id, q1_charge, q1, ssrcalc, modifications, missed_cleavages, isotopically_modified from %(peptide_table)s where q1 between %(lowq1)s - %(isotope_correction)s and %(highq1)s and isotope_nr = 0 """ % {'peptide_table' : par.peptide_tables[0], 'lowq1' : lower_q1, # min_q1 - par.q1_window 'highq1' : upper_q1, # max_q1 + par.q1_window, 'isotope_correction' : isotope_correction } cursor.execute(q) for res in cursor.fetchall(): p = Precursor() p.initialize(*res) # Only include those precursors that are actually have isotopes in the specified range if(p.included_in_isotopic_range(lower_q1, upper_q1, par) ): self.myprecursors.precursors.append(p) ##### END LEGACY getFromDB self.precursors_to_evaluate = self.myprecursors.getPrecursorsToEvaluate(self.min_q1, self.max_q1) except Exception as inst: print "something went wrong" print inst @attr('comparison') def test_integrated_cpp(self): """ Compare the fully integrated vs the mixed C++ rangetree / Python solution. Here we are comparing the fully integrated solution of storing all precursors in a C++ range tree and never passing them to Python vs the solution where we store the precursors in the rangetree, pass them to Python and then evaluate them. """ verbose = True verbose = False print '\n'*1 print "Comparing fully integrated solution (c_integrated.wrap_all)" par = self.par cursor = self.cursor all_precursors = self.precursors_to_evaluate shuffle(all_precursors) all_precursors = all_precursors[:self.limit_large] self.myprecursors.build_parent_id_lookup() testrange = self.myprecursors.build_rangetree() import c_rangetree r = c_rangetree.ExtendedRangetree_Q1_RT.create() r.new_rangetree() r.create_tree(tuple(self.alltuples_isotope_correction)) #c_integrated.create_tree(tuple(self.alltuples_isotope_correction)) MAX_UIS = 5 newtime = 0; oldtime = 0; ctime = 0 oldsql = 0; newsql = 0 alllocaltime = 0 localprecursor = 0 transitiontime = 0 c_fromprecursortime = 0 prepare = [] self._cursor = False print "Running experiment ", par.get_common_filename() print "calc_trans. = time to calculate the transitions of the precursor" print "old = use rangetree to get precursors, use C++ code to get collperpep" print "new = use rangetree to get precursors, use single C++ code to get collperpep" print "i\tcalc_trans.\tnew\t\told\t\t>>\tspeedup" for kk, precursor in enumerate(all_precursors): ii = kk + 1 q1 = precursor.q1 ssrcalc = precursor.ssrcalc sequence = precursor.modified_sequence peptide_key = precursor.transition_group p_id = precursor.parent_id q3_low, q3_high = par.get_q3range_transitions() #new way to calculate the precursors mystart = time.time() transitions = c_getnonuis.calculate_transitions_ch( ((q1, sequence, p_id),), [1,2], q3_low, q3_high) nr_transitions = len( transitions ) #fake some srm_id for the transitions transitions = tuple([ (t[0], i) for i,t in enumerate(transitions)]) q1_low = q1 - par.q1_window q1_high = q1 + par.q1_window innerstart = time.time() #correct rounding errors, s.t. we get the same results as before! ssrcalc_low = ssrcalc - par.ssrcalc_window + 0.001 ssrcalc_high = ssrcalc + par.ssrcalc_window - 0.001 transitiontime += time.time() - mystart isotope_correction = par.isotopes_up_to * Residues.mass_diffC13 / min(par.parent_charges) ################################### # New way to calculate non_uislist # - start out from transitions, get non_uislist mystart = time.time() newresult = c_integrated.wrap_all_bitwise(transitions, q1_low, ssrcalc_low, q1_high, ssrcalc_high, peptide_key, min(MAX_UIS,nr_transitions) , par.q3_window, #q3_low, q3_high, par.ppm, par.isotopes_up_to, isotope_correction, par, r) newtime += time.time() - mystart ################################### # Old way to calculate non_uislist: # - get collisions per peptide # - get non_uislist mystart = time.time() collisions_per_peptide_obj = self.myprecursors.get_collisions_per_peptide_from_rangetree( precursor, precursor.q1 - par.q1_window, precursor.q1 + par.q1_window, transitions, par, r) ## # if False: ## # precursor_ids = tuple(c_rangetree.query_tree( q1_low, ssrcalc_low, ## # q1_high, ssrcalc_high, par.isotopes_up_to, isotope_correction)) ## # precursors = tuple([parentid_lookup[myid[0]] for myid in precursor_ids ## # #dont select myself ## # if parentid_lookup[myid[0]][2] != peptide_key]) ## # collisions_per_peptide = c_getnonuis.calculate_collisions_per_peptide( ## # transitions, precursors, q3_low, q3_high, par.q3_window, par.ppm) non_uis_list = [{} for i in range(MAX_UIS+1)] for order in range(1,MAX_UIS+1): non_uis_list[order] = c_getnonuis.get_non_uis( collisions_per_peptide_obj, order) oldtime += time.time() - mystart non_uis_list_old_way = [set(kk.keys()) for kk in non_uis_list] non_uis_list_len = [len(kk) for kk in non_uis_list_old_way[1:]] ################################### # Assert equality, print out result self.assertEqual( newresult , non_uis_list_len) mys = "%s\t%0.4fms\t%0.2fms\t\t%0.2fms\t\t>>\t%0.2f" % \ (ii, transitiontime *1000/ ii, newtime*1000/ii, oldtime*1000/ii, oldtime *1.0 / newtime) #start a new line for each output? #mys += '\t%s\t%s' % ( len(precursors), len(precursor_new) ) if False: mys += '\n' self.ESC = chr(27) sys.stdout.write(self.ESC + '[2K') if self._cursor: sys.stdout.write(self.ESC + '[u') self._cursor = True sys.stdout.write(self.ESC + '[s') sys.stdout.write(mys) sys.stdout.flush() # except Exception as inst: # print "something went wrong" # print inst #@attr('comparison') def test_two_table_mysql(self): """Compare the two table vs the one table MySQL approach Here we are comparing the old (querying the transitions database as well as the precursor database) and the new way (only query the precursor database and calculate the transitions on the fly) way of calculating the collisions. """ print '\n'*1 print "Comparing one vs two table MySQL solution" par = self.par cursor = self.cursor mycollider = collider.SRMcollider() mypepids = _get_unique_pepids(par, cursor) self.mycollider.pepids = mypepids self.mycollider.calcinner = 0 shuffle( self.mycollider.pepids ) self.mycollider.pepids = self.mycollider.pepids[:self.limit] MAX_UIS = 5 c_newuistime = 0; oldtime = 0; c_fromprecursortime = 0 oldsql = 0; newsql = 0 oldcalctime = 0; localsql = 0 self._cursor = False print "oldtime = get UIS from collisions and transitions (getting all collisions from the transitions db)" print "cuis + oldsql = as oldtime but calculate UIS in C++" print "py+newsql = only get the precursors from the db and calculate collisions in Python" print "ctime + newsql = only get the precursors from the db and calculate collisions in C++" print "new = use fast SQL and C++ code" print "old = use slow SQL and Python code" print "i\toldtime\tcuis+oldsql\tpy+newsql\tctime+newsql\t>>>\toldsql\tnewsql\t...\t...\tspeedup" for kk, pep in enumerate(self.mycollider.pepids): ii = kk + 1 p_id = pep['parent_id'] q1 = pep['q1'] q3_low, q3_high = par.get_q3range_transitions() precursor = Precursor(q1=pep['q1'], transition_group=pep['transition_group'], parent_id = pep['parent_id'], modified_sequence=pep['mod_sequence'], ssrcalc=pep['ssrcalc']) transitions = collider.calculate_transitions_ch( ((q1, pep['mod_sequence'], p_id),), [1], q3_low, q3_high) #fake some srm_id for the transitions transitions = tuple([ (t[0], i) for i,t in enumerate(transitions)]) ##### transitions = self.mycollider._get_all_transitions(par, pep, cursor) nr_transitions = len( transitions ) if nr_transitions == 0: continue #no transitions in this window # mystart = time.time() collisions = list(self.mycollider._get_all_collisions_calculate_new(par, precursor, cursor)) oldcolllen = len(collisions) oldcalctime += time.time() - mystart # mystart = time.time() collisions = _get_all_collisions(mycollider, par, pep, cursor, transitions = transitions) oldcsqllen = len(collisions) oldsql += time.time() - mystart # par.query2_add = ' and isotope_nr = 0 ' # due to the new handling of isotopes mystart = time.time() self.mycollider.mysqlnewtime= 0 precursors = self.mycollider._get_all_precursors(par, precursor, cursor) newsql += time.time() - mystart # mystart = time.time() #precursors = self.mycollider._get_all_precursors(par, pep, cursor_l) localsql += time.time() - mystart par.query2_add = '' # due to the new handling of isotopes # mystart = time.time() non_uis_list = get_non_UIS_from_transitions(transitions, tuple(collisions), par, MAX_UIS) cnewuis = non_uis_list c_newuistime += time.time() - mystart # mystart = time.time() non_uis_list = get_non_UIS_from_transitions_old(transitions, collisions, par, MAX_UIS) oldnonuislist = non_uis_list oldtime += time.time() - mystart # mystart = time.time() q3_low, q3_high = par.get_q3range_transitions() collisions_per_peptide = c_getnonuis.calculate_collisions_per_peptide_other_ion_series( transitions, precursors, par, q3_low, q3_high, par.q3_window, par.ppm, False) non_uis_list = [ {} for i in range(MAX_UIS+1)] for order in range(1,MAX_UIS+1): non_uis_list[order] = c_getnonuis.get_non_uis( collisions_per_peptide, order) c_fromprecursortime += time.time() - mystart newl = [len(n) for n in non_uis_list] self.assertEqual(newl, [len(o) for o in cnewuis]) self.assertEqual(newl, [len(o) for o in oldnonuislist]) non_uis_list = [set(k.keys()) for k in non_uis_list] cnewuis = [set(k.keys()) for k in cnewuis] self.assertEqual(non_uis_list, cnewuis) self.assertEqual(non_uis_list, oldnonuislist) mys = "%s\t%0.fms\t%0.fms\t\t%0.fms\t\t%0.2fms\t\t>>>\t%0.fms\t%0.2fms\t...\t...\t%0.2f" % \ (ii, #i (oldtime + oldsql)*1000/ii, #oldtime (c_newuistime+oldsql)*1000/ii, #cuis + oldsql (oldcalctime + newsql + oldtime)*1000/ii, #newsql (c_fromprecursortime + newsql)*1000/ii, #ctime+newsql #(c_fromprecursortime + localsql)*1000/ii, oldsql*1000/ii, #newsql newsql*1000/ii, #oldsql #localsql*1000/ii, #oldtime / c_newuistime (oldtime + oldsql) / (c_fromprecursortime + newsql) ) self.ESC = chr(27) sys.stdout.write(self.ESC + '[2K') if self._cursor: sys.stdout.write(self.ESC + '[u') self._cursor = True sys.stdout.write(self.ESC + '[s') sys.stdout.write(mys) sys.stdout.flush() #@attr('comparison') def test_mysql_vs_integrated(self): """Compare the one table MySQL approach vs the fully integrated Cpp approach Here we are comparing the old (querying the transitions database as well as the precursor database) and the new way (only query the precursor database and calculate the transitions on the fly) way of calculating the collisions. """ print '\n'*1 print "Comparing one table MySQL solution vs integrated solution" par = self.par cursor = self.cursor mypepids = [ { 'mod_sequence' : r[0], 'peptide_key' :r[1], 'transition_group' :r[1], 'parent_id' : r[2], 'q1_charge' : r[3], 'q1' : r[4], 'ssrcalc' : r[5], } for r in self.alltuples if r[3] == 2 #charge is 2 and r[6] == 0 #isotope is 0 and r[4] >= self.min_q1 and r[4] < self.max_q1 ] mycollider = collider.SRMcollider() #mypepids = _get_unique_pepids(par, cursor) self.mycollider.pepids = mypepids self.mycollider.calcinner = 0 shuffle( self.mycollider.pepids ) self.mycollider.pepids = self.mycollider.pepids[:self.limit] import c_rangetree r = c_rangetree.ExtendedRangetree_Q1_RT.create() r.new_rangetree() r.create_tree(tuple(self.alltuples_isotope_correction)) #c_integrated.create_tree(tuple(self.alltuples_isotope_correction)) MAX_UIS = 5 c_newuistime = 0; oldtime = 0; c_fromprecursortime = 0 oldsql = 0; newsql = 0 newtime = 0 oldcalctime = 0; localsql = 0 self._cursor = False print "i\toldtime\t\tnewtime\t>>\tspeedup" for kk, pep in enumerate(self.mycollider.pepids): ii = kk + 1 p_id = pep['parent_id'] q1 = pep['q1'] q3_low, q3_high = par.get_q3range_transitions() q1_low = q1 - par.q1_window q1_high = q1 + par.q1_window ssrcalc = pep['ssrcalc'] peptide_key = pep['peptide_key'] #correct rounding errors, s.t. we get the same results as before! ssrcalc_low = ssrcalc - par.ssrcalc_window + 0.001 ssrcalc_high = ssrcalc + par.ssrcalc_window - 0.001 isotope_correction = par.isotopes_up_to * Residues.mass_diffC13 / min(par.parent_charges) precursor = Precursor(q1=pep['q1'], transition_group=pep['transition_group'], parent_id = pep['parent_id'], modified_sequence=pep['mod_sequence'], ssrcalc=pep['ssrcalc']) transitions = collider.calculate_transitions_ch( ((q1, pep['mod_sequence'], p_id),), [1], q3_low, q3_high) #fake some srm_id for the transitions transitions = tuple([ (t[0], i) for i,t in enumerate(transitions)]) ##### transitions = self.mycollider._get_all_transitions(par, pep, cursor) nr_transitions = len( transitions ) if nr_transitions == 0: continue #no transitions in this window ################################### # Old way to calculate non_uislist # - get all precursors from the SQL database # - calculate collisions per peptide in C++ par.query2_add = ' and isotope_nr = 0 ' # due to the new handling of isotopes mystart = time.time() self.mycollider.mysqlnewtime= 0 precursors = self.mycollider._get_all_precursors(par, precursor, cursor) newsql += time.time() - mystart mystart = time.time() q3_low, q3_high = par.get_q3range_transitions() collisions_per_peptide = c_getnonuis.calculate_collisions_per_peptide_other_ion_series( transitions, precursors, par, q3_low, q3_high, par.q3_window, par.ppm, False) non_uis_list = [ {} for i in range(MAX_UIS+1)] for order in range(1,MAX_UIS+1): non_uis_list[order] = c_getnonuis.get_non_uis( collisions_per_peptide, order) c_fromprecursortime += time.time() - mystart newl = [len(n) for n in non_uis_list] non_uis_list_old_way = [set(kk.keys()) for kk in non_uis_list] non_uis_list_len = [len(kk) for kk in non_uis_list_old_way[1:]] ################################### # New way to calculate non_uislist # - start out from transitions, get non_uislist mystart = time.time() newresult = c_integrated.wrap_all_bitwise(transitions, q1_low, ssrcalc_low, q1_high, ssrcalc_high, peptide_key, min(MAX_UIS,nr_transitions) , par.q3_window, #q3_low, q3_high, par.ppm, par.isotopes_up_to, isotope_correction, par, r) newtime += time.time() - mystart ################################### # Assert equality, print out result self.assertEqual( newresult , non_uis_list_len) mys = "%s\t%0.1fms\t\t%0.2fms\t>>>\t%0.1f" % \ (ii, #i (c_fromprecursortime + newsql)*1000/ii, # oldtime (newtime)*1000/ii, # newtime (c_fromprecursortime + newsql) / (newtime), # speedup ) self.ESC = chr(27) sys.stdout.write(self.ESC + '[2K') if self._cursor: sys.stdout.write(self.ESC + '[u') self._cursor = True sys.stdout.write(self.ESC + '[s') sys.stdout.write(mys) sys.stdout.flush()
raise Exception("Your Q1 window needs to be at least as large as the min/max q1 you chose.") 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
exp_key = sys.argv[1] 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
def setUp(self): self.limit = 100 self.limit_large = 100 self.limit = 300 self.limit_large = 600 try: import MySQLdb #db_l = MySQLdb.connect(read_default_file="~/.my.cnf.local") db = MySQLdb.connect(read_default_file="~/.srm.cnf") cursor = db.cursor() self.cursor = cursor par = test_shared.get_default_setup_parameters() par.use_sqlite = True par.q1_window = 1.2 / 2.0 par.q3_window = 2.0 / 2.0 par.ssrcalc_window = 4 / 2.0 par.ssrcalc_window = 9999 / 2.0 par.peptide_tables = ['hroest.srmPeptides_yeast'] par.transition_table = 'hroest.srmTransitions_yeast' par.isotopes_up_to = 3 self.mycollider = collider.SRMcollider() par.select_by = "id" self.par = par self.min_q1 = 440 self.max_q1 = 450 ## For debugging ##self.max_q1 = 440.18 ##par.q1_window = 0.009 / 2.0 ##par.q3_window = 2.0 / 2.0 ##par.isotopes_up_to = 1 import Residues R = Residues.Residues('mono') isotope_correction = par.isotopes_up_to * R.mass_diffC13 / min( par.parent_charges) start = time.time() query = """ select modified_sequence, transition_group, parent_id, q1_charge, q1, ssrcalc, isotope_nr, 0, 0 from %s where q1 between %s and %s #and isotope_nr = 0 """ % (par.peptide_tables[0], self.min_q1 - par.q1_window, self.max_q1 + par.q1_window) cursor.execute(query) self.alltuples = list(cursor.fetchall()) #print "len alltuples", len(self.alltuples) query = """ select modified_sequence, transition_group, parent_id, q1_charge, q1, ssrcalc, isotope_nr, 0, 0 from %s where q1 between %s - %s and %s and isotope_nr = 0 """ % (par.peptide_tables[0], self.min_q1 - par.q1_window, isotope_correction, self.max_q1 + par.q1_window) cursor.execute(query) self.alltuples_isotope_correction = list(cursor.fetchall()) #print "len alltuples zero", len(self.alltuples_isotope_correction) self.myprecursors = Precursors() # myprecursors.getFromDB(par, db.cursor(), self.min_q1 - par.q1_window, self.max_q1 + par.q1_window) ##### LEGACY getFromDB -- have isotope_nr = 0 in there! # Get all precursors from the DB within a window of Q1 lower_q1 = self.min_q1 - par.q1_window upper_q1 = self.max_q1 + par.q1_window self.myprecursors.precursors = [] isotope_correction = par.isotopes_up_to * R.mass_diffC13 / min( par.parent_charges) q = """ select modified_sequence, transition_group, parent_id, q1_charge, q1, ssrcalc, modifications, missed_cleavages, isotopically_modified from %(peptide_table)s where q1 between %(lowq1)s - %(isotope_correction)s and %(highq1)s and isotope_nr = 0 """ % { 'peptide_table': par.peptide_tables[0], 'lowq1': lower_q1, # min_q1 - par.q1_window 'highq1': upper_q1, # max_q1 + par.q1_window, 'isotope_correction': isotope_correction } cursor.execute(q) for res in cursor.fetchall(): p = Precursor() p.initialize(*res) # Only include those precursors that are actually have isotopes in the specified range if (p.included_in_isotopic_range(lower_q1, upper_q1, par)): self.myprecursors.precursors.append(p) ##### END LEGACY getFromDB self.precursors_to_evaluate = self.myprecursors.getPrecursorsToEvaluate( self.min_q1, self.max_q1) except Exception as inst: print "something went wrong" print inst
class Test_speed_integrated(unittest.TestCase): def setUp(self): self.limit = 100 self.limit_large = 100 self.limit = 300 self.limit_large = 600 try: import MySQLdb #db_l = MySQLdb.connect(read_default_file="~/.my.cnf.local") db = MySQLdb.connect(read_default_file="~/.srm.cnf") cursor = db.cursor() self.cursor = cursor par = test_shared.get_default_setup_parameters() par.use_sqlite = True par.q1_window = 1.2 / 2.0 par.q3_window = 2.0 / 2.0 par.ssrcalc_window = 4 / 2.0 par.ssrcalc_window = 9999 / 2.0 par.peptide_tables = ['hroest.srmPeptides_yeast'] par.transition_table = 'hroest.srmTransitions_yeast' par.isotopes_up_to = 3 self.mycollider = collider.SRMcollider() par.select_by = "id" self.par = par self.min_q1 = 440 self.max_q1 = 450 ## For debugging ##self.max_q1 = 440.18 ##par.q1_window = 0.009 / 2.0 ##par.q3_window = 2.0 / 2.0 ##par.isotopes_up_to = 1 import Residues R = Residues.Residues('mono') isotope_correction = par.isotopes_up_to * R.mass_diffC13 / min( par.parent_charges) start = time.time() query = """ select modified_sequence, transition_group, parent_id, q1_charge, q1, ssrcalc, isotope_nr, 0, 0 from %s where q1 between %s and %s #and isotope_nr = 0 """ % (par.peptide_tables[0], self.min_q1 - par.q1_window, self.max_q1 + par.q1_window) cursor.execute(query) self.alltuples = list(cursor.fetchall()) #print "len alltuples", len(self.alltuples) query = """ select modified_sequence, transition_group, parent_id, q1_charge, q1, ssrcalc, isotope_nr, 0, 0 from %s where q1 between %s - %s and %s and isotope_nr = 0 """ % (par.peptide_tables[0], self.min_q1 - par.q1_window, isotope_correction, self.max_q1 + par.q1_window) cursor.execute(query) self.alltuples_isotope_correction = list(cursor.fetchall()) #print "len alltuples zero", len(self.alltuples_isotope_correction) self.myprecursors = Precursors() # myprecursors.getFromDB(par, db.cursor(), self.min_q1 - par.q1_window, self.max_q1 + par.q1_window) ##### LEGACY getFromDB -- have isotope_nr = 0 in there! # Get all precursors from the DB within a window of Q1 lower_q1 = self.min_q1 - par.q1_window upper_q1 = self.max_q1 + par.q1_window self.myprecursors.precursors = [] isotope_correction = par.isotopes_up_to * R.mass_diffC13 / min( par.parent_charges) q = """ select modified_sequence, transition_group, parent_id, q1_charge, q1, ssrcalc, modifications, missed_cleavages, isotopically_modified from %(peptide_table)s where q1 between %(lowq1)s - %(isotope_correction)s and %(highq1)s and isotope_nr = 0 """ % { 'peptide_table': par.peptide_tables[0], 'lowq1': lower_q1, # min_q1 - par.q1_window 'highq1': upper_q1, # max_q1 + par.q1_window, 'isotope_correction': isotope_correction } cursor.execute(q) for res in cursor.fetchall(): p = Precursor() p.initialize(*res) # Only include those precursors that are actually have isotopes in the specified range if (p.included_in_isotopic_range(lower_q1, upper_q1, par)): self.myprecursors.precursors.append(p) ##### END LEGACY getFromDB self.precursors_to_evaluate = self.myprecursors.getPrecursorsToEvaluate( self.min_q1, self.max_q1) except Exception as inst: print "something went wrong" print inst @attr('comparison') def test_integrated_cpp(self): """ Compare the fully integrated vs the mixed C++ rangetree / Python solution. Here we are comparing the fully integrated solution of storing all precursors in a C++ range tree and never passing them to Python vs the solution where we store the precursors in the rangetree, pass them to Python and then evaluate them. """ verbose = True verbose = False print '\n' * 1 print "Comparing fully integrated solution (c_integrated.wrap_all)" par = self.par cursor = self.cursor all_precursors = self.precursors_to_evaluate shuffle(all_precursors) all_precursors = all_precursors[:self.limit_large] self.myprecursors.build_parent_id_lookup() testrange = self.myprecursors.build_rangetree() import c_rangetree r = c_rangetree.ExtendedRangetree_Q1_RT.create() r.new_rangetree() r.create_tree(tuple(self.alltuples_isotope_correction)) #c_integrated.create_tree(tuple(self.alltuples_isotope_correction)) MAX_UIS = 5 newtime = 0 oldtime = 0 ctime = 0 oldsql = 0 newsql = 0 alllocaltime = 0 localprecursor = 0 transitiontime = 0 c_fromprecursortime = 0 prepare = [] self._cursor = False print "Running experiment ", par.get_common_filename() print "calc_trans. = time to calculate the transitions of the precursor" print "old = use rangetree to get precursors, use C++ code to get collperpep" print "new = use rangetree to get precursors, use single C++ code to get collperpep" print "i\tcalc_trans.\tnew\t\told\t\t>>\tspeedup" for kk, precursor in enumerate(all_precursors): ii = kk + 1 q1 = precursor.q1 ssrcalc = precursor.ssrcalc sequence = precursor.modified_sequence peptide_key = precursor.transition_group p_id = precursor.parent_id q3_low, q3_high = par.get_q3range_transitions() #new way to calculate the precursors mystart = time.time() transitions = c_getnonuis.calculate_transitions_ch( ((q1, sequence, p_id), ), [1, 2], q3_low, q3_high) nr_transitions = len(transitions) #fake some srm_id for the transitions transitions = tuple([(t[0], i) for i, t in enumerate(transitions)]) q1_low = q1 - par.q1_window q1_high = q1 + par.q1_window innerstart = time.time() #correct rounding errors, s.t. we get the same results as before! ssrcalc_low = ssrcalc - par.ssrcalc_window + 0.001 ssrcalc_high = ssrcalc + par.ssrcalc_window - 0.001 transitiontime += time.time() - mystart isotope_correction = par.isotopes_up_to * Residues.mass_diffC13 / min( par.parent_charges) ################################### # New way to calculate non_uislist # - start out from transitions, get non_uislist mystart = time.time() newresult = c_integrated.wrap_all_bitwise( transitions, q1_low, ssrcalc_low, q1_high, ssrcalc_high, peptide_key, min(MAX_UIS, nr_transitions), par.q3_window, #q3_low, q3_high, par.ppm, par.isotopes_up_to, isotope_correction, par, r) newtime += time.time() - mystart ################################### # Old way to calculate non_uislist: # - get collisions per peptide # - get non_uislist mystart = time.time() collisions_per_peptide_obj = self.myprecursors.get_collisions_per_peptide_from_rangetree( precursor, precursor.q1 - par.q1_window, precursor.q1 + par.q1_window, transitions, par, r) ## # if False: ## # precursor_ids = tuple(c_rangetree.query_tree( q1_low, ssrcalc_low, ## # q1_high, ssrcalc_high, par.isotopes_up_to, isotope_correction)) ## # precursors = tuple([parentid_lookup[myid[0]] for myid in precursor_ids ## # #dont select myself ## # if parentid_lookup[myid[0]][2] != peptide_key]) ## # collisions_per_peptide = c_getnonuis.calculate_collisions_per_peptide( ## # transitions, precursors, q3_low, q3_high, par.q3_window, par.ppm) non_uis_list = [{} for i in range(MAX_UIS + 1)] for order in range(1, MAX_UIS + 1): non_uis_list[order] = c_getnonuis.get_non_uis( collisions_per_peptide_obj, order) oldtime += time.time() - mystart non_uis_list_old_way = [set(kk.keys()) for kk in non_uis_list] non_uis_list_len = [len(kk) for kk in non_uis_list_old_way[1:]] ################################### # Assert equality, print out result self.assertEqual(newresult, non_uis_list_len) mys = "%s\t%0.4fms\t%0.2fms\t\t%0.2fms\t\t>>\t%0.2f" % \ (ii, transitiontime *1000/ ii, newtime*1000/ii, oldtime*1000/ii, oldtime *1.0 / newtime) #start a new line for each output? #mys += '\t%s\t%s' % ( len(precursors), len(precursor_new) ) if False: mys += '\n' self.ESC = chr(27) sys.stdout.write(self.ESC + '[2K') if self._cursor: sys.stdout.write(self.ESC + '[u') self._cursor = True sys.stdout.write(self.ESC + '[s') sys.stdout.write(mys) sys.stdout.flush() # except Exception as inst: # print "something went wrong" # print inst #@attr('comparison') def test_two_table_mysql(self): """Compare the two table vs the one table MySQL approach Here we are comparing the old (querying the transitions database as well as the precursor database) and the new way (only query the precursor database and calculate the transitions on the fly) way of calculating the collisions. """ print '\n' * 1 print "Comparing one vs two table MySQL solution" par = self.par cursor = self.cursor mycollider = collider.SRMcollider() mypepids = _get_unique_pepids(par, cursor) self.mycollider.pepids = mypepids self.mycollider.calcinner = 0 shuffle(self.mycollider.pepids) self.mycollider.pepids = self.mycollider.pepids[:self.limit] MAX_UIS = 5 c_newuistime = 0 oldtime = 0 c_fromprecursortime = 0 oldsql = 0 newsql = 0 oldcalctime = 0 localsql = 0 self._cursor = False print "oldtime = get UIS from collisions and transitions (getting all collisions from the transitions db)" print "cuis + oldsql = as oldtime but calculate UIS in C++" print "py+newsql = only get the precursors from the db and calculate collisions in Python" print "ctime + newsql = only get the precursors from the db and calculate collisions in C++" print "new = use fast SQL and C++ code" print "old = use slow SQL and Python code" print "i\toldtime\tcuis+oldsql\tpy+newsql\tctime+newsql\t>>>\toldsql\tnewsql\t...\t...\tspeedup" for kk, pep in enumerate(self.mycollider.pepids): ii = kk + 1 p_id = pep['parent_id'] q1 = pep['q1'] q3_low, q3_high = par.get_q3range_transitions() precursor = Precursor(q1=pep['q1'], transition_group=pep['transition_group'], parent_id=pep['parent_id'], modified_sequence=pep['mod_sequence'], ssrcalc=pep['ssrcalc']) transitions = collider.calculate_transitions_ch( ((q1, pep['mod_sequence'], p_id), ), [1], q3_low, q3_high) #fake some srm_id for the transitions transitions = tuple([(t[0], i) for i, t in enumerate(transitions)]) ##### transitions = self.mycollider._get_all_transitions(par, pep, cursor) nr_transitions = len(transitions) if nr_transitions == 0: continue #no transitions in this window # mystart = time.time() collisions = list( self.mycollider._get_all_collisions_calculate_new( par, precursor, cursor)) oldcolllen = len(collisions) oldcalctime += time.time() - mystart # mystart = time.time() collisions = _get_all_collisions(mycollider, par, pep, cursor, transitions=transitions) oldcsqllen = len(collisions) oldsql += time.time() - mystart # par.query2_add = ' and isotope_nr = 0 ' # due to the new handling of isotopes mystart = time.time() self.mycollider.mysqlnewtime = 0 precursors = self.mycollider._get_all_precursors( par, precursor, cursor) newsql += time.time() - mystart # mystart = time.time() #precursors = self.mycollider._get_all_precursors(par, pep, cursor_l) localsql += time.time() - mystart par.query2_add = '' # due to the new handling of isotopes # mystart = time.time() non_uis_list = get_non_UIS_from_transitions( transitions, tuple(collisions), par, MAX_UIS) cnewuis = non_uis_list c_newuistime += time.time() - mystart # mystart = time.time() non_uis_list = get_non_UIS_from_transitions_old( transitions, collisions, par, MAX_UIS) oldnonuislist = non_uis_list oldtime += time.time() - mystart # mystart = time.time() q3_low, q3_high = par.get_q3range_transitions() collisions_per_peptide = c_getnonuis.calculate_collisions_per_peptide_other_ion_series( transitions, precursors, par, q3_low, q3_high, par.q3_window, par.ppm, False) non_uis_list = [{} for i in range(MAX_UIS + 1)] for order in range(1, MAX_UIS + 1): non_uis_list[order] = c_getnonuis.get_non_uis( collisions_per_peptide, order) c_fromprecursortime += time.time() - mystart newl = [len(n) for n in non_uis_list] self.assertEqual(newl, [len(o) for o in cnewuis]) self.assertEqual(newl, [len(o) for o in oldnonuislist]) non_uis_list = [set(k.keys()) for k in non_uis_list] cnewuis = [set(k.keys()) for k in cnewuis] self.assertEqual(non_uis_list, cnewuis) self.assertEqual(non_uis_list, oldnonuislist) mys = "%s\t%0.fms\t%0.fms\t\t%0.fms\t\t%0.2fms\t\t>>>\t%0.fms\t%0.2fms\t...\t...\t%0.2f" % \ (ii, #i (oldtime + oldsql)*1000/ii, #oldtime (c_newuistime+oldsql)*1000/ii, #cuis + oldsql (oldcalctime + newsql + oldtime)*1000/ii, #newsql (c_fromprecursortime + newsql)*1000/ii, #ctime+newsql #(c_fromprecursortime + localsql)*1000/ii, oldsql*1000/ii, #newsql newsql*1000/ii, #oldsql #localsql*1000/ii, #oldtime / c_newuistime (oldtime + oldsql) / (c_fromprecursortime + newsql) ) self.ESC = chr(27) sys.stdout.write(self.ESC + '[2K') if self._cursor: sys.stdout.write(self.ESC + '[u') self._cursor = True sys.stdout.write(self.ESC + '[s') sys.stdout.write(mys) sys.stdout.flush() #@attr('comparison') def test_mysql_vs_integrated(self): """Compare the one table MySQL approach vs the fully integrated Cpp approach Here we are comparing the old (querying the transitions database as well as the precursor database) and the new way (only query the precursor database and calculate the transitions on the fly) way of calculating the collisions. """ print '\n' * 1 print "Comparing one table MySQL solution vs integrated solution" par = self.par cursor = self.cursor mypepids = [ { 'mod_sequence': r[0], 'peptide_key': r[1], 'transition_group': r[1], 'parent_id': r[2], 'q1_charge': r[3], 'q1': r[4], 'ssrcalc': r[5], } for r in self.alltuples if r[3] == 2 #charge is 2 and r[6] == 0 #isotope is 0 and r[4] >= self.min_q1 and r[4] < self.max_q1 ] mycollider = collider.SRMcollider() #mypepids = _get_unique_pepids(par, cursor) self.mycollider.pepids = mypepids self.mycollider.calcinner = 0 shuffle(self.mycollider.pepids) self.mycollider.pepids = self.mycollider.pepids[:self.limit] import c_rangetree r = c_rangetree.ExtendedRangetree_Q1_RT.create() r.new_rangetree() r.create_tree(tuple(self.alltuples_isotope_correction)) #c_integrated.create_tree(tuple(self.alltuples_isotope_correction)) MAX_UIS = 5 c_newuistime = 0 oldtime = 0 c_fromprecursortime = 0 oldsql = 0 newsql = 0 newtime = 0 oldcalctime = 0 localsql = 0 self._cursor = False print "i\toldtime\t\tnewtime\t>>\tspeedup" for kk, pep in enumerate(self.mycollider.pepids): ii = kk + 1 p_id = pep['parent_id'] q1 = pep['q1'] q3_low, q3_high = par.get_q3range_transitions() q1_low = q1 - par.q1_window q1_high = q1 + par.q1_window ssrcalc = pep['ssrcalc'] peptide_key = pep['peptide_key'] #correct rounding errors, s.t. we get the same results as before! ssrcalc_low = ssrcalc - par.ssrcalc_window + 0.001 ssrcalc_high = ssrcalc + par.ssrcalc_window - 0.001 isotope_correction = par.isotopes_up_to * Residues.mass_diffC13 / min( par.parent_charges) precursor = Precursor(q1=pep['q1'], transition_group=pep['transition_group'], parent_id=pep['parent_id'], modified_sequence=pep['mod_sequence'], ssrcalc=pep['ssrcalc']) transitions = collider.calculate_transitions_ch( ((q1, pep['mod_sequence'], p_id), ), [1], q3_low, q3_high) #fake some srm_id for the transitions transitions = tuple([(t[0], i) for i, t in enumerate(transitions)]) ##### transitions = self.mycollider._get_all_transitions(par, pep, cursor) nr_transitions = len(transitions) if nr_transitions == 0: continue #no transitions in this window ################################### # Old way to calculate non_uislist # - get all precursors from the SQL database # - calculate collisions per peptide in C++ par.query2_add = ' and isotope_nr = 0 ' # due to the new handling of isotopes mystart = time.time() self.mycollider.mysqlnewtime = 0 precursors = self.mycollider._get_all_precursors( par, precursor, cursor) newsql += time.time() - mystart mystart = time.time() q3_low, q3_high = par.get_q3range_transitions() collisions_per_peptide = c_getnonuis.calculate_collisions_per_peptide_other_ion_series( transitions, precursors, par, q3_low, q3_high, par.q3_window, par.ppm, False) non_uis_list = [{} for i in range(MAX_UIS + 1)] for order in range(1, MAX_UIS + 1): non_uis_list[order] = c_getnonuis.get_non_uis( collisions_per_peptide, order) c_fromprecursortime += time.time() - mystart newl = [len(n) for n in non_uis_list] non_uis_list_old_way = [set(kk.keys()) for kk in non_uis_list] non_uis_list_len = [len(kk) for kk in non_uis_list_old_way[1:]] ################################### # New way to calculate non_uislist # - start out from transitions, get non_uislist mystart = time.time() newresult = c_integrated.wrap_all_bitwise( transitions, q1_low, ssrcalc_low, q1_high, ssrcalc_high, peptide_key, min(MAX_UIS, nr_transitions), par.q3_window, #q3_low, q3_high, par.ppm, par.isotopes_up_to, isotope_correction, par, r) newtime += time.time() - mystart ################################### # Assert equality, print out result self.assertEqual(newresult, non_uis_list_len) mys = "%s\t%0.1fms\t\t%0.2fms\t>>>\t%0.1f" % \ (ii, #i (c_fromprecursortime + newsql)*1000/ii, # oldtime (newtime)*1000/ii, # newtime (c_fromprecursortime + newsql) / (newtime), # speedup ) self.ESC = chr(27) sys.stdout.write(self.ESC + '[2K') if self._cursor: sys.stdout.write(self.ESC + '[u') self._cursor = True sys.stdout.write(self.ESC + '[s') sys.stdout.write(mys) sys.stdout.flush()
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()
sys.exit() #local arguments exp_key = sys.argv[1] min_q1 = float(sys.argv[2]) max_q1 = float(sys.argv[3]) db = par.get_db() cursor = db.cursor() if par.max_uis ==0: print "Please change --max_uis option, 0 does not make sense here" sys.exit() # Get the 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) isotope_correction = par.calculate_isotope_correction() r_tree = myprecursors.build_extended_rangetree () print "Will evaluate %s precursors" % len(precursors_to_evaluate)