ProteoWizard
SpectrumListFactoryTest.cpp
Go to the documentation of this file.
1//
2// $Id$
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
27#include <cstring>
28
29
30using namespace pwiz::analysis;
31using namespace pwiz::util;
32using namespace pwiz::cv;
33using namespace pwiz::msdata;
34
35
36ostream* os_ = 0;
37
38
40{
41 if (os_) *os_ << "SpectrumListFactory::usage():\n" << SpectrumListFactory::usage() << endl;
42}
43
44
46{
47 MSData msd;
49
51
52 unit_assert(sl.get());
53 unit_assert(sl->size() > 2);
54
55 // CompassXtract and pwiz data processing
57 unit_assert_operator_equal(1, msd.allDataProcessingPtrs()[1]->processingMethods.size());
58
59 SpectrumListFactory::wrap(msd, "scanNumber [19,20]");
60 unit_assert(sl->size() == 2);
61
62 // make sure we can handle config file lines copied from commandline
63 // with quotes intact
64 SpectrumListFactory::wrap(msd, "'index [1,1]'");
65 unit_assert(sl->size() == 1);
66 unit_assert(sl->spectrumIdentity(0).id == "scan=20");
67
68 vector<double> profileData(sl->spectrum(0)->getMZArray()->data);
69 unit_assert(profileData.size() == 10);
70 unit_assert(profileData[0] == 0);
71 unit_assert(profileData[9] == 18);
72
74 unit_assert_operator_equal(1, msd.allDataProcessingPtrs()[1]->processingMethods.size());
75
76 SpectrumListFactory::wrap(msd, "peakPicking true [1,6]"); // backwards compatible syntax
77 SpectrumListFactory::wrap(msd, "peakPicking false"); // backwards compatible syntax
78 SpectrumListFactory::wrap(msd, "peakPicking cwt msLevel=[1,6]");
79 SpectrumListFactory::wrap(msd, "peakPicking cwt snr=1.2 msLevel=2-");
80 SpectrumListFactory::wrap(msd, "peakPicking cwt peakSpace=0.05");
81
82 vector<double> peakData(sl->spectrum(0)->getMZArray()->data);
83 unit_assert(peakData.size() == 1);
84 unit_assert(peakData[0] == 0);
85
87 unit_assert_operator_equal(6, msd.allDataProcessingPtrs()[1]->processingMethods.size());
88}
89
90
92{
93 MSData msd;
95
97 unit_assert(sl.get());
98 unit_assert(sl->size() > 2);
99
100 double timeHighInSeconds = 5.9 * 60; // between first and second scan
101 ostringstream oss;
102 oss << "scanTime [0," << timeHighInSeconds << "]";
103 SpectrumListFactory::wrap(msd, oss.str());
104 unit_assert(sl->size() == 2);
105 unit_assert(sl->spectrumIdentity(0).id == "scan=19");
106 unit_assert(sl->spectrumIdentity(1).id == "sample=1 period=1 cycle=23 experiment=1"); // not in scan time order (42 seconds)
107}
108
109
111{
112 MSData msd;
114
116 unit_assert(sl.get());
117 unit_assert(sl->size() == 5);
118
119 sl->spectrum(0)->scanList.scans[0].set(MS_scan_start_time, 35, UO_second);
120 sl->spectrum(2)->scanList.scans[0].set(MS_scan_start_time, 0.5, UO_minute);
121
122 SpectrumListFactory::wrap(msd, "sortByScanTime");
123 unit_assert(sl->size() == 5);
124 unit_assert(sl->spectrumIdentity(0).id == "scan=21");
125 unit_assert(sl->spectrumIdentity(1).id == "scan=19");
126 unit_assert(sl->spectrumIdentity(2).id == "sample=1 period=1 cycle=23 experiment=1");
127}
128
129
131{
132 MSData msd;
134
136 unit_assert(sl.get() && sl->size()>2);
137 SpectrumPtr spectrum = sl->spectrum(0, true);
138 vector<MZIntensityPair> data;
139 spectrum->getMZIntensityPairs(data);
140 unit_assert(data.size() == 15);
141
142 SpectrumListFactory::wrap(msd, "mzWindow [9.5,15]");
143
144 spectrum = sl->spectrum(0, true);
145 spectrum->getMZIntensityPairs(data);
146 unit_assert(data.size() == 5);
147
148 spectrum = sl->spectrum(1, true);
149 spectrum->getMZIntensityPairs(data);
150 unit_assert(data.size() == 3);
151}
152
153
155{
156 MSData msd;
158
160 unit_assert(sl.get());
161 unit_assert_operator_equal(5, sl->size());
162
163 SpectrumListFactory::wrap(msd, "msLevel 2");
164 unit_assert_operator_equal(2, sl->size());
165 unit_assert_operator_equal("scan=20", sl->spectrumIdentity(0).id);
166}
167
168
170{
171 {
172 MSData msd;
175
176 SpectrumListFactory::wrap(msd, "chargeState 2");
177 unit_assert_operator_equal(2, sl->size());
178 unit_assert_operator_equal("scan=20", sl->spectrumIdentity(0).id);
179
180 SpectrumListFactory::wrap(msd, "chargeState 1");
181 unit_assert_operator_equal(0, sl->size());
182 }
183
184 {
185 MSData msd;
188
189 SpectrumListFactory::wrap(msd, "chargeState 0-2");
190 unit_assert_operator_equal(2, sl->size());
191 unit_assert_operator_equal("scan=20", sl->spectrumIdentity(0).id);
192 }
193}
194
195
197{
198 {
199 MSData msd;
202
203 SpectrumListFactory::wrap(msd, "chargeStatePredictor overrideExistingCharge=false maxMultipleCharge=3 minMultipleCharge=2 singleChargeFractionTIC=0.9 maxKnownCharge=4 makeMS2=true");
204 unit_assert_operator_equal(5, sl->size());
205 }
206}
207
208
210{
211 // test that the minimum length is 1 (due to 0 being the "unset" value)
212 {
213 MSData msd;
215
217 unit_assert(sl.get());
218 unit_assert(sl->size() == 5);
219
220 SpectrumListFactory::wrap(msd, "defaultArrayLength 0-");
221 unit_assert(sl->size() == 4);
222 unit_assert(sl->find("scan=21") == sl->size());
223 }
224
225 // test filtering out all spectra
226 {
227 MSData msd;
230
231 SpectrumListFactory::wrap(msd, "defaultArrayLength 100-");
232 unit_assert(sl->size() == 0);
233 }
234
235 // test filtering out empty spectra
236 {
237 MSData msd;
240
241 SpectrumListFactory::wrap(msd, "defaultArrayLength 1-");
242 unit_assert(sl->size() == 4);
243 unit_assert(sl->find("scan=21") == sl->size());
244 }
245
246 // test filtering out spectra with defaultArrayLength > 14
247 {
248 MSData msd;
251
252 SpectrumListFactory::wrap(msd, "defaultArrayLength 15-");
253 unit_assert(sl->size() == 2);
254 unit_assert(sl->find("scan=20") == sl->size());
255 unit_assert(sl->find("scan=21") == sl->size());
256 }
257
258 // test filtering out spectra with 0 < defaultArrayLength < 15
259 {
260 MSData msd;
263
264 SpectrumListFactory::wrap(msd, "defaultArrayLength 1-14");
265 unit_assert(sl->size() == 2);
266 unit_assert(sl->find("scan=20") == 0);
267 }
268}
269
271{
272 // test filter by CID activation
273 {
274 MSData msd;
276 SpectrumListFactory::wrap(msd, "msLevel 2-");
277 SpectrumListFactory::wrap(msd, "activation CID");
278 unit_assert(msd.run.spectrumListPtr->size() == 1);
279 }
280 // test filter by ETD activation
281 {
282 MSData msd;
284 SpectrumListFactory::wrap(msd, "msLevel 2-");
285 SpectrumListFactory::wrap(msd, "activation ETD");
286 unit_assert(msd.run.spectrumListPtr->size() == 1);
287 }
288 // test filter by HCD activation
289 {
290 MSData msd;
292 SpectrumListFactory::wrap(msd, "msLevel 2-");
293 SpectrumListFactory::wrap(msd, "activation HCD");
294 unit_assert(msd.run.spectrumListPtr->size() == 0);
295 }
296 // test filter by IRMPD activation
297 {
298 MSData msd;
300 SpectrumListFactory::wrap(msd, "msLevel 2-");
301 SpectrumListFactory::wrap(msd, "activation IRMPD");
302 unit_assert(msd.run.spectrumListPtr->size() == 0);
303 }
304 // test invalid argument
305 {
306 MSData msd;
308
309 unit_assert_throws(SpectrumListFactory::wrap(msd, "activation UNEXPECTED_INPUT"), runtime_error);
310 }
311}
312
314{
315 // test filter by ITMS analyzer type
316 {
317 MSData msd;
319
320 SpectrumListFactory::wrap(msd, "analyzerType ITMS");
321 unit_assert(msd.run.spectrumListPtr->size() == 5);
322 }
323 // test filter by ITMS analyzer type (new syntax)
324 {
325 MSData msd;
327
328 SpectrumListFactory::wrap(msd, "analyzerType it");
329 unit_assert(msd.run.spectrumListPtr->size() == 5);
330 }
331 // test filter by FTMS analyzer type
332 {
333 MSData msd;
335
336 SpectrumListFactory::wrap(msd, "analyzer FTMS");
337 unit_assert(msd.run.spectrumListPtr->size() == 0);
338 }
339 // test filter by Orbi analyzer type
340 {
341 MSData msd;
343
344 SpectrumListFactory::wrap(msd, "analyzer Orbi");
345 unit_assert(msd.run.spectrumListPtr->size() == 0);
346 }
347 // test filter by TOF analyzer type
348 {
349 MSData msd;
351
352 SpectrumListFactory::wrap(msd, "analyzer TOF");
353 unit_assert(msd.run.spectrumListPtr->size() == 0);
354 }
355 // test invalid argument
356 {
357 MSData msd;
359
360 unit_assert_throws(SpectrumListFactory::wrap(msd, "analyzer UNEXPECTED_INPUT"), runtime_error)
361 }
362}
363
365{
366 // test filter by positive polarity
367 {
368 MSData msd;
370
372 unit_assert(sl.get());
373 unit_assert(sl->size() == 5);
374
375 SpectrumListFactory::wrap(msd, "polarity positive");
376 unit_assert(sl->size() == 3);
377 }
378 // test filter by + polarity
379 {
380 MSData msd;
382
384 unit_assert(sl.get());
385 unit_assert(sl->size() == 5);
386
387 SpectrumListFactory::wrap(msd, "polarity +");
388 unit_assert(sl->size() == 3);
389 }
390 // test filter by negative polarity
391 {
392 MSData msd;
394
396 unit_assert(sl.get());
397 unit_assert(sl->size() == 5);
398
399 SpectrumListFactory::wrap(msd, "polarity -");
400 unit_assert(sl->size() == 2);
401 }
402 // test invalid argument
403 {
404 MSData msd;
406
408 unit_assert(sl.get());
409 unit_assert(sl->size() == 5);
410 unit_assert_throws(SpectrumListFactory::wrap(msd, "polarity UNEXPECTED_INPUT"), runtime_error)
411 }
412}
413
415{
416 MSData msd;
418
419 {
420 SpectrumListFactory::wrap(msd, "titleMaker <Id>");
422 unit_assert_operator_equal("scan=19", sl->spectrum(0)->cvParam(MS_spectrum_title).value);
423 unit_assert_operator_equal("scan=20", sl->spectrum(1)->cvParam(MS_spectrum_title).value);
424 unit_assert_operator_equal("scan=21", sl->spectrum(2)->cvParam(MS_spectrum_title).value);
425 unit_assert_operator_equal("scan=22", sl->spectrum(3)->cvParam(MS_spectrum_title).value);
426 unit_assert_operator_equal("sample=1 period=1 cycle=23 experiment=1", sl->spectrum(4)->cvParam(MS_spectrum_title).value);
427 }
428
429 {
430 // the outer titleMaker overrides the inner one
431 SpectrumListFactory::wrap(msd, "titleMaker <Index>; <SpectrumType>, <MsLevel>");
433 unit_assert_operator_equal("0; MS1 spectrum, 1", sl->spectrum(0)->cvParam(MS_spectrum_title).value);
434 unit_assert_operator_equal("1; MSn spectrum, 2", sl->spectrum(1)->cvParam(MS_spectrum_title).value);
435 unit_assert_operator_equal("2; MS1 spectrum, 1", sl->spectrum(2)->cvParam(MS_spectrum_title).value);
436 unit_assert_operator_equal("3; MSn spectrum, 2", sl->spectrum(3)->cvParam(MS_spectrum_title).value);
437 unit_assert_operator_equal("4; MS1 spectrum, 1", sl->spectrum(4)->cvParam(MS_spectrum_title).value);
438 }
439
440 {
441 SpectrumListFactory::wrap(msd, "titleMaker <ScanNumber> <MsLevel> <ActivationType> <ChargeState> <PrecursorSpectrumId>");
443 unit_assert_operator_equal("19 1 ", sl->spectrum(0)->cvParam(MS_spectrum_title).value);
444 unit_assert_operator_equal("20 2 CID 2 scan=19", sl->spectrum(1)->cvParam(MS_spectrum_title).value);
445 unit_assert_operator_equal("21 1 ", sl->spectrum(2)->cvParam(MS_spectrum_title).value);
446 unit_assert_operator_equal("22 2 ETD/CID 2 scan=19", sl->spectrum(3)->cvParam(MS_spectrum_title).value);
447 unit_assert_operator_equal("5 1 ", sl->spectrum(4)->cvParam(MS_spectrum_title).value);
448 }
449}
450
452{
454 // add some filter data on top of the tiny scan example.
456 for (size_t i=0; i<5; ++i)
457 {
458 SpectrumPtr spectrum = sl->spectrum(i);
459 ostringstream filterLine;
460
461 if (i == 0) // scan=19
462 filterLine << "FTMS + p NSI SIM ms [595.0000-655.0000]";
463 else if (i == 1) // scan=20
464 filterLine << "FTMS + c NSI Full ms2 " << (i + 4) * 100 << ".0000@etd30.00 [100.0000-2000.0000]";
465 else if (i == 2) // scan=21
466 filterLine << "ITMS + c NSI Full ms2 " << (i + 4) * 100 << ".0000@cid30.00 [100.0000-2000.0000]";
467 else if (i == 3) // scan=22
468 filterLine << "FTMS + p NSI SIM ms [395.0000-1005.0000]";
469 else if (i == 4) // sample=1 period=1 cycle=23 experiment=1
470 filterLine << "ITMS + c NSI Full ms2 " << (i + 4) * 100 << ".0000@hcd30.00 [100.0000-2000.0000]";
471 spectrum->scanList.scans[0].set(MS_filter_string, filterLine.str());
472 }
473}
474
476{
477 MSData msd;
479 auto originalSL = msd.run.spectrumListPtr;
480
481 {
482 SpectrumListFactory::wrap(msd, "thermoScanFilter contains include 395.0000-1005.0000");
484 unit_assert(sl->size() == 1);
485 unit_assert(sl->spectrumIdentity(0).id == "scan=22");
486 }
487
488 {
489 msd.run.spectrumListPtr = originalSL;
490 SpectrumListFactory::wrap(msd, "thermoScanFilter contains exclude 395.0000-1005.0000");
492 cout << sl->size()<<endl;
493 unit_assert(sl->size() == 4);
494 unit_assert(sl->spectrumIdentity(0).id == "scan=19");
495 unit_assert(sl->spectrumIdentity(1).id == "scan=20");
496 unit_assert(sl->spectrumIdentity(2).id == "scan=21");
497 unit_assert(sl->spectrumIdentity(3).id == "sample=1 period=1 cycle=23 experiment=1");
498 }
499
500 {
501 msd.run.spectrumListPtr = originalSL;
502 SpectrumListFactory::wrap(msd, "thermoScanFilter exact include FTMS + p NSI SIM ms [395.0000-1005.0000]");
504 unit_assert(sl->size() == 1);
505 unit_assert(sl->spectrumIdentity(0).id == "scan=22");
506 }
507
508 {
509 msd.run.spectrumListPtr = originalSL;
510 SpectrumListFactory::wrap(msd, "thermoScanFilter exact exclude TMS + p NSI SIM ms [395.0000-1005.0000]");
511 // should not exclude anything
513 unit_assert(sl->size() == 5);
514 unit_assert(sl->spectrumIdentity(0).id == "scan=19");
515 unit_assert(sl->spectrumIdentity(1).id == "scan=20");
516 unit_assert(sl->spectrumIdentity(2).id == "scan=21");
517 unit_assert(sl->spectrumIdentity(3).id == "scan=22");
518 unit_assert(sl->spectrumIdentity(4).id == "sample=1 period=1 cycle=23 experiment=1");
519 }
520}
521
523{
524 MSData msd;
526 auto originalSL = msd.run.spectrumListPtr;
527
528 {
529 SpectrumListFactory::wrap(msd, "mzPrecursors [445]"); // default tolerance does not match to 445.34
531 unit_assert_operator_equal(0, sl->size());
532 }
533
534 {
535 msd.run.spectrumListPtr = originalSL;
536 SpectrumListFactory::wrap(msd, "mzPrecursors [445] mzTol=1mz");
538 unit_assert_operator_equal(1, sl->size());
539 unit_assert_operator_equal("scan=20", sl->spectrumIdentity(0).id);
540 }
541
542 {
543 msd.run.spectrumListPtr = originalSL;
544 SpectrumListFactory::wrap(msd, "mzPrecursors [445] mzTol=1.0 mz"); // mzTol should still parse correctly with a space
546 unit_assert_operator_equal(1, sl->size());
547 unit_assert_operator_equal("scan=20", sl->spectrumIdentity(0).id);
548 }
549
550 {
551 msd.run.spectrumListPtr = originalSL;
552 SpectrumListFactory::wrap(msd, "mzPrecursors [445.34] mode=exclude"); // only 1 MS2 left, but MS1s aren't excluded now
554 unit_assert_operator_equal(4, sl->size());
555 unit_assert_operator_equal("scan=19", sl->spectrumIdentity(0).id);
556 unit_assert_operator_equal("scan=21", sl->spectrumIdentity(1).id);
557 unit_assert_operator_equal("scan=22", sl->spectrumIdentity(2).id);
558 unit_assert_operator_equal("sample=1 period=1 cycle=23 experiment=1", sl->spectrumIdentity(3).id);
559 }
560
561 {
562 msd.run.spectrumListPtr = originalSL;
563 SpectrumListFactory::wrap(msd, "mzPrecursors [0,445.34]"); // bring back the MS1s explicitly
565 unit_assert_operator_equal(4, sl->size());
566 unit_assert_operator_equal("scan=19", sl->spectrumIdentity(0).id);
567 unit_assert_operator_equal("scan=20", sl->spectrumIdentity(1).id);
568 unit_assert_operator_equal("scan=21", sl->spectrumIdentity(2).id);
569 unit_assert_operator_equal("sample=1 period=1 cycle=23 experiment=1", sl->spectrumIdentity(3).id);
570 }
571
572 {
573 msd.run.spectrumListPtr = originalSL;
574 SpectrumListFactory::wrap(msd, "mzPrecursors [0,445.34] target=selected");
576 unit_assert_operator_equal(4, sl->size());
577 unit_assert_operator_equal("scan=19", sl->spectrumIdentity(0).id);
578 unit_assert_operator_equal("scan=20", sl->spectrumIdentity(1).id);
579 unit_assert_operator_equal("scan=21", sl->spectrumIdentity(2).id);
580 unit_assert_operator_equal("sample=1 period=1 cycle=23 experiment=1", sl->spectrumIdentity(3).id);
581 }
582
583 {
584 msd.run.spectrumListPtr = originalSL;
585 SpectrumListFactory::wrap(msd, "mzPrecursors [445.3] target=isolated");
587 unit_assert_operator_equal(1, sl->size());
588 unit_assert_operator_equal("scan=20", sl->spectrumIdentity(0).id);
589 }
590
591 {
592 msd.run.spectrumListPtr = originalSL;
593 SpectrumListFactory::wrap(msd, "mzPrecursors [445.34] target=isolated"); // tolerance too tight to match to 445.3
595 unit_assert_operator_equal(0, sl->size());
596 }
597
598 msd.run.spectrumListPtr = originalSL;
599 unit_assert_throws_what(SpectrumListFactory::wrap(msd, "mzPrecursors mode=include"), user_error, "[SpectrumListFactory::filterCreator_mzPrecursors()] expected a list of m/z values formatted like \"[123.4,567.8,789.0]\"");
600
601 msd.run.spectrumListPtr = originalSL;
602 unit_assert_throws_what(SpectrumListFactory::wrap(msd, "mzPrecursors [0,445.34] target=42"), user_error, "[SpectrumListFactory::filterCreator_mzPrecursors()] invalid value for 'target' parameter: 42");
603}
604
606{
607 MSData msd;
609 auto originalSL = msd.run.spectrumListPtr;
610
611 // tiny spectra have simple m/z lists:
612 // s19: 0,1,2,...,15 15,14,13,...,0
613 // s20: 0,2,4,6,...,20 20,18,16,...,0
614 // s21: no data points
615 // s22: 0,2,4,6,...,20 20,18,16,...,0
616 // s23: 0,1,2,...,15 15,14,13,...,0
617
618 {
619 SpectrumListFactory::wrap(msd, "mzPresent [1.6] type=count threshold=100 orientation=most-intense");
621 unit_assert_operator_equal(4, sl->size());
622 unit_assert_operator_equal("scan=19", sl->spectrumIdentity(0).id);
623 unit_assert_operator_equal("scan=20", sl->spectrumIdentity(1).id);;
624 unit_assert_operator_equal("scan=22", sl->spectrumIdentity(2).id);
625 unit_assert_operator_equal("sample=1 period=1 cycle=23 experiment=1", sl->spectrumIdentity(3).id);
626 }
627
628 {
629 msd.run.spectrumListPtr = originalSL;
630 SpectrumListFactory::wrap(msd, "mzPresent [1.6] mzTol=1 ppm"); // mzTol should still parse correctly with a space; with this tight tolereance no spectra will match
632 unit_assert_operator_equal(0, sl->size());
633 }
634
635 {
636 msd.run.spectrumListPtr = originalSL;
637 SpectrumListFactory::wrap(msd, "mzPresent [0]");
639 unit_assert_operator_equal(4, sl->size());
640 }
641
642 {
643 msd.run.spectrumListPtr = originalSL;
644 SpectrumListFactory::wrap(msd, "mzPresent [0] type=absolute threshold=17 orientation=most-intense mode=include");
646 unit_assert_operator_equal(2, sl->size());
647 unit_assert_operator_equal("scan=20", sl->spectrumIdentity(0).id);
648 unit_assert_operator_equal("scan=22", sl->spectrumIdentity(1).id);
649 }
650
651 {
652 msd.run.spectrumListPtr = originalSL;
653 SpectrumListFactory::wrap(msd, "mzPresent [0] type=absolute threshold=17 orientation=most-intense mode=exclude");
655 unit_assert_operator_equal(3, sl->size());
656 unit_assert_operator_equal("scan=19", sl->spectrumIdentity(0).id);
657 unit_assert_operator_equal("scan=21", sl->spectrumIdentity(1).id);
658 unit_assert_operator_equal("sample=1 period=1 cycle=23 experiment=1", sl->spectrumIdentity(2).id);
659 }
660}
661
662
682
683
684int main(int argc, char* argv[])
685{
686 TEST_PROLOG(argc, argv)
687
688 try
689 {
690 if (argc>1 && !strcmp(argv[1],"-v")) os_ = &cout;
691 test();
692 }
693 catch (exception& e)
694 {
695 TEST_FAILED(e.what())
696 }
697 catch (...)
698 {
699 TEST_FAILED("Caught unknown exception.")
700 }
701
703}
704
int main(int argc, char *argv[])
void testWrapThermoScanFilter()
void testWrapScanTimeRange()
void testWrapMZWindow()
void testWrapMassAnalyzer()
void testWrapDefaultArrayLength()
void testWrapPrecursorMzSet()
void testWrapMZPresent()
void testWrapChargeState()
void intializeTinyWithThermoFilter(MSData &msd)
void testWrapTitleMaker()
void testWrap()
void testWrapMSLevel()
ostream * os_
void testWrapSortScanTime()
void testWrapChargeStatePredictor()
void testWrapActivation()
void testWrapPolarity()
void testUsage()
static void wrap(msdata::MSData &msd, const std::string &wrapper, pwiz::util::IterationListenerRegistry *ilr=NULL)
instantiate the SpectrumListWrapper indicated by wrapper
static std::string usage(bool detailedHelp=true, const char *morehelp_prompt=NULL, int maxLineLength=80)
user-friendly documentation, with option of less or more detail
UO_minute
minute: A time unit which is equal to 60 seconds.
Definition cv.hpp:13896
MS_filter_string
filter string: A string unique to Thermo instrument describing instrument settings for the scan.
Definition cv.hpp:2142
MS_spectrum_title
spectrum title: A free-form text title describing a spectrum.
Definition cv.hpp:3075
MS_scan_start_time
scan start time: The time that an analyzer started a scan, relative to the start of the MS run.
Definition cv.hpp:309
UO_second
second: A time unit which is equal to the duration of 9 192 631 770 periods of the radiation correspo...
Definition cv.hpp:13833
PWIZ_API_DECL void initializeTiny(MSData &msd)
boost::shared_ptr< SpectrumList > SpectrumListPtr
Definition MSData.hpp:711
boost::shared_ptr< Spectrum > SpectrumPtr
Definition MSData.hpp:573
This is the root element of ProteoWizard; it represents the mzML element, defined as: intended to cap...
Definition MSData.hpp:850
Run run
a run in mzML should correspond to a single, consecutive and coherent set of scans on an instrument.
Definition MSData.hpp:886
std::vector< DataProcessingPtr > allDataProcessingPtrs() const
return dataProcessingPtrs augmented by the dataProcessingPtr() set in SpectrumList and/or Chromatogra...
SpectrumListPtr spectrumListPtr
all mass spectra and the acquisitions underlying them are described and attached here....
Definition MSData.hpp:827
#define unit_assert(x)
Definition unit.hpp:85
#define unit_assert_throws(x, exception)
Definition unit.hpp:106
#define TEST_EPILOG
Definition unit.hpp:183
#define TEST_FAILED(x)
Definition unit.hpp:177
#define unit_assert_operator_equal(expected, actual)
Definition unit.hpp:92
#define unit_assert_throws_what(x, exception, whatStr)
Definition unit.hpp:119
#define TEST_PROLOG(argc, argv)
Definition unit.hpp:175