ProteoWizard
Classes | Functions | Variables
SpectrumList_FilterTest.cpp File Reference
#include "SpectrumList_Filter.hpp"
#include "pwiz/utility/misc/unit.hpp"
#include "pwiz/utility/misc/IntegerSet.hpp"
#include "pwiz/utility/misc/Std.hpp"
#include "pwiz/data/msdata/examples.hpp"
#include "pwiz/data/msdata/Serializer_mzML.hpp"
#include <cstring>

Go to the source code of this file.

Classes

struct  EvenPredicate
 
struct  EvenMS2Predicate
 
struct  SelectedIndexPredicate
 
struct  HasBinaryDataPredicate
 

Functions

void printSpectrumList (const SpectrumList &sl, ostream &os)
 
SpectrumListPtr createSpectrumList ()
 
void testEven (SpectrumListPtr sl)
 
void testEvenMS2 (SpectrumListPtr sl)
 
void testSelectedIndices (SpectrumListPtr sl)
 
void testHasBinaryData (SpectrumListPtr sl)
 
void testIndexSet (SpectrumListPtr sl)
 
void testScanNumberSet (SpectrumListPtr sl)
 
void testScanEventSet (SpectrumListPtr sl)
 
void testScanTimeRange (SpectrumListPtr sl)
 
void testMSLevelSet (SpectrumListPtr sl)
 
void testMS2Activation (SpectrumListPtr sl)
 
void testMassAnalyzerFilter (SpectrumListPtr sl)
 
void testMZPresentFilter (SpectrumListPtr sl)
 
void testThermoFilterFilter (SpectrumListPtr sl)
 
void test ()
 
int main (int argc, char *argv[])
 

Variables

ostream * os_ = 0
 

Function Documentation

◆ printSpectrumList()

void printSpectrumList ( const SpectrumList sl,
ostream &  os 
)

Definition at line 43 of file SpectrumList_FilterTest.cpp.

References MS_filter_string, MS_ms_level, MS_preset_scan_configuration, MS_scan_start_time, pwiz::msdata::SpectrumList::size(), and pwiz::msdata::SpectrumList::spectrum().

Referenced by createSpectrumList(), testEven(), testEvenMS2(), testHasBinaryData(), testIndexSet(), testMassAnalyzerFilter(), testMS2Activation(), testMSLevelSet(), testMZPresentFilter(), testScanEventSet(), testScanNumberSet(), testScanTimeRange(), testSelectedIndices(), and testThermoFilterFilter().

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  << "scanFilter:" << spectrum->scanList.scans[0].cvParam(MS_filter_string).value << " "
56  << endl;
57  }
58 }
boost::shared_ptr< Spectrum > SpectrumPtr
Definition: MSData.hpp:569
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:148
virtual SpectrumPtr spectrum(size_t index, bool getBinaryData=false) const =0
retrieve a spectrum by index
virtual size_t size() const =0
returns the number of spectra
MS_ms_level
ms level: Stages of ms achieved in a multi stage mass spectrometry experiment.
Definition: cv.hpp:1987
MS_filter_string
filter string: A string unique to Thermo instrument describing instrument settings for the scan...
Definition: cv.hpp:1990
MS_preset_scan_configuration
preset scan configuration: A user-defined scan configuration that specifies the instrumental settings...
Definition: cv.hpp:2359

◆ createSpectrumList()

SpectrumListPtr createSpectrumList ( )

Definition at line 61 of file SpectrumList_FilterTest.cpp.

References boost::lexical_cast(), MS_collision_induced_dissociation, MS_electron_transfer_dissociation, MS_filter_string, MS_HCD, MS_IRMPD, MS_MS1_spectrum, MS_ms_level, MS_MSn_spectrum, MS_number_of_detector_counts, MS_orbitrap, MS_preset_scan_configuration, MS_radial_ejection_linear_ion_trap, MS_scan_start_time, os_, printSpectrumList(), and UO_second.

Referenced by test().

62 {
64 
65  for (size_t i=0; i<10; ++i)
66  {
67  SpectrumPtr spectrum(new Spectrum);
68  spectrum->index = i;
69  spectrum->id = "scan=" + lexical_cast<string>(100+i);
70  spectrum->setMZIntensityPairs(vector<MZIntensityPair>(i), MS_number_of_detector_counts);
71 
72  // add mz/intensity to the spectra for mzPresent filter
73  vector<MZIntensityPair> mzint(i*2);
74  for (size_t j=1.0; j<i*2; ++j)
75  {
76  mzint.insert(mzint.end(), MZIntensityPair(j*100, j*j));
77  }
78  spectrum->setMZIntensityPairs(mzint, MS_number_of_detector_counts);
79 
80  bool isMS1 = i%3==0;
81  spectrum->set(MS_ms_level, isMS1 ? 1 : 2);
82  spectrum->set(isMS1 ? MS_MS1_spectrum : MS_MSn_spectrum);
83 
84  // outfit the spectra with mass analyzer definitions to test the massAnalyzer filter
85  spectrum->scanList.scans.push_back(Scan());
86 
87  spectrum->scanList.scans[0].instrumentConfigurationPtr = InstrumentConfigurationPtr(new InstrumentConfiguration());
88  InstrumentConfigurationPtr p = spectrum->scanList.scans[0].instrumentConfigurationPtr;
89  if (i%3 == 0)
90  {
91  p->componentList.push_back(Component(MS_orbitrap, 0/*order*/));
92  }
93  else
94  {
95  if (i%2)
96  p->componentList.push_back(Component(MS_orbitrap, 0/*order*/));
97  else
98  p->componentList.push_back(Component(MS_radial_ejection_linear_ion_trap, 0/*order*/));
99  }
100 
101  // add thermo scan filter lines to the MS1 spectra
102  // MS1
103  if (i == 0 || i == 6) // narrow window MS1
104  {
105  spectrum->scanList.scans[0].set(MS_filter_string, "FTMS + p NSI SIM ms [595.0000-655.0000]");
106  }
107  else if (i == 3 || i == 9) // wide window MS1
108  {
109  spectrum->scanList.scans[0].set(MS_filter_string, "FTMS + p NSI SIM ms [395.0000-1005.0000]");
110  }
111 
112  if (i%3 != 0)
113  spectrum->precursors.push_back(Precursor((i+4)*100, 3));
114 
115  // add precursors, activation types, and thermo scan filter lines to the MS2 spectra
116  ostringstream filterLine;
117  if (i==1 || i ==5) // ETD
118  {
119  spectrum->precursors[0].activation.set(MS_electron_transfer_dissociation);
120  filterLine << "FTMS + c NSI Full ms2 " << (i + 4) * 100 << ".0000@etd30.00 [100.0000-2000.0000]";
121  }
122  else if (i==2) // CID
123  {
124  spectrum->precursors[0].activation.set(MS_collision_induced_dissociation);
125  filterLine << "ITMS + c NSI Full ms2 " << (i + 4) * 100 << ".0000@cid30.00 [100.0000-2000.0000]";
126  }
127  else if (i==4) // HCD
128  {
129  spectrum->precursors[0].activation.set(MS_HCD);
130  filterLine << "ITMS + c NSI Full ms2 " << (i + 4) * 100 << ".0000@hcd30.00 [100.0000-2000.0000]";
131  }
132  else if (i==8) // IRMPD
133  {
134  spectrum->precursors[0].activation.set(MS_IRMPD);
135  filterLine << "ITMS + c NSI Full ms2 " << (i + 4) * 100 << ".0000@irmpd30.00 [100.0000-2000.0000]";
136  }
137  else if (i==7) // ETD + SA
138  {
139  spectrum->precursors[0].activation.set(MS_electron_transfer_dissociation);
140  spectrum->precursors[0].activation.set(MS_collision_induced_dissociation);
141  filterLine << "FTMS + c NSI Full ms2 " << (i + 4) * 100 << ".0000@irmpd30.00 [100.0000-2000.0000]";
142  }
143 
144  spectrum->scanList.scans.push_back(Scan());
145  spectrum->scanList.scans[0].set(MS_preset_scan_configuration, i%4);
146  spectrum->scanList.scans[0].set(MS_scan_start_time, 420+i, UO_second);
147  if (i % 3 != 0)
148  spectrum->scanList.scans[0].set(MS_filter_string, filterLine.str());
149  sl->spectra.push_back(spectrum);
150  }
151 
152  if (os_)
153  {
154  *os_ << "original spectrum list:\n";
155  printSpectrumList(*sl, *os_);
156  *os_ << endl;
157  }
158 
159  return sl;
160 }
MS_MSn_spectrum
MSn spectrum: MSn refers to multi-stage MS2 experiments designed to record product ion spectra where ...
Definition: cv.hpp:2212
The method of precursor ion selection and activation.
Definition: MSData.hpp:310
A component of an instrument corresponding to a source (i.e. ion source), an analyzer (i...
Definition: MSData.hpp:130
boost::shared_ptr< Spectrum > SpectrumPtr
Definition: MSData.hpp:569
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:148
ostream * os_
MS_collision_induced_dissociation
collision-induced dissociation: The dissociation of an ion after collisional excitation. The term collisional-activated dissociation is not recommended.
Definition: cv.hpp:586
MS_ms_level
ms level: Stages of ms achieved in a multi stage mass spectrometry experiment.
Definition: cv.hpp:1987
float lexical_cast(const std::string &str)
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:12526
MS_filter_string
filter string: A string unique to Thermo instrument describing instrument settings for the scan...
Definition: cv.hpp:1990
MS_electron_transfer_dissociation
electron transfer dissociation: A process to fragment ions in a mass spectrometer by inducing fragmen...
Definition: cv.hpp:2296
MS_radial_ejection_linear_ion_trap
radial ejection linear ion trap: A linear ion trap mass spectrometer where ions are ejected along the...
Definition: cv.hpp:397
MS_IRMPD
IRMPD (infrared multiphoton dissociation): Multiphoton ionization where the reactant ion dissociates ...
Definition: cv.hpp:1117
The data point type of a mass spectrum.
Definition: MSData.hpp:421
MS_MS1_spectrum
MS1 spectrum: Mass spectrum created by a single-stage MS experiment or the first stage of a multi-sta...
Definition: cv.hpp:2197
MS_preset_scan_configuration
preset scan configuration: A user-defined scan configuration that specifies the instrumental settings...
Definition: cv.hpp:2359
Description of a particular hardware configuration of a mass spectrometer. Each configuration MUST ha...
Definition: MSData.hpp:228
boost::shared_ptr< InstrumentConfiguration > InstrumentConfigurationPtr
Definition: MSData.hpp:249
void printSpectrumList(const SpectrumList &sl, ostream &os)
MS_number_of_detector_counts
number of detector counts: The number of counted events observed in one or a group of elements of a d...
Definition: cv.hpp:580
boost::shared_ptr< SpectrumListSimple > SpectrumListSimplePtr
Definition: MSData.hpp:727
The structure that captures the generation of a peak list (including the underlying acquisitions) ...
Definition: MSData.hpp:504
Simple writeable in-memory implementation of SpectrumList.
Definition: MSData.hpp:712
MS_orbitrap
orbitrap: An ion trapping device that consists of an outer barrel-like electrode and a coaxial inner ...
Definition: cv.hpp:1900
MS_HCD
HCD (beam-type collision-induced dissociation): A collision-induced dissociation process that occurs ...
Definition: cv.hpp:1690

◆ testEven()

void testEven ( SpectrumListPtr  sl)

Definition at line 172 of file SpectrumList_FilterTest.cpp.

References ralab::base::filter::filter(), os_, printSpectrumList(), pwiz::analysis::SpectrumList_Filter::size(), pwiz::analysis::SpectrumList_Filter::spectrum(), pwiz::analysis::SpectrumList_Filter::spectrumIdentity(), and unit_assert.

Referenced by test().

173 {
174  if (os_) *os_ << "testEven:\n";
175 
177 
178  if (os_)
179  {
181  *os_ << endl;
182  }
183 
184  unit_assert(filter.size() == 5);
185 
186  for (size_t i=0, end=filter.size(); i<end; i++)
187  {
188  const SpectrumIdentity& id = filter.spectrumIdentity(i);
189  unit_assert(id.index == i);
190  unit_assert(id.id == "scan=" + lexical_cast<string>(100+i*2));
191 
192  SpectrumPtr spectrum = filter.spectrum(i);
193  unit_assert(spectrum->index == i);
194  unit_assert(spectrum->id == "scan=" + lexical_cast<string>(100+i*2));
195  }
196 }
boost::shared_ptr< Spectrum > SpectrumPtr
Definition: MSData.hpp:569
ostream * os_
Identifying information for a spectrum.
Definition: MSData.hpp:469
void printSpectrumList(const SpectrumList &sl, ostream &os)
SpectrumList filter, for creating Spectrum sub-lists.
#define unit_assert(x)
Definition: unit.hpp:85
void filter(const TContainer &data, const TContainer &filter, TContainer &result, bool circular=false, uint32_t sides=2)
Applies linear convolution (filtering) to a univariate time series.
Definition: filter.hpp:112

◆ testEvenMS2()

void testEvenMS2 ( SpectrumListPtr  sl)

Definition at line 222 of file SpectrumList_FilterTest.cpp.

References ralab::base::filter::filter(), pwiz::msdata::SpectrumIdentity::id, os_, printSpectrumList(), pwiz::analysis::SpectrumList_Filter::size(), pwiz::analysis::SpectrumList_Filter::spectrumIdentity(), and unit_assert.

Referenced by test().

223 {
224  if (os_) *os_ << "testEvenMS2:\n";
225 
227 
228  if (os_)
229  {
231  *os_ << endl;
232  }
233 
234  unit_assert(filter.size() == 3);
235  unit_assert(filter.spectrumIdentity(0).id == "scan=102");
236  unit_assert(filter.spectrumIdentity(1).id == "scan=104");
237  unit_assert(filter.spectrumIdentity(2).id == "scan=108");
238 }
ostream * os_
void printSpectrumList(const SpectrumList &sl, ostream &os)
SpectrumList filter, for creating Spectrum sub-lists.
#define unit_assert(x)
Definition: unit.hpp:85
void filter(const TContainer &data, const TContainer &filter, TContainer &result, bool circular=false, uint32_t sides=2)
Applies linear convolution (filtering) to a univariate time series.
Definition: filter.hpp:112

◆ testSelectedIndices()

void testSelectedIndices ( SpectrumListPtr  sl)

Definition at line 263 of file SpectrumList_FilterTest.cpp.

References ralab::base::filter::filter(), pwiz::msdata::SpectrumIdentity::id, os_, printSpectrumList(), pwiz::analysis::SpectrumList_Filter::size(), pwiz::analysis::SpectrumList_Filter::spectrumIdentity(), and unit_assert.

Referenced by test().

264 {
265  if (os_) *os_ << "testSelectedIndices:\n";
266 
268 
269  if (os_)
270  {
272  *os_ << endl;
273  }
274 
275  unit_assert(filter.size() == 3);
276  unit_assert(filter.spectrumIdentity(0).id == "scan=101");
277  unit_assert(filter.spectrumIdentity(1).id == "scan=103");
278  unit_assert(filter.spectrumIdentity(2).id == "scan=105");
279 }
ostream * os_
void printSpectrumList(const SpectrumList &sl, ostream &os)
SpectrumList filter, for creating Spectrum sub-lists.
#define unit_assert(x)
Definition: unit.hpp:85
void filter(const TContainer &data, const TContainer &filter, TContainer &result, bool circular=false, uint32_t sides=2)
Applies linear convolution (filtering) to a univariate time series.
Definition: filter.hpp:112

◆ testHasBinaryData()

void testHasBinaryData ( SpectrumListPtr  sl)

Definition at line 303 of file SpectrumList_FilterTest.cpp.

References pwiz::msdata::DetailLevel_FullData, pwiz::msdata::DetailLevel_FullMetadata, pwiz::msdata::SpectrumListWrapper::empty(), ralab::base::filter::filter(), pwiz::msdata::examples::initializeTiny(), os_, printSpectrumList(), pwiz::msdata::Serializer_mzML::read(), pwiz::msdata::MSData::run, pwiz::analysis::SpectrumList_Filter::size(), pwiz::msdata::Run::spectrumListPtr, unit_assert, unit_assert_operator_equal, and pwiz::msdata::Serializer_mzML::write().

Referenced by test().

304 {
305  if (os_) *os_ << "testHasBinaryData:\n";
306 
307  MSData msd;
309 
310  shared_ptr<stringstream> ss(new stringstream);
311  Serializer_mzML serializer;
312  serializer.write(*ss, msd);
313 
314  MSData msd2;
315  serializer.read(ss, msd2);
316 
317  sl = msd2.run.spectrumListPtr;
318 
319  {
321  unit_assert(filter.empty());
322  }
323 
324  {
326 
327  if (os_)
328  {
330  *os_ << endl;
331  }
332 
334  }
335 }
MSData <-> mzML stream serialization.
void read(boost::shared_ptr< std::istream > is, MSData &msd) const
read in MSData object from an mzML istream note: istream may be managed by MSData&#39;s SpectrumList...
void write(std::ostream &os, const MSData &msd, const pwiz::util::IterationListenerRegistry *iterationListenerRegistry=0) const
write MSData object to ostream as mzML; iterationListenerRegistry may be used to receive progress upd...
ostream * os_
#define unit_assert_operator_equal(expected, actual)
Definition: unit.hpp:92
Run run
a run in mzML should correspond to a single, consecutive and coherent set of scans on an instrument...
Definition: MSData.hpp:882
SpectrumListPtr spectrumListPtr
all mass spectra and the acquisitions underlying them are described and attached here. Subsidiary data arrays are also both described and attached here.
Definition: MSData.hpp:823
void printSpectrumList(const SpectrumList &sl, ostream &os)
PWIZ_API_DECL void initializeTiny(IdentData &mzid)
SpectrumList filter, for creating Spectrum sub-lists.
This is the root element of ProteoWizard; it represents the mzML element, defined as: intended to cap...
Definition: MSData.hpp:845
#define unit_assert(x)
Definition: unit.hpp:85
void filter(const TContainer &data, const TContainer &filter, TContainer &result, bool circular=false, uint32_t sides=2)
Applies linear convolution (filtering) to a univariate time series.
Definition: filter.hpp:112

◆ testIndexSet()

void testIndexSet ( SpectrumListPtr  sl)

Definition at line 338 of file SpectrumList_FilterTest.cpp.

References ralab::base::filter::filter(), pwiz::msdata::SpectrumIdentity::id, pwiz::util::IntegerSet::insert(), os_, printSpectrumList(), pwiz::analysis::SpectrumList_Filter::size(), pwiz::analysis::SpectrumList_Filter::spectrumIdentity(), and unit_assert.

Referenced by test().

339 {
340  if (os_) *os_ << "testIndexSet:\n";
341 
342  IntegerSet indexSet;
343  indexSet.insert(3,5);
344  indexSet.insert(7);
345  indexSet.insert(9);
346 
348 
349  if (os_)
350  {
352  *os_ << endl;
353  }
354 
355  unit_assert(filter.size() == 5);
356  unit_assert(filter.spectrumIdentity(0).id == "scan=103");
357  unit_assert(filter.spectrumIdentity(1).id == "scan=104");
358  unit_assert(filter.spectrumIdentity(2).id == "scan=105");
359  unit_assert(filter.spectrumIdentity(3).id == "scan=107");
360  unit_assert(filter.spectrumIdentity(4).id == "scan=109");
361 }
a virtual container of integers, accessible via an iterator interface, stored as union of intervals ...
Definition: IntegerSet.hpp:37
ostream * os_
void printSpectrumList(const SpectrumList &sl, ostream &os)
SpectrumList filter, for creating Spectrum sub-lists.
void insert(Interval interval)
insert an interval of integers into the virtual container
#define unit_assert(x)
Definition: unit.hpp:85
void filter(const TContainer &data, const TContainer &filter, TContainer &result, bool circular=false, uint32_t sides=2)
Applies linear convolution (filtering) to a univariate time series.
Definition: filter.hpp:112

◆ testScanNumberSet()

void testScanNumberSet ( SpectrumListPtr  sl)

Definition at line 364 of file SpectrumList_FilterTest.cpp.

References ralab::base::filter::filter(), pwiz::msdata::SpectrumIdentity::id, pwiz::util::IntegerSet::insert(), os_, printSpectrumList(), pwiz::analysis::SpectrumList_Filter::size(), pwiz::analysis::SpectrumList_Filter::spectrumIdentity(), and unit_assert.

Referenced by test().

365 {
366  if (os_) *os_ << "testScanNumberSet:\n";
367 
368  IntegerSet scanNumberSet;
369  scanNumberSet.insert(102,104);
370  scanNumberSet.insert(107);
371 
373 
374  if (os_)
375  {
377  *os_ << endl;
378  }
379 
380  unit_assert(filter.size() == 4);
381  unit_assert(filter.spectrumIdentity(0).id == "scan=102");
382  unit_assert(filter.spectrumIdentity(1).id == "scan=103");
383  unit_assert(filter.spectrumIdentity(2).id == "scan=104");
384  unit_assert(filter.spectrumIdentity(3).id == "scan=107");
385 }
a virtual container of integers, accessible via an iterator interface, stored as union of intervals ...
Definition: IntegerSet.hpp:37
ostream * os_
void printSpectrumList(const SpectrumList &sl, ostream &os)
SpectrumList filter, for creating Spectrum sub-lists.
void insert(Interval interval)
insert an interval of integers into the virtual container
#define unit_assert(x)
Definition: unit.hpp:85
void filter(const TContainer &data, const TContainer &filter, TContainer &result, bool circular=false, uint32_t sides=2)
Applies linear convolution (filtering) to a univariate time series.
Definition: filter.hpp:112

◆ testScanEventSet()

void testScanEventSet ( SpectrumListPtr  sl)

Definition at line 388 of file SpectrumList_FilterTest.cpp.

References ralab::base::filter::filter(), pwiz::msdata::SpectrumIdentity::id, pwiz::util::IntegerSet::insert(), os_, printSpectrumList(), pwiz::analysis::SpectrumList_Filter::size(), pwiz::analysis::SpectrumList_Filter::spectrumIdentity(), and unit_assert.

Referenced by test().

389 {
390  if (os_) *os_ << "testScanEventSet:\n";
391 
392  IntegerSet scanEventSet;
393  scanEventSet.insert(0,0);
394  scanEventSet.insert(2,3);
395 
397 
398  if (os_)
399  {
401  *os_ << endl;
402  }
403 
404  unit_assert(filter.size() == 7);
405  unit_assert(filter.spectrumIdentity(0).id == "scan=100");
406  unit_assert(filter.spectrumIdentity(1).id == "scan=102");
407  unit_assert(filter.spectrumIdentity(2).id == "scan=103");
408  unit_assert(filter.spectrumIdentity(3).id == "scan=104");
409  unit_assert(filter.spectrumIdentity(4).id == "scan=106");
410  unit_assert(filter.spectrumIdentity(5).id == "scan=107");
411  unit_assert(filter.spectrumIdentity(6).id == "scan=108");
412 }
a virtual container of integers, accessible via an iterator interface, stored as union of intervals ...
Definition: IntegerSet.hpp:37
ostream * os_
void printSpectrumList(const SpectrumList &sl, ostream &os)
SpectrumList filter, for creating Spectrum sub-lists.
void insert(Interval interval)
insert an interval of integers into the virtual container
#define unit_assert(x)
Definition: unit.hpp:85
void filter(const TContainer &data, const TContainer &filter, TContainer &result, bool circular=false, uint32_t sides=2)
Applies linear convolution (filtering) to a univariate time series.
Definition: filter.hpp:112

◆ testScanTimeRange()

void testScanTimeRange ( SpectrumListPtr  sl)

Definition at line 415 of file SpectrumList_FilterTest.cpp.

References ralab::base::filter::filter(), pwiz::msdata::SpectrumIdentity::id, os_, printSpectrumList(), pwiz::analysis::SpectrumList_Filter::size(), pwiz::analysis::SpectrumList_Filter::spectrumIdentity(), and unit_assert.

Referenced by test().

416 {
417  if (os_) *os_ << "testScanTimeRange:\n";
418 
419  const double low = 422.5;
420  const double high = 427.5;
421 
423 
424  if (os_)
425  {
427  *os_ << endl;
428  }
429 
430  unit_assert(filter.size() == 5);
431  unit_assert(filter.spectrumIdentity(0).id == "scan=103");
432  unit_assert(filter.spectrumIdentity(1).id == "scan=104");
433  unit_assert(filter.spectrumIdentity(2).id == "scan=105");
434  unit_assert(filter.spectrumIdentity(3).id == "scan=106");
435  unit_assert(filter.spectrumIdentity(4).id == "scan=107");
436 }
ostream * os_
void printSpectrumList(const SpectrumList &sl, ostream &os)
SpectrumList filter, for creating Spectrum sub-lists.
#define unit_assert(x)
Definition: unit.hpp:85
void filter(const TContainer &data, const TContainer &filter, TContainer &result, bool circular=false, uint32_t sides=2)
Applies linear convolution (filtering) to a univariate time series.
Definition: filter.hpp:112

◆ testMSLevelSet()

void testMSLevelSet ( SpectrumListPtr  sl)

Definition at line 439 of file SpectrumList_FilterTest.cpp.

References ralab::base::filter::filter(), pwiz::msdata::SpectrumIdentity::id, pwiz::util::IntegerSet::insert(), os_, printSpectrumList(), pwiz::analysis::SpectrumList_Filter::size(), pwiz::analysis::SpectrumList_Filter::spectrumIdentity(), and unit_assert.

Referenced by test().

440 {
441  if (os_) *os_ << "testMSLevelSet:\n";
442 
443  IntegerSet msLevelSet;
444  msLevelSet.insert(1);
445 
447 
448  if (os_)
449  {
451  *os_ << endl;
452  }
453 
454  unit_assert(filter.size() == 4);
455  unit_assert(filter.spectrumIdentity(0).id == "scan=100");
456  unit_assert(filter.spectrumIdentity(1).id == "scan=103");
457  unit_assert(filter.spectrumIdentity(2).id == "scan=106");
458  unit_assert(filter.spectrumIdentity(3).id == "scan=109");
459 
460  IntegerSet msLevelSet2;
461  msLevelSet2.insert(2);
462 
464 
465  if (os_)
466  {
467  printSpectrumList(filter2, *os_);
468  *os_ << endl;
469  }
470 
471  unit_assert(filter2.size() == 6);
472  unit_assert(filter2.spectrumIdentity(0).id == "scan=101");
473  unit_assert(filter2.spectrumIdentity(1).id == "scan=102");
474  unit_assert(filter2.spectrumIdentity(2).id == "scan=104");
475  unit_assert(filter2.spectrumIdentity(3).id == "scan=105");
476  unit_assert(filter2.spectrumIdentity(4).id == "scan=107");
477  unit_assert(filter2.spectrumIdentity(5).id == "scan=108");
478 }
a virtual container of integers, accessible via an iterator interface, stored as union of intervals ...
Definition: IntegerSet.hpp:37
ostream * os_
void printSpectrumList(const SpectrumList &sl, ostream &os)
SpectrumList filter, for creating Spectrum sub-lists.
void insert(Interval interval)
insert an interval of integers into the virtual container
#define unit_assert(x)
Definition: unit.hpp:85
void filter(const TContainer &data, const TContainer &filter, TContainer &result, bool circular=false, uint32_t sides=2)
Applies linear convolution (filtering) to a univariate time series.
Definition: filter.hpp:112

◆ testMS2Activation()

void testMS2Activation ( SpectrumListPtr  sl)

Definition at line 480 of file SpectrumList_FilterTest.cpp.

References ralab::base::filter::filter(), pwiz::msdata::SpectrumIdentity::id, MS_collision_induced_dissociation, MS_electron_transfer_dissociation, MS_HCD, MS_IRMPD, os_, printSpectrumList(), pwiz::analysis::SpectrumList_Filter::size(), pwiz::analysis::SpectrumList_Filter::spectrumIdentity(), and unit_assert.

Referenced by test().

481 {
482  if (os_) *os_ << "testMS2Activation:\n";
483 
485 
486  set<CVID> cvIDs;
487  // CID
488  cvIDs.insert(MS_electron_transfer_dissociation);
489  cvIDs.insert(MS_HCD);
490  cvIDs.insert(MS_IRMPD);
491  SpectrumList_Filter filter(ms2filter,
493 
494  if (os_)
495  {
497  *os_ << endl;
498  }
499 
500  unit_assert(filter.size() == 1);
501  unit_assert(filter.spectrumIdentity(0).id == "scan=102");
502 
503  // ETD + SA
504  cvIDs.clear();
505  cvIDs.insert(MS_electron_transfer_dissociation);
506  cvIDs.insert(MS_collision_induced_dissociation);
507  SpectrumList_Filter filter1(ms2filter,
509  if (os_)
510  {
511  printSpectrumList(filter1, *os_);
512  *os_ << endl;
513  }
514 
515  unit_assert(filter1.size() == 1);
516  unit_assert(filter1.spectrumIdentity(0).id == "scan=107");
517 
518  // ETD
519  cvIDs.clear();
520  cvIDs.insert(MS_electron_transfer_dissociation);
521  SpectrumList_Filter filter2(ms2filter,
523  if (os_)
524  {
525  printSpectrumList(filter2, *os_);
526  *os_ << endl;
527  }
528 
529  unit_assert(filter2.size() == 3);
530  unit_assert(filter2.spectrumIdentity(0).id == "scan=101");
531  unit_assert(filter2.spectrumIdentity(1).id == "scan=105");
532  unit_assert(filter2.spectrumIdentity(2).id == "scan=107");
533 
534  // HCD
535  cvIDs.clear();
536  cvIDs.insert(MS_HCD);
537  SpectrumList_Filter filter3(ms2filter,
539  if (os_)
540  {
541  printSpectrumList(filter3, *os_);
542  *os_ << endl;
543  }
544 
545  unit_assert(filter3.size() == 1);
546  unit_assert(filter3.spectrumIdentity(0).id == "scan=104");
547 
548  // IRMPD
549  cvIDs.clear();
550  cvIDs.insert(MS_IRMPD);
551  SpectrumList_Filter filter4(ms2filter,
553  if (os_)
554  {
555  printSpectrumList(filter4, *os_);
556  *os_ << endl;
557  }
558 
559  unit_assert(filter4.size() == 1);
560  unit_assert(filter4.spectrumIdentity(0).id == "scan=108");
561 
562 }
a virtual container of integers, accessible via an iterator interface, stored as union of intervals ...
Definition: IntegerSet.hpp:37
ostream * os_
MS_collision_induced_dissociation
collision-induced dissociation: The dissociation of an ion after collisional excitation. The term collisional-activated dissociation is not recommended.
Definition: cv.hpp:586
MS_electron_transfer_dissociation
electron transfer dissociation: A process to fragment ions in a mass spectrometer by inducing fragmen...
Definition: cv.hpp:2296
MS_IRMPD
IRMPD (infrared multiphoton dissociation): Multiphoton ionization where the reactant ion dissociates ...
Definition: cv.hpp:1117
boost::shared_ptr< SpectrumList > SpectrumListPtr
Definition: MSData.hpp:707
void printSpectrumList(const SpectrumList &sl, ostream &os)
SpectrumList filter, for creating Spectrum sub-lists.
#define unit_assert(x)
Definition: unit.hpp:85
MS_HCD
HCD (beam-type collision-induced dissociation): A collision-induced dissociation process that occurs ...
Definition: cv.hpp:1690
void filter(const TContainer &data, const TContainer &filter, TContainer &result, bool circular=false, uint32_t sides=2)
Applies linear convolution (filtering) to a univariate time series.
Definition: filter.hpp:112

◆ testMassAnalyzerFilter()

void testMassAnalyzerFilter ( SpectrumListPtr  sl)

Definition at line 564 of file SpectrumList_FilterTest.cpp.

References ralab::base::filter::filter(), pwiz::msdata::SpectrumIdentity::id, MS_fourier_transform_ion_cyclotron_resonance_mass_spectrometer, MS_ion_trap, MS_orbitrap, os_, printSpectrumList(), pwiz::analysis::SpectrumList_Filter::size(), pwiz::analysis::SpectrumList_Filter::spectrumIdentity(), and unit_assert.

Referenced by test().

565 {
566  if (os_) *os_ << "testMassAnalyzerFilter:\n";
567 
568  set<CVID> cvIDs;
569  // msconvert mass analyzer filter FTMS option
570  cvIDs.insert(MS_orbitrap);
574 
575  if (os_)
576  {
578  *os_ << endl;
579  }
580 
581  unit_assert(filter.size() == 7);
582  unit_assert(filter.spectrumIdentity(0).id == "scan=100");
583 
584  cvIDs.clear();
585  // msconvert mass analyzer filter ITMS option
586  cvIDs.insert(MS_ion_trap);
587 
588  SpectrumList_Filter filter1(sl,
590 
591  if (os_)
592  {
593  printSpectrumList(filter1, *os_);
594  *os_ << endl;
595  }
596 
597  unit_assert(filter1.size() == 3);
598  unit_assert(filter1.spectrumIdentity(0).id == "scan=102");
599 }
ostream * os_
MS_fourier_transform_ion_cyclotron_resonance_mass_spectrometer
fourier transform ion cyclotron resonance mass spectrometer: A mass spectrometer based on the princip...
Definition: cv.hpp:373
void printSpectrumList(const SpectrumList &sl, ostream &os)
MS_ion_trap
ion trap: A device for spatially confining ions using electric and magnetic fields alone or in combin...
Definition: cv.hpp:1126
SpectrumList filter, for creating Spectrum sub-lists.
#define unit_assert(x)
Definition: unit.hpp:85
MS_orbitrap
orbitrap: An ion trapping device that consists of an outer barrel-like electrode and a coaxial inner ...
Definition: cv.hpp:1900
void filter(const TContainer &data, const TContainer &filter, TContainer &result, bool circular=false, uint32_t sides=2)
Applies linear convolution (filtering) to a univariate time series.
Definition: filter.hpp:112

◆ testMZPresentFilter()

void testMZPresentFilter ( SpectrumListPtr  sl)

Definition at line 601 of file SpectrumList_FilterTest.cpp.

References ralab::base::filter::filter(), pwiz::msdata::SpectrumIdentity::id, os_, printSpectrumList(), pwiz::analysis::SpectrumList_Filter::size(), pwiz::analysis::SpectrumList_Filter::spectrumIdentity(), and unit_assert_operator_equal.

Referenced by test().

602 {
603  if (os_) *os_ << "testMZPresentFilter:\n";
604 
605  // test mzpresent on MS level 2 (include test)
607  chemistry::MZTolerance mzt(3.0);
608  std::set<double> mzSet;
609  mzSet.insert(200.0);
610  mzSet.insert(300.0);
611  mzSet.insert(400.0);
612  double threshold = 10;
613  IntegerSet msLevels(1, INT_MAX);
614  ThresholdFilter tf(ThresholdFilter::ThresholdingBy_Count, threshold, ThresholdFilter::Orientation_MostIntense, msLevels);
615  SpectrumList_Filter filter(ms2filter, SpectrumList_FilterPredicate_MzPresent(mzt, mzSet, tf, SpectrumList_Filter::Predicate::FilterMode_Include));
616 
617  if (os_)
618  {
620  *os_ << endl;
621  }
623  unit_assert_operator_equal("scan=102", filter.spectrumIdentity(0).id);
624  unit_assert_operator_equal("scan=104", filter.spectrumIdentity(1).id);
625  unit_assert_operator_equal("scan=105", filter.spectrumIdentity(2).id);
626  unit_assert_operator_equal("scan=107", filter.spectrumIdentity(3).id);
627 
628  // test mz present on MS level 1 (exclude test)
630  chemistry::MZTolerance mzt1(3.0);
631  std::set<double> mzSet1;
632  mzSet1.insert(200.0);
633  mzSet1.insert(300.0);
634  double threshold1 = 5;
635  ThresholdFilter tf1(ThresholdFilter::ThresholdingBy_Count, threshold1, ThresholdFilter::Orientation_MostIntense, msLevels);
636  SpectrumList_Filter filter1(ms1filter, SpectrumList_FilterPredicate_MzPresent(mzt1, mzSet1, tf1, SpectrumList_Filter::Predicate::FilterMode_Exclude));
637 
638  if (os_)
639  {
640  printSpectrumList(filter1, *os_);
641  *os_ << endl;
642  }
643  unit_assert_operator_equal(3, filter1.size());
644  unit_assert_operator_equal("scan=100", filter1.spectrumIdentity(0).id);
645  unit_assert_operator_equal("scan=106", filter1.spectrumIdentity(1).id);
646  unit_assert_operator_equal("scan=109", filter1.spectrumIdentity(2).id);
647 }
a virtual container of integers, accessible via an iterator interface, stored as union of intervals ...
Definition: IntegerSet.hpp:37
ostream * os_
#define unit_assert_operator_equal(expected, actual)
Definition: unit.hpp:92
boost::shared_ptr< SpectrumList > SpectrumListPtr
Definition: MSData.hpp:707
void printSpectrumList(const SpectrumList &sl, ostream &os)
struct for expressing m/z tolerance in either amu or ppm
Definition: MZTolerance.hpp:38
SpectrumList filter, for creating Spectrum sub-lists.
void filter(const TContainer &data, const TContainer &filter, TContainer &result, bool circular=false, uint32_t sides=2)
Applies linear convolution (filtering) to a univariate time series.
Definition: filter.hpp:112

◆ testThermoFilterFilter()

void testThermoFilterFilter ( SpectrumListPtr  sl)

Definition at line 649 of file SpectrumList_FilterTest.cpp.

References pwiz::msdata::SpectrumIdentity::id, os_, printSpectrumList(), pwiz::analysis::SpectrumList_Filter::size(), pwiz::analysis::SpectrumList_Filter::spectrumIdentity(), and unit_assert.

Referenced by test().

650 {
651  if (os_) *os_ << "testThermoFilterFilter:\n";
652 
653  // test for query of "395.0000-1005.0000" using contains (include)
654  string queryString = "395.0000-1005.0000";
655  SpectrumList_Filter filter1(sl, SpectrumList_FilterPredicate_ThermoScanFilter(queryString, false, false));
656  if (os_)
657  {
658  *os_ << "Including all spectra that contain " << queryString << endl;
659  printSpectrumList(filter1, *os_);
660  *os_ << endl;
661  }
662  unit_assert(filter1.size() == 2);
663  unit_assert(filter1.spectrumIdentity(0).id == "scan=103");
664  unit_assert(filter1.spectrumIdentity(1).id == "scan=109");
665 
666  // test for query of "395.0000-1005.0000" using contains (exclude)
667  SpectrumList_Filter filter2(sl, SpectrumList_FilterPredicate_ThermoScanFilter(queryString, false, true));
668  if (os_)
669  {
670  *os_ << "Excluding all spectra that contain " << queryString << endl;
671  printSpectrumList(filter2, *os_);
672  *os_ << endl;
673  }
674  unit_assert(filter2.size() == 8);
675  unit_assert(filter2.spectrumIdentity(0).id == "scan=100");
676  unit_assert(filter2.spectrumIdentity(1).id == "scan=101");
677  unit_assert(filter2.spectrumIdentity(2).id == "scan=102");
678  unit_assert(filter2.spectrumIdentity(3).id == "scan=104");
679  unit_assert(filter2.spectrumIdentity(4).id == "scan=105");
680  unit_assert(filter2.spectrumIdentity(5).id == "scan=106");
681  unit_assert(filter2.spectrumIdentity(6).id == "scan=107");
682  unit_assert(filter2.spectrumIdentity(7).id == "scan=108");
683 
684  // test for query of "ms2" using contains (exclude)
685  queryString = "ms2";
686  SpectrumList_Filter filter3(sl, SpectrumList_FilterPredicate_ThermoScanFilter(queryString, false, true));
687  if (os_)
688  {
689  *os_ << "Excluding all spectra that contain " << queryString << endl;
690  printSpectrumList(filter3, *os_);
691  *os_ << endl;
692  }
693  unit_assert(filter3.size() == 4);
694  unit_assert(filter3.spectrumIdentity(0).id == "scan=100");
695  unit_assert(filter3.spectrumIdentity(1).id == "scan=103");
696  unit_assert(filter3.spectrumIdentity(2).id == "scan=106");
697  unit_assert(filter3.spectrumIdentity(3).id == "scan=109");
698 
699  // test for exact query of "FTMS + p NSI SIM ms [395.0000-1005.0000]" (include)
700  queryString = "FTMS + p NSI SIM ms [395.0000-1005.0000]";
701  SpectrumList_Filter filter4(sl, SpectrumList_FilterPredicate_ThermoScanFilter(queryString, true, false));
702  if (os_)
703  {
704  *os_ << "Including all spectra that exactly match " << queryString << endl;
705  printSpectrumList(filter4, *os_);
706  *os_ << endl;
707  }
708  unit_assert(filter4.size() == 2);
709  unit_assert(filter4.spectrumIdentity(0).id == "scan=103");
710  unit_assert(filter4.spectrumIdentity(1).id == "scan=109");
711 
712  // test for exact query of "FTMS + p NSI SIM ms [395.0000-1005.0000]" (exclude)
713  queryString = "FTMS + p NSI SIM ms [395.0000-1005.0000]";
714  SpectrumList_Filter filter5(sl, SpectrumList_FilterPredicate_ThermoScanFilter(queryString, true, true));
715  if (os_)
716  {
717  *os_ << "Excluding all spectra that exactly match " << queryString << endl;
718  printSpectrumList(filter5, *os_);
719  *os_ << endl;
720  }
721  unit_assert(filter5.size() == 8);
722  unit_assert(filter5.spectrumIdentity(0).id == "scan=100");
723  unit_assert(filter5.spectrumIdentity(1).id == "scan=101");
724  unit_assert(filter5.spectrumIdentity(2).id == "scan=102");
725  unit_assert(filter5.spectrumIdentity(3).id == "scan=104");
726  unit_assert(filter5.spectrumIdentity(4).id == "scan=105");
727  unit_assert(filter5.spectrumIdentity(5).id == "scan=106");
728  unit_assert(filter5.spectrumIdentity(6).id == "scan=107");
729  unit_assert(filter5.spectrumIdentity(7).id == "scan=108");
730 }
ostream * os_
void printSpectrumList(const SpectrumList &sl, ostream &os)
SpectrumList filter, for creating Spectrum sub-lists.
#define unit_assert(x)
Definition: unit.hpp:85

◆ test()

void test ( )

Definition at line 732 of file SpectrumList_FilterTest.cpp.

References createSpectrumList(), testEven(), testEvenMS2(), testHasBinaryData(), testIndexSet(), testMassAnalyzerFilter(), testMS2Activation(), testMSLevelSet(), testMZPresentFilter(), testScanEventSet(), testScanNumberSet(), testScanTimeRange(), testSelectedIndices(), and testThermoFilterFilter().

Referenced by main().

733 {
735  testEven(sl);
736  testEvenMS2(sl);
738  testHasBinaryData(sl);
739  testIndexSet(sl);
740  testScanNumberSet(sl);
741  testScanEventSet(sl);
742  testScanTimeRange(sl);
743  testMSLevelSet(sl);
744  testMS2Activation(sl);
748 }
void testThermoFilterFilter(SpectrumListPtr sl)
void testEvenMS2(SpectrumListPtr sl)
void testScanNumberSet(SpectrumListPtr sl)
void testMSLevelSet(SpectrumListPtr sl)
SpectrumListPtr createSpectrumList()
void testScanTimeRange(SpectrumListPtr sl)
void testMS2Activation(SpectrumListPtr sl)
void testScanEventSet(SpectrumListPtr sl)
boost::shared_ptr< SpectrumList > SpectrumListPtr
Definition: MSData.hpp:707
void testSelectedIndices(SpectrumListPtr sl)
void testMZPresentFilter(SpectrumListPtr sl)
void testHasBinaryData(SpectrumListPtr sl)
void testMassAnalyzerFilter(SpectrumListPtr sl)
void testEven(SpectrumListPtr sl)
void testIndexSet(SpectrumListPtr sl)

◆ main()

int main ( int  argc,
char *  argv[] 
)

Definition at line 751 of file SpectrumList_FilterTest.cpp.

References os_, test(), TEST_EPILOG, TEST_FAILED, and TEST_PROLOG.

752 {
753  TEST_PROLOG(argc, argv)
754 
755  try
756  {
757  if (argc>1 && !strcmp(argv[1],"-v")) os_ = &cout;
758  test();
759  }
760  catch (exception& e)
761  {
762  TEST_FAILED(e.what())
763  }
764  catch (...)
765  {
766  TEST_FAILED("Caught unknown exception.")
767  }
768 
770 }
ostream * os_
#define TEST_EPILOG
Definition: unit.hpp:182
#define TEST_FAILED(x)
Definition: unit.hpp:176
#define TEST_PROLOG(argc, argv)
Definition: unit.hpp:174

Variable Documentation

◆ os_

ostream* os_ = 0