def test_find_clashes_forall_other_series_by(self):
""" Test how to calculate the transitions of the target
nonunique = c_getnonuis._find_clashes_forall_other_series(
tuple(transitions), tuple(precursors), q3_low, q3_high,
par.q3_window, par.ppm, par, q1 - par.q1_window)
"""
par = self.real_parameters
q3_low, q3_high = self.real_parameters.get_q3range_transitions()
precursor = self.precursor
transitions = precursor.calculate_transitions(q3_low, q3_high)
nonunique = c_getnonuis._find_clashes_forall_other_series(
tuple(transitions),
self.interfering_precursors,
par,
q3_low,
q3_high,
par.q3_window,
par.ppm,
precursor.q1 - par.q1_window,
False,
)
self.assertEqual(len(nonunique), 3)
self.assertEqual(nonunique.keys(), [0, 2, 4])
self.assertTrue(abs(nonunique[0][0][0] - 842.4008) < self.EPSILON)
self.assertTrue(abs(nonunique[0][0][1] - 506.584613) < self.EPSILON)
self.assertEqual(nonunique[0][0][2], 0) # empty
self.assertEqual(nonunique[0][0][3], 618) # peptide key
self.assertEqual(nonunique[0][0][4], "b")
self.assertEqual(nonunique[0][0][5], 9)
self.assertEqual(nonunique[0][0][6], "NGTDGGLQVAIDAMR") # sequence
self.assertEqual(nonunique[0][0][-1], 1) # charge
self.assertTrue(abs(nonunique[2][0][0] - 565.8035) < self.EPSILON)
self.assertEqual(nonunique[2][0][4], "y")
self.assertEqual(nonunique[2][0][5], 11)
self.assertEqual(nonunique[2][0][6], "NGTDGGLQVAIDAMR") # sequence
self.assertEqual(nonunique[2][0][-1], 2) # charge
self.assertTrue(abs(nonunique[4][0][0] - 440.287275) < self.EPSILON)
self.assertTrue(abs(nonunique[4][0][1] - 500.787837374) < self.EPSILON)
self.assertEqual(nonunique[4][0][2], 0) # empty
self.assertEqual(nonunique[4][0][3], 665) # peptide key
self.assertEqual(nonunique[4][0][4], "b")
self.assertEqual(nonunique[4][0][5], 5)
self.assertEqual(nonunique[4][0][6], "GGLIVELGDK") # sequence
self.assertEqual(nonunique[4][0][-1], 1) # charge
def do_analysis(input_sequences, seqs, par, wuis, local_cursor, controller):
"""
###########################################################################
# Do analysis
# 1. Find SSRCalc values for all peptides
# 2. Iterate through all sequences and calculate the b / y series
# 3. Find all (potentially) interfering precursors
# 4. For each precursors, find the list of transitions that interfers
# 5. For each transition, find the precursors that interfere
# 6. Print information
###########################################################################
"""
q3_low, q3_high = par.q3_range
uis = par.uis
pepmap = get_ssrcalc_values(seqs, input_sequences, default_ssrcalc, local_cursor, ssrcalc_path)
toggle_all_str = '<script language="javascript"> function toggleAll(){ '
mycollider = collider.SRMcollider()
for seq_id, peptide in enumerate(controller.peptides):
#
# Step 2 : find the SSRCalc values for this sequence
#
try: ssrcalc = pepmap[filter(str.isalpha, peptide.sequence)]
except KeyError: ssrcalc = 25
transitions = [ (f.q3, f.fragment_count) for f in peptide.fragments]
if len( transitions ) == 0: continue # no transitions in this window
#
# Step 3 : find all potentially interfering precursors
# Create precursor and use db to find all interfering precursors
#
precursor = Precursor(modified_sequence = peptide.get_modified_sequence(), parent_id = -1,
q1 = peptide.charged_mass, q1_charge = 2, ssrcalc = ssrcalc, transition_group = -1)
precursor.seq_id = seq_id
precursors_obj = mycollider._get_all_precursors(par, precursor, local_cursor)
#
# Step 4 and 5: Find interferences per precursor, then find
# interferences per transition (see the two readouts in the html)
#
collisions_per_peptide = \
c_getnonuis.calculate_collisions_per_peptide_other_ion_series(
tuple(transitions), precursors_obj, par, q3_low, q3_high,
par.q3_window, par.ppm, par.chargeCheck)
nonunique = c_getnonuis._find_clashes_forall_other_series(
tuple(transitions), precursors_obj, par, q3_low, q3_high,
par.q3_window, par.ppm, peptide.charged_mass - par.q1_window, par.chargeCheck)
# also add those that have no interference
for fragment in peptide.fragments:
if not fragment.fragment_count in nonunique:
nonunique[fragment.fragment_count] = []
nonunique_obj = controller.getNonuniqueObjects(nonunique)
#
# Step 6: printing
#
do_all_print(peptide, collisions_per_peptide,
wuis, precursor, par, precursors_obj, nonunique_obj)
toggle_all_str += "toggleDisplay('col_peptides_%s'); toggleDisplay('col_transitions_%s');\n" % (seq_id,seq_id)
toggle_all_str += "};</script>"
print toggle_all_str
print """
def test_find_clashes_forall_other_series(self):
""" Test how to calculate the transitions of the target
nonunique = c_getnonuis._find_clashes_forall_other_series(
tuple(transitions), tuple(precursors), q3_low, q3_high,
par.q3_window, par.ppm, par, q1 - par.q1_window)
"""
par = self.real_parameters
par.aions = True
par.xions = True
par.zions = True
par.bions = False
par.yions = False
# par.bMinusNH3 = True
# par.bMinusH2O = True
# par.bPlusH2O = True
par.q3_window = 4.5
q3_low, q3_high = self.real_parameters.get_q3range_transitions()
precursor = self.precursor
transitions = precursor.calculate_transitions(q3_low, q3_high)
nonunique = c_getnonuis._find_clashes_forall_other_series(
tuple(transitions),
self.interfering_precursors,
par,
q3_low,
q3_high,
par.q3_window,
par.ppm,
precursor.q1 - par.q1_window,
False,
)
self.assertEqual(len(nonunique), 4)
self.assertEqual(nonunique.keys(), [3, 4, 5, 6])
self.assertEqual(len(nonunique[3]), 1)
self.assertEqual(len(nonunique[4]), 2)
self.assertEqual(len(nonunique[5]), 3)
self.assertEqual(len(nonunique[6]), 1)
# we have one interference with 3
self.assertTrue(abs(nonunique[3][0][0] - 456.756009652) < self.EPSILON)
self.assertTrue(abs(nonunique[3][0][1] - 500.787837374) < self.EPSILON)
self.assertEqual(nonunique[3][0][2], 0) # empty
self.assertEqual(nonunique[3][0][3], 665) # peptide key
self.assertEqual(nonunique[3][0][4], "x")
self.assertEqual(nonunique[3][0][5], 8)
self.assertEqual(nonunique[3][0][6], "GGLIVELGDK") # sequence
self.assertEqual(nonunique[3][0][-1], 2) # charge
# we have two interferences with 4
self.assertTrue(abs(nonunique[4][0][0] - 443.22541272) < self.EPSILON)
self.assertTrue(abs(nonunique[4][0][1] - 506.58461326) < self.EPSILON)
self.assertEqual(nonunique[4][0][2], 0) # empty
self.assertEqual(nonunique[4][0][3], 618) # peptide key
self.assertEqual(nonunique[4][0][4], "a")
self.assertEqual(nonunique[4][0][5], 10)
self.assertEqual(nonunique[4][0][6], "NGTDGGLQVAIDAMR") # sequence
self.assertEqual(nonunique[4][0][-1], 2) # charge
self.assertTrue(abs(nonunique[4][1][0] - 443.7267378235) < self.EPSILON)
self.assertTrue(abs(nonunique[4][1][1] - 506.58461326) < self.EPSILON)
self.assertEqual(nonunique[4][1][2], 0) # empty
self.assertEqual(nonunique[4][1][3], 618) # peptide key
self.assertEqual(nonunique[4][1][4], "z")
self.assertEqual(nonunique[4][1][5], 8)
self.assertEqual(nonunique[4][1][6], "NGTDGGLQVAIDAMR") # sequence
self.assertEqual(nonunique[4][1][-1], 2) # charge
# we have three interferences with 5
self.assertTrue(abs(nonunique[5][0][0] - 557.280912722) < self.EPSILON)
self.assertEqual(nonunique[5][0][4], "a")
self.assertEqual(nonunique[5][0][5], 12)
self.assertEqual(nonunique[5][0][6], "NGTDGGLQVAIDAMR") # sequence
self.assertEqual(nonunique[5][0][-1], 2) # charge
self.assertTrue(abs(nonunique[5][1][0] - 550.28240465) < self.EPSILON)
self.assertEqual(nonunique[5][1][4], "x")
self.assertEqual(nonunique[5][1][5], 10)
self.assertEqual(nonunique[5][1][6], "NGTDGGLQVAIDAMR") # sequence
self.assertEqual(nonunique[5][1][-1], 2) # charge
self.assertTrue(abs(nonunique[5][2][0] - 557.2902278235) < self.EPSILON)
self.assertEqual(nonunique[5][2][4], "z")
self.assertEqual(nonunique[5][2][5], 11)
self.assertEqual(nonunique[5][2][6], "NGTDGGLQVAIDAMR") # sequence
self.assertEqual(nonunique[5][2][-1], 2) # charge
# we have one interference with 6
self.assertTrue(abs(nonunique[6][0][0] - 665.327537823) < self.EPSILON)
self.assertEqual(nonunique[6][0][2], 0) # empty
self.assertEqual(nonunique[6][0][3], 618) # peptide key
self.assertEqual(nonunique[6][0][4], "z")
self.assertEqual(nonunique[6][0][5], 13)
self.assertEqual(nonunique[6][0][6], "NGTDGGLQVAIDAMR") # sequence
self.assertEqual(nonunique[6][0][-1], 2) # charge
