ProteoWizard
SpectrumIteratorTest.cpp
Go to the documentation of this file.
1//
2// $Id$
3//
4//
5// Original author: Darren Kessner <darren@proteowizard.org>
6//
7// Copyright 2007 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 "SpectrumIterator.hpp"
25#include "MSData.hpp"
29#include <cstring>
30
31
32using namespace pwiz::cv;
33using namespace pwiz::msdata;
34using namespace pwiz::util;
35
36
37ostream* os_ = 0;
38
39
41{
42 // initialize with scans:
43 // scan 0: IT
44 // scan 5: FT (1,100)
45 // scan 10: IT (1,100), (2,200)
46 // scan 15: FT (1,100), (2,200), (3,300)
47 // scan 20: IT (1,100), (2,200), (3,300), (4,400)
48 // ...
49
50 for (int i=0; i<=10; i++)
51 {
52 SpectrumPtr spectrum(new Spectrum);
53 spectrum->id = lexical_cast<string>(i*5);
54
55 spectrum->cvParams.push_back(i%2 ?
56 MS_FT_ICR :
58
60 bdMZ->cvParams.push_back(MS_m_z_array);
61 spectrum->binaryDataArrayPtrs.push_back(bdMZ);
62
63 BinaryDataArrayPtr bdIntensity(new BinaryDataArray);
64 bdIntensity->cvParams.push_back(MS_intensity_array);
65 spectrum->binaryDataArrayPtrs.push_back(bdIntensity);
66
67 for (int j=1; j<=i; j++)
68 {
69 bdMZ->data.push_back(j);
70 bdIntensity->data.push_back(100*j);
71 }
72
73 spectrum->defaultArrayLength = i;
74 spectrumList.spectra.push_back(spectrum);
75 }
76}
77
78
79const char* anal(const CVParam& cvParam)
80{
81 if (cvParam == MS_FT_ICR)
82 return "FT";
83 else if (cvParam == MS_ion_trap)
84 return "IT";
85 else
86 return "Unknown";
87}
88
89
90void printSpectrumList(ostream& os, const SpectrumList& sl)
91{
92 if (os_) *os_ << "printSpectrumList()\n";
93
94 for (unsigned int i=0; i<sl.size(); i++)
95 {
96 SpectrumPtr spectrum = sl.spectrum(i);
97 os << spectrum->id << " "
98 << anal(spectrum->cvParamChild(MS_mass_analyzer)) << endl;
99
100 vector<MZIntensityPair> mziPairs;
101 spectrum->getMZIntensityPairs(mziPairs);
102 copy(mziPairs.begin(), mziPairs.end(), ostream_iterator<MZIntensityPair>(os,""));
103 os << endl;
104 }
105}
106
107
108void testBasic(const SpectrumList& sl)
109{
110 if (os_) *os_ << "testBasic()\n";
111
112 SpectrumIterator it(sl);
113
114 unit_assert(it->id == "0");
115 unit_assert((*it).cvParamChild(MS_mass_analyzer_type) == MS_ion_trap);
116 unit_assert(it->binaryDataArrayPtrs.size() == 2);
117
118 ++it; ++it; ++it; ++it; ++it; // advance to scan 5
119
120 unit_assert(it->id == "25");
122 unit_assert(it->binaryDataArrayPtrs.size() == 2 &&
123 it->binaryDataArrayPtrs[0]->data.size() == 5);
124}
125
126
127void doSomething(const Spectrum& spectrum)
128{
129 if (os_) *os_ << "spectrum: " << spectrum.id << " "
130 << anal(spectrum.cvParamChild(MS_mass_analyzer)) << endl;
131
132 vector<MZIntensityPair> pairs;
133 spectrum.getMZIntensityPairs(pairs);
134
135 if (os_)
136 {
137 copy(pairs.begin(), pairs.end(), ostream_iterator<MZIntensityPair>(*os_,""));
138 *os_ << endl;
139 }
140
141 unit_assert((int)pairs.size()*5 == lexical_cast<int>(spectrum.id));
142}
143
144
145void testForEach(const SpectrumList& spectrumList)
146{
147 if (os_) *os_ << "testForEach(): \n";
148 for_each(SpectrumIterator(spectrumList), SpectrumIterator(), doSomething);
149}
150
151
152void testIntegerSet(const SpectrumList& spectrumList)
153{
154 // iterate through even scan numbers
155
156 if (os_) *os_ << "testIntegerSet():\n";
157
158 IntegerSet scanNumbers;
159 for (int i=2; i<=50; i+=2) // note that some scan numbers don't exist in spectrumList
160 scanNumbers.insert(i);
161
162 // loop written for illustration
163 // note automatic conversion from IntegerSet to SpectrumIterator::Config
164 for (SpectrumIterator it(spectrumList, scanNumbers); it!=SpectrumIterator(); ++it)
165 doSomething(*it);
166
167 // using for_each:
168 for_each(SpectrumIterator(spectrumList, scanNumbers), SpectrumIterator(), doSomething);
169}
170
171
172inline int getScanNumber(const Spectrum& spectrum)
173{
174 return lexical_cast<int>(spectrum.id);
175}
176
177
179{
180 public:
181 virtual bool accept(const Spectrum& spectrum) const
182 {
183 return (spectrum.cvParamChild(MS_mass_analyzer_type) == MS_FT_ICR);
184 }
185};
186
187
188void testSieve(const SpectrumList& spectrumList)
189{
190 vector<int> ftScanNumbers;
191
192 FTSieve sieve;
193 SpectrumIterator::Config config(sieve, false);
194
195 transform(SpectrumIterator(spectrumList, config),
197 back_inserter(ftScanNumbers),
199
200 if (os_)
201 {
202 *os_ << "testSieve():\n";
203 copy(ftScanNumbers.begin(), ftScanNumbers.end(), ostream_iterator<int>(*os_, " "));
204 *os_ << endl;
205 }
206
207 unit_assert(ftScanNumbers.size() == 5);
208 unit_assert(ftScanNumbers[0] == 5);
209 unit_assert(ftScanNumbers[1] == 15);
210 unit_assert(ftScanNumbers[2] == 25);
211 unit_assert(ftScanNumbers[3] == 35);
212 unit_assert(ftScanNumbers[4] == 45);
213}
214
215
216void testIteratorEquality(const SpectrumList& spectrumList)
217{
218 if (os_) *os_ << "testIteratorEquality()\n";
219
220 SpectrumIterator it(spectrumList);
221 ++it; ++it; ++it;
222
223 SpectrumIterator jt(spectrumList);
224 unit_assert(it!=jt);
225 ++jt;
226 unit_assert(it!=jt);
227 ++jt;
228 unit_assert(it!=jt);
229 ++jt;
230 unit_assert(it==jt);
231}
232
233
235{
236 if (os_) *os_ << "testMSDataConstruction()\n";
237
240
241 MSData msd;
242 msd.run.spectrumListPtr = sl;
243
244 int i = 0;
245 FTSieve sieve;
246 for (SpectrumIterator it(msd, sieve); it!=SpectrumIterator(); ++it, ++i)
247 {
248 if (os_) *os_ << it->id << " "
249 << anal(it->cvParamChild(MS_mass_analyzer)) << endl;
250
251 unit_assert(it->id == lexical_cast<string>(5+i*10));
252 }
253}
254
255
256int main(int argc, char* argv[])
257{
258 TEST_PROLOG(argc, argv)
259
260 try
261 {
262 if (argc>1 && !strcmp(argv[1],"-v")) os_ = &cout;
263
264 SpectrumListSimple spectrumList;
265 initializeSpectrumList(spectrumList);
266 if (os_) printSpectrumList(*os_, spectrumList);
267
268 testBasic(spectrumList);
269 testForEach(spectrumList);
270 testIntegerSet(spectrumList);
271 testSieve(spectrumList);
272 testIteratorEquality(spectrumList);
274
275 }
276 catch (exception& e)
277 {
278 TEST_FAILED(e.what())
279 }
280 catch (...)
281 {
282 TEST_FAILED("Caught unknown exception.")
283 }
284
286}
287
288
void testBasic()
int main(int argc, char *argv[])
const char * anal(const CVParam &cvParam)
void initializeSpectrumList(SpectrumListSimple &spectrumList)
void testIteratorEquality(const SpectrumList &spectrumList)
int getScanNumber(const Spectrum &spectrum)
void testForEach(const SpectrumList &spectrumList)
void testIntegerSet(const SpectrumList &spectrumList)
void testMSDataConstruction()
void printSpectrumList(ostream &os, const SpectrumList &sl)
void doSomething(const Spectrum &spectrum)
ostream * os_
void testSieve(const SpectrumList &spectrumList)
virtual bool accept(const Spectrum &spectrum) const
interface for filtering based on ScanInfo
SpectrumIterator provides convenient iteration through a set of scans in a SpectrumList.
Interface for accessing spectra, which may be stored in memory or backed by a data file (RAW,...
Definition MSData.hpp:661
virtual size_t size() const =0
returns the number of spectra
virtual SpectrumPtr spectrum(size_t index, bool getBinaryData=false) const =0
retrieve a spectrum by index
a virtual container of integers, accessible via an iterator interface, stored as union of intervals
void insert(Interval interval)
insert an interval of integers into the virtual container
MS_intensity_array
intensity array: A data array of intensity values.
Definition cv.hpp:2151
MS_mass_analyzer
mass analyzer: Terms used to describe the Analyzer.
Definition cv.hpp:1938
MS_FT_ICR
FT_ICR (fourier transform ion cyclotron resonance mass spectrometer): A mass spectrometer based on th...
Definition cv.hpp:537
MS_mass_analyzer_type
mass analyzer type: Mass analyzer separates the ions according to their mass-to-charge ratio.
Definition cv.hpp:1911
MS_m_z_array
m/z array: A data array of m/z values.
Definition cv.hpp:2148
MS_ion_trap
ion trap: A device for spatially confining ions using electric and magnetic fields alone or in combin...
Definition cv.hpp:1278
boost::shared_ptr< BinaryDataArray > BinaryDataArrayPtr
Definition MSData.hpp:417
boost::shared_ptr< Spectrum > SpectrumPtr
Definition MSData.hpp:573
boost::shared_ptr< SpectrumListSimple > SpectrumListSimplePtr
Definition MSData.hpp:731
represents a tag-value pair, where the tag comes from the controlled vocabulary
CVParam cvParamChild(CVID cvid) const
finds child of cvid in the container:
The structure into which encoded binary data goes. Byte ordering is always little endian (Intel style...
Definition MSData.hpp:405
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
SpectrumListPtr spectrumListPtr
all mass spectra and the acquisitions underlying them are described and attached here....
Definition MSData.hpp:827
The structure that captures the generation of a peak list (including the underlying acquisitions)
Definition MSData.hpp:506
void getMZIntensityPairs(std::vector< MZIntensityPair > &output) const
copy binary data arrays into m/z-intensity pair array
std::vector< BinaryDataArrayPtr > binaryDataArrayPtrs
list of binary data arrays.
Definition MSData.hpp:526
std::string id
a unique identifier for this spectrum. It should be expected that external files may use this identif...
Definition MSData.hpp:476
SpectrumIterator configuration – note that constructors allow automatic conversion from IntegerSet or...
Simple writeable in-memory implementation of SpectrumList.
Definition MSData.hpp:717
std::vector< SpectrumPtr > spectra
Definition MSData.hpp:718
#define unit_assert(x)
Definition unit.hpp:85
#define TEST_EPILOG
Definition unit.hpp:183
#define TEST_FAILED(x)
Definition unit.hpp:177
#define TEST_PROLOG(argc, argv)
Definition unit.hpp:175