ProteoWizard
SpectrumList_FilterTest.cpp
Go to the documentation of this file.
1 //
2 // $Id: SpectrumList_FilterTest.cpp 4129 2012-11-20 00:05:37Z chambm $
3 //
4 //
5 // Original author: Darren Kessner <darren@proteowizard.org>
6 //
7 // Copyright 2008 Spielberg Family Center for Applied Proteomics
8 // Cedars-Sinai Medical Center, Los Angeles, California 90048
9 //
10 // Licensed under the Apache License, Version 2.0 (the "License");
11 // you may not use this file except in compliance with the License.
12 // You may obtain a copy of the License at
13 //
14 // http://www.apache.org/licenses/LICENSE-2.0
15 //
16 // Unless required by applicable law or agreed to in writing, software
17 // distributed under the License is distributed on an "AS IS" BASIS,
18 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
19 // See the License for the specific language governing permissions and
20 // limitations under the License.
21 //
22 
23 
24 #include "SpectrumList_Filter.hpp"
30 #include <cstring>
31 
32 
33 using namespace pwiz;
34 using namespace pwiz::msdata;
35 using namespace pwiz::analysis;
36 using namespace pwiz::util;
37 using boost::logic::tribool;
38 
39 
40 ostream* os_ = 0;
41 
42 
43 void printSpectrumList(const SpectrumList& sl, ostream& os)
44 {
45  os << "size: " << sl.size() << endl;
46 
47  for (size_t i=0, end=sl.size(); i<end; i++)
48  {
49  SpectrumPtr spectrum = sl.spectrum(i, false);
50  os << spectrum->index << " "
51  << spectrum->id << " "
52  << "ms" << spectrum->cvParam(MS_ms_level).value << " "
53  << "scanEvent:" << spectrum->scanList.scans[0].cvParam(MS_preset_scan_configuration).value << " "
54  << "scanTime:" << spectrum->scanList.scans[0].cvParam(MS_scan_start_time).timeInSeconds() << " "
55  << endl;
56  }
57 }
58 
59 
61 {
63 
64  for (size_t i=0; i<10; ++i)
65  {
66  SpectrumPtr spectrum(new Spectrum);
67  spectrum->index = i;
68  spectrum->id = "scan=" + lexical_cast<string>(100+i);
69  spectrum->setMZIntensityPairs(vector<MZIntensityPair>(i), MS_number_of_counts);
70 
71  bool isMS1 = i%3==0;
72  spectrum->set(MS_ms_level, isMS1 ? 1 : 2);
73  spectrum->set(isMS1 ? MS_MS1_spectrum : MS_MSn_spectrum);
74 
75  // outfit the spectra with mass analyzer definitions to test the massAnalyzer filter
76  spectrum->scanList.scans.push_back(Scan());
77 
78  spectrum->scanList.scans[0].instrumentConfigurationPtr = InstrumentConfigurationPtr(new InstrumentConfiguration());
79  InstrumentConfigurationPtr p = spectrum->scanList.scans[0].instrumentConfigurationPtr;
80  if (i%3 == 0)
81  {
82  p->componentList.push_back(Component(MS_orbitrap, 0/*order*/));
83  }
84  else
85  {
86  if (i%2)
87  p->componentList.push_back(Component(MS_orbitrap, 0/*order*/));
88  else
89  p->componentList.push_back(Component(MS_radial_ejection_linear_ion_trap, 0/*order*/));
90  }
91 
92  if (i%3 != 0)
93  spectrum->precursors.push_back(Precursor(500, 3));
94 
95  // add precursors and activation types to the MS2 spectra
96  if (i==1 || i ==5) // ETD
97  {
98  spectrum->precursors[0].activation.set(MS_electron_transfer_dissociation);
99  }
100  else if (i==2) // CID
101  {
102  spectrum->precursors[0].activation.set(MS_collision_induced_dissociation);
103  }
104  else if (i==4) // HCD
105  {
106  spectrum->precursors[0].activation.set(MS_high_energy_collision_induced_dissociation);
107  }
108  else if (i==8) // IRMPD
109  {
110  spectrum->precursors[0].activation.set(MS_IRMPD);
111  }
112  else if (i==7) // ETD + SA
113  {
114  spectrum->precursors[0].activation.set(MS_electron_transfer_dissociation);
115  spectrum->precursors[0].activation.set(MS_collision_induced_dissociation);
116  }
117 
118  spectrum->scanList.scans.push_back(Scan());
119  spectrum->scanList.scans[0].set(MS_preset_scan_configuration, i%4);
120  spectrum->scanList.scans[0].set(MS_scan_start_time, 420+i, UO_second);
121  sl->spectra.push_back(spectrum);
122  }
123 
124  if (os_)
125  {
126  *os_ << "original spectrum list:\n";
127  printSpectrumList(*sl, *os_);
128  *os_ << endl;
129  }
130 
131  return sl;
132 }
133 
134 
136 {
137  virtual tribool accept(const SpectrumIdentity& spectrumIdentity) const
138  {
139  return spectrumIdentity.index%2 == 0;
140  }
141 };
142 
143 
145 {
146  if (os_) *os_ << "testEven:\n";
147 
148  SpectrumList_Filter filter(sl, EvenPredicate());
149 
150  if (os_)
151  {
152  printSpectrumList(filter, *os_);
153  *os_ << endl;
154  }
155 
156  unit_assert(filter.size() == 5);
157 
158  for (size_t i=0, end=filter.size(); i<end; i++)
159  {
160  const SpectrumIdentity& id = filter.spectrumIdentity(i);
161  unit_assert(id.index == i);
162  unit_assert(id.id == "scan=" + lexical_cast<string>(100+i*2));
163 
164  SpectrumPtr spectrum = filter.spectrum(i);
165  unit_assert(spectrum->index == i);
166  unit_assert(spectrum->id == "scan=" + lexical_cast<string>(100+i*2));
167  }
168 }
169 
170 
172 {
173  virtual tribool accept(const SpectrumIdentity& spectrumIdentity) const
174  {
175  if (spectrumIdentity.index%2 != 0) return false;
176  return boost::logic::indeterminate;
177  }
178 
179  virtual tribool accept(const Spectrum& spectrum) const
180  {
181  CVParam param = spectrum.cvParamChild(MS_spectrum_type);
182  if (param.cvid == CVID_Unknown) return boost::logic::indeterminate;
183  if (!cvIsA(param.cvid, MS_mass_spectrum))
184  return true; // MS level filter doesn't affect non-MS spectra
185 
186  param = spectrum.cvParam(MS_ms_level);
187  if (param.cvid == CVID_Unknown) return boost::logic::indeterminate;
188 
189  return (param.valueAs<int>() == 2);
190  }
191 };
192 
193 
195 {
196  if (os_) *os_ << "testEvenMS2:\n";
197 
199 
200  if (os_)
201  {
202  printSpectrumList(filter, *os_);
203  *os_ << endl;
204  }
205 
206  unit_assert(filter.size() == 3);
207  unit_assert(filter.spectrumIdentity(0).id == "scan=102");
208  unit_assert(filter.spectrumIdentity(1).id == "scan=104");
209  unit_assert(filter.spectrumIdentity(2).id == "scan=108");
210 }
211 
212 
214 {
215  mutable bool pastMaxIndex;
216 
217  SelectedIndexPredicate() : pastMaxIndex(false) {}
218 
219  virtual tribool accept(const SpectrumIdentity& spectrumIdentity) const
220  {
221  if (spectrumIdentity.index>5) pastMaxIndex = true;
222 
223  return (spectrumIdentity.index==1 ||
224  spectrumIdentity.index==3 ||
225  spectrumIdentity.index==5);
226  }
227 
228  virtual bool done() const
229  {
230  return pastMaxIndex;
231  }
232 };
233 
234 
236 {
237  if (os_) *os_ << "testSelectedIndices:\n";
238 
240 
241  if (os_)
242  {
243  printSpectrumList(filter, *os_);
244  *os_ << endl;
245  }
246 
247  unit_assert(filter.size() == 3);
248  unit_assert(filter.spectrumIdentity(0).id == "scan=101");
249  unit_assert(filter.spectrumIdentity(1).id == "scan=103");
250  unit_assert(filter.spectrumIdentity(2).id == "scan=105");
251 }
252 
253 
255 {
256  HasBinaryDataPredicate(DetailLevel suggestedDetailLevel) : detailLevel_(suggestedDetailLevel) {}
257 
259  virtual DetailLevel suggestedDetailLevel() const {return detailLevel_;}
260 
261  virtual tribool accept(const msdata::SpectrumIdentity& spectrumIdentity) const
262  {
263  return boost::logic::indeterminate;
264  }
265 
266  virtual tribool accept(const Spectrum& spectrum) const
267  {
268  if (spectrum.binaryDataArrayPtrs.empty())
269  return boost::logic::indeterminate;
270  return !spectrum.binaryDataArrayPtrs[0]->data.empty();
271  }
272 };
273 
274 
276 {
277  if (os_) *os_ << "testHasBinaryData:\n";
278 
279  MSData msd;
281 
282  shared_ptr<stringstream> ss(new stringstream);
283  Serializer_mzML serializer;
284  serializer.write(*ss, msd);
285 
286  MSData msd2;
287  serializer.read(ss, msd2);
288 
289  sl = msd2.run.spectrumListPtr;
290 
291  {
293  unit_assert(filter.empty());
294  }
295 
296  {
298 
299  if (os_)
300  {
301  printSpectrumList(filter, *os_);
302  *os_ << endl;
303  }
304 
305  unit_assert_operator_equal(4, filter.size());
306  }
307 }
308 
309 
311 {
312  if (os_) *os_ << "testIndexSet:\n";
313 
314  IntegerSet indexSet;
315  indexSet.insert(3,5);
316  indexSet.insert(7);
317  indexSet.insert(9);
318 
320 
321  if (os_)
322  {
323  printSpectrumList(filter, *os_);
324  *os_ << endl;
325  }
326 
327  unit_assert(filter.size() == 5);
328  unit_assert(filter.spectrumIdentity(0).id == "scan=103");
329  unit_assert(filter.spectrumIdentity(1).id == "scan=104");
330  unit_assert(filter.spectrumIdentity(2).id == "scan=105");
331  unit_assert(filter.spectrumIdentity(3).id == "scan=107");
332  unit_assert(filter.spectrumIdentity(4).id == "scan=109");
333 }
334 
335 
337 {
338  if (os_) *os_ << "testScanNumberSet:\n";
339 
340  IntegerSet scanNumberSet;
341  scanNumberSet.insert(102,104);
342  scanNumberSet.insert(107);
343 
345 
346  if (os_)
347  {
348  printSpectrumList(filter, *os_);
349  *os_ << endl;
350  }
351 
352  unit_assert(filter.size() == 4);
353  unit_assert(filter.spectrumIdentity(0).id == "scan=102");
354  unit_assert(filter.spectrumIdentity(1).id == "scan=103");
355  unit_assert(filter.spectrumIdentity(2).id == "scan=104");
356  unit_assert(filter.spectrumIdentity(3).id == "scan=107");
357 }
358 
359 
361 {
362  if (os_) *os_ << "testScanEventSet:\n";
363 
364  IntegerSet scanEventSet;
365  scanEventSet.insert(0,0);
366  scanEventSet.insert(2,3);
367 
369 
370  if (os_)
371  {
372  printSpectrumList(filter, *os_);
373  *os_ << endl;
374  }
375 
376  unit_assert(filter.size() == 7);
377  unit_assert(filter.spectrumIdentity(0).id == "scan=100");
378  unit_assert(filter.spectrumIdentity(1).id == "scan=102");
379  unit_assert(filter.spectrumIdentity(2).id == "scan=103");
380  unit_assert(filter.spectrumIdentity(3).id == "scan=104");
381  unit_assert(filter.spectrumIdentity(4).id == "scan=106");
382  unit_assert(filter.spectrumIdentity(5).id == "scan=107");
383  unit_assert(filter.spectrumIdentity(6).id == "scan=108");
384 }
385 
386 
388 {
389  if (os_) *os_ << "testScanTimeRange:\n";
390 
391  const double low = 422.5;
392  const double high = 427.5;
393 
395 
396  if (os_)
397  {
398  printSpectrumList(filter, *os_);
399  *os_ << endl;
400  }
401 
402  unit_assert(filter.size() == 5);
403  unit_assert(filter.spectrumIdentity(0).id == "scan=103");
404  unit_assert(filter.spectrumIdentity(1).id == "scan=104");
405  unit_assert(filter.spectrumIdentity(2).id == "scan=105");
406  unit_assert(filter.spectrumIdentity(3).id == "scan=106");
407  unit_assert(filter.spectrumIdentity(4).id == "scan=107");
408 }
409 
410 
412 {
413  if (os_) *os_ << "testMSLevelSet:\n";
414 
415  IntegerSet msLevelSet;
416  msLevelSet.insert(1);
417 
419 
420  if (os_)
421  {
422  printSpectrumList(filter, *os_);
423  *os_ << endl;
424  }
425 
426  unit_assert(filter.size() == 4);
427  unit_assert(filter.spectrumIdentity(0).id == "scan=100");
428  unit_assert(filter.spectrumIdentity(1).id == "scan=103");
429  unit_assert(filter.spectrumIdentity(2).id == "scan=106");
430  unit_assert(filter.spectrumIdentity(3).id == "scan=109");
431 
432  IntegerSet msLevelSet2;
433  msLevelSet2.insert(2);
434 
436 
437  if (os_)
438  {
439  printSpectrumList(filter2, *os_);
440  *os_ << endl;
441  }
442 
443  unit_assert(filter2.size() == 6);
444  unit_assert(filter2.spectrumIdentity(0).id == "scan=101");
445  unit_assert(filter2.spectrumIdentity(1).id == "scan=102");
446  unit_assert(filter2.spectrumIdentity(2).id == "scan=104");
447  unit_assert(filter2.spectrumIdentity(3).id == "scan=105");
448  unit_assert(filter2.spectrumIdentity(4).id == "scan=107");
449  unit_assert(filter2.spectrumIdentity(5).id == "scan=108");
450 }
451 
453 {
454  if (os_) *os_ << "testMS2Activation:\n";
455 
457 
458  set<CVID> cvIDs;
459  // CID
460  cvIDs.insert(MS_electron_transfer_dissociation);
462  cvIDs.insert(MS_IRMPD);
463  SpectrumList_Filter filter(ms2filter,
465 
466  if (os_)
467  {
468  printSpectrumList(filter, *os_);
469  *os_ << endl;
470  }
471 
472  unit_assert(filter.size() == 1);
473  unit_assert(filter.spectrumIdentity(0).id == "scan=102");
474 
475  // ETD + SA
476  cvIDs.clear();
477  cvIDs.insert(MS_electron_transfer_dissociation);
478  cvIDs.insert(MS_collision_induced_dissociation);
479  SpectrumList_Filter filter1(ms2filter,
481  if (os_)
482  {
483  printSpectrumList(filter1, *os_);
484  *os_ << endl;
485  }
486 
487  unit_assert(filter1.size() == 1);
488  unit_assert(filter1.spectrumIdentity(0).id == "scan=107");
489 
490  // ETD
491  cvIDs.clear();
492  cvIDs.insert(MS_electron_transfer_dissociation);
493  SpectrumList_Filter filter2(ms2filter,
495  if (os_)
496  {
497  printSpectrumList(filter2, *os_);
498  *os_ << endl;
499  }
500 
501  unit_assert(filter2.size() == 3);
502  unit_assert(filter2.spectrumIdentity(0).id == "scan=101");
503  unit_assert(filter2.spectrumIdentity(1).id == "scan=105");
504  unit_assert(filter2.spectrumIdentity(2).id == "scan=107");
505 
506  // HCD
507  cvIDs.clear();
509  SpectrumList_Filter filter3(ms2filter,
511  if (os_)
512  {
513  printSpectrumList(filter3, *os_);
514  *os_ << endl;
515  }
516 
517  unit_assert(filter3.size() == 1);
518  unit_assert(filter3.spectrumIdentity(0).id == "scan=104");
519 
520  // IRMPD
521  cvIDs.clear();
522  cvIDs.insert(MS_IRMPD);
523  SpectrumList_Filter filter4(ms2filter,
525  if (os_)
526  {
527  printSpectrumList(filter4, *os_);
528  *os_ << endl;
529  }
530 
531  unit_assert(filter4.size() == 1);
532  unit_assert(filter4.spectrumIdentity(0).id == "scan=108");
533 
534 }
535 
537 {
538  if (os_) *os_ << "testMassAnalyzerFilter:\n";
539 
540  set<CVID> cvIDs;
541  // msconvert mass analyzer filter FTMS option
542  cvIDs.insert(MS_orbitrap);
544  SpectrumList_Filter filter(sl,
546 
547  if (os_)
548  {
549  printSpectrumList(filter, *os_);
550  *os_ << endl;
551  }
552 
553  unit_assert(filter.size() == 7);
554  unit_assert(filter.spectrumIdentity(0).id == "scan=100");
555 
556  cvIDs.clear();
557  // msconvert mass analyzer filter ITMS option
558  cvIDs.insert(MS_ion_trap);
559 
560  SpectrumList_Filter filter1(sl,
562 
563  if (os_)
564  {
565  printSpectrumList(filter1, *os_);
566  *os_ << endl;
567  }
568 
569  unit_assert(filter1.size() == 3);
570  unit_assert(filter1.spectrumIdentity(0).id == "scan=102");
571 }
572 
573 void test()
574 {
576  testEven(sl);
577  testEvenMS2(sl);
579  testHasBinaryData(sl);
580  testIndexSet(sl);
581  testScanNumberSet(sl);
582  testScanEventSet(sl);
583  testScanTimeRange(sl);
584  testMSLevelSet(sl);
585  testMS2Activation(sl);
587 }
588 
589 
590 int main(int argc, char* argv[])
591 {
592  TEST_PROLOG(argc, argv)
593 
594  try
595  {
596  if (argc>1 && !strcmp(argv[1],"-v")) os_ = &cout;
597  test();
598  }
599  catch (exception& e)
600  {
601  TEST_FAILED(e.what())
602  }
603  catch (...)
604  {
605  TEST_FAILED("Caught unknown exception.")
606  }
607 
609 }
610 
611