ProteoWizard
Functions | Variables
SpectrumListCacheTest.cpp File Reference
#include "pwiz/utility/misc/unit.hpp"
#include "MSDataFile.hpp"
#include "MemoryMRUCache.hpp"
#include "SpectrumListCache.hpp"
#include "pwiz/utility/misc/Std.hpp"
#include "Serializer_MGF.hpp"

Go to the source code of this file.

Functions

ostream & std::operator<< (ostream &os, SpectrumListCache::CacheType &cache)
 
void testMemoryMRUCache ()
 
SpectrumPtr makeSpectrumPtr (size_t index, const string &id)
 
bool spectrumHasMetadata (const Spectrum &s)
 
bool spectrumHasBinaryData (const Spectrum &s)
 
void testModeOff ()
 
void testModeMetaDataOnly ()
 
void testModeBinaryDataOnly ()
 
void testModeMetaDataAndBinaryData ()
 
void testFileReads (const char *filename)
 
void test ()
 
int main (int argc, char *argv[])
 

Variables

ostream * os_ = 0
 

Function Documentation

◆ operator<<()

ostream& std::operator<< ( ostream &  os,
SpectrumListCache::CacheType cache 
)

Definition at line 42 of file SpectrumListCacheTest.cpp.

43 {
44  os << "Spectrum cache indices (from MRU to LRU):";
45  for (SpectrumListCache::CacheType::iterator itr = cache.begin(); itr != cache.end(); ++itr)
46  os << " " << itr->spectrum->index;
47  return os;
48 }

References pwiz::util::mru_list< Item, KeyExtractor >::begin(), and pwiz::util::mru_list< Item, KeyExtractor >::end().

◆ testMemoryMRUCache()

void testMemoryMRUCache ( )

Definition at line 53 of file SpectrumListCacheTest.cpp.

54 {
56 
57  unit_assert_operator_equal(2, cache.max_size());
58  unit_assert(cache.empty());
59  unit_assert_operator_equal(0, cache.size());
60 
61  cache.insert(SpectrumListCache::CacheEntry(0, SpectrumPtr()));
62 
63  unit_assert(!cache.empty());
64  unit_assert_operator_equal(1, cache.size());
65 
66  cache.insert(SpectrumListCache::CacheEntry(1, SpectrumPtr()));
67 
68  unit_assert_operator_equal(2, cache.size());
69  unit_assert_operator_equal(1, cache.mru().index);
70  unit_assert_operator_equal(0, cache.lru().index);
71 
72  cache.insert(SpectrumListCache::CacheEntry(0, SpectrumPtr()));
73 
74  unit_assert_operator_equal(2, cache.size());
75  unit_assert_operator_equal(0, cache.mru().index);
76  unit_assert_operator_equal(1, cache.lru().index);
77 
78  cache.insert(SpectrumListCache::CacheEntry(2, SpectrumPtr()));
79 
80  unit_assert_operator_equal(2, cache.size());
81  unit_assert_operator_equal(2, cache.mru().index);
82  unit_assert_operator_equal(0, cache.lru().index);
83 }

References pwiz::util::mru_list< Item, KeyExtractor >::empty(), pwiz::util::mru_list< Item, KeyExtractor >::insert(), pwiz::util::mru_list< Item, KeyExtractor >::lru(), pwiz::util::mru_list< Item, KeyExtractor >::max_size(), MemoryMRUCacheMode_Off, pwiz::util::mru_list< Item, KeyExtractor >::mru(), pwiz::util::mru_list< Item, KeyExtractor >::size(), unit_assert, and unit_assert_operator_equal.

Referenced by test().

◆ makeSpectrumPtr()

SpectrumPtr makeSpectrumPtr ( size_t  index,
const string &  id 
)

Definition at line 86 of file SpectrumListCacheTest.cpp.

87 {
88  SpectrumPtr spectrum(new Spectrum);
89  spectrum->id = id;
90  spectrum->index = index;
91  spectrum->set(MS_MSn_spectrum);
92  spectrum->set(MS_ms_level, 2);
93  spectrum->precursors.push_back(Precursor(123.4));
94  spectrum->setMZIntensityArrays(vector<double>(), vector<double>(), MS_number_of_detector_counts);
95  BinaryDataArray& mzArray = *spectrum->getMZArray();
96  BinaryDataArray& intensityArray = *spectrum->getIntensityArray();
97  for (size_t i=0; i < (index+1)*10; ++i)
98  {
99  mzArray.data.push_back(i);
100  intensityArray.data.push_back(i*100);
101  }
102  spectrum->defaultArrayLength = mzArray.data.size();
103  return spectrum;
104 }

References pwiz::msdata::BinaryDataArray::data, MS_ms_level, MS_MSn_spectrum, MS_number_of_detector_counts, pwiz::util::BinaryData< T >::push_back(), and pwiz::util::BinaryData< T >::size().

Referenced by testModeBinaryDataOnly(), testModeMetaDataAndBinaryData(), testModeMetaDataOnly(), and testModeOff().

◆ spectrumHasMetadata()

bool spectrumHasMetadata ( const Spectrum s)

◆ spectrumHasBinaryData()

bool spectrumHasBinaryData ( const Spectrum s)

◆ testModeOff()

void testModeOff ( )

Definition at line 122 of file SpectrumListCacheTest.cpp.

123 {
124  // initialize list
125  shared_ptr<SpectrumListSimple> sl(new SpectrumListSimple);
126  sl->spectra.push_back(makeSpectrumPtr(0, "S1"));
127  sl->spectra.push_back(makeSpectrumPtr(1, "S2"));
128  sl->spectra.push_back(makeSpectrumPtr(2, "S3"));
129  sl->spectra.push_back(makeSpectrumPtr(3, "S4"));
130 
131  // access a series of spectra and make sure the cache behaves appropriately:
132  // in off mode, the cache should always be empty
133 
134  SpectrumPtr s;
135 
137  SpectrumListCache::CacheType& cache = slc.spectrumCache();
138 
139  unit_assert(cache.empty());
140 
141  s = slc.spectrum(0, false);
142  s = slc.spectrum(1, true);
143  s = slc.spectrum(2, false);
144  s = slc.spectrum(3, true);
145 
146  if (os_) *os_ << cache << endl;
147  unit_assert(cache.empty());
148 }

References pwiz::util::mru_list< Item, KeyExtractor >::empty(), makeSpectrumPtr(), MemoryMRUCacheMode_Off, os_, pwiz::msdata::SpectrumListCache::spectrum(), pwiz::msdata::SpectrumListCache::spectrumCache(), and unit_assert.

Referenced by test().

◆ testModeMetaDataOnly()

void testModeMetaDataOnly ( )

Definition at line 151 of file SpectrumListCacheTest.cpp.

152 {
153  // initialize list
154  MSData msd;
155  shared_ptr<SpectrumListSimple> sl(new SpectrumListSimple);
156  sl->spectra.push_back(makeSpectrumPtr(0, "S1"));
157  sl->spectra.push_back(makeSpectrumPtr(1, "S2"));
158  sl->spectra.push_back(makeSpectrumPtr(2, "S3"));
159  sl->spectra.push_back(makeSpectrumPtr(3, "S4"));
160  msd.run.spectrumListPtr = sl;
161 
162  // SpectrumListSimple returns the same shared_ptrs regardless of caching;
163  // serializing to MGF and back will produce different shared_ptrs
164  boost::shared_ptr<stringstream> ss(new stringstream);
165  Serializer_MGF serializer;
166  serializer.write(*ss, msd, 0);
167  serializer.read(ss, msd);
168 
169  // access a series of spectra and make sure the cache behaves appropriately:
170  // in metadata-only mode, entries in the cache should:
171  // - always have metadata
172  // - never have binary data
173 
174  SpectrumPtr s;
175 
177  SpectrumListCache::CacheType& cache = slc.spectrumCache();
178 
179  unit_assert(cache.empty());
181 
182  s = slc.spectrum(0, false);
183 
184  // pointers should be equal
185  unit_assert_operator_equal(slc.spectrum(0, false), s);
186 
187  if (os_) *os_ << cache << endl;
188  unit_assert(!cache.empty());
189  unit_assert_operator_equal(1, cache.size());
190  unit_assert_operator_equal(0, cache.mru().spectrum->index);
191 
192  // with-binary-data access should return the binary data, but only cache the metadata
193  s = slc.spectrum(1, true);
194 
195  if (os_) *os_ << cache << endl;
196  unit_assert_operator_equal(2, cache.size());
197  unit_assert_operator_equal(1, cache.mru().spectrum->index);
198  unit_assert(spectrumHasMetadata(*cache.mru().spectrum));
199  unit_assert(!spectrumHasBinaryData(*cache.mru().spectrum));
200  unit_assert(spectrumHasMetadata(*cache.lru().spectrum));
201  unit_assert_operator_equal(0, cache.lru().spectrum->index);
202 
203  s = slc.spectrum(2, false);
204 
205  // pointers should be equal
206  unit_assert_operator_equal(slc.spectrum(2, false), s);
207 
208  if (os_) *os_ << cache << endl;
209  unit_assert_operator_equal(2, cache.size());
210  unit_assert_operator_equal(2, cache.mru().spectrum->index);
211  unit_assert(spectrumHasMetadata(*cache.mru().spectrum));
212  unit_assert(!spectrumHasBinaryData(*cache.mru().spectrum));
213  unit_assert_operator_equal(1, cache.lru().spectrum->index);
214 
215  s = slc.spectrum(3, true);
216 
217  if (os_) *os_ << cache << endl;
218  unit_assert_operator_equal(2, cache.size());
219  unit_assert_operator_equal(3, cache.mru().spectrum->index);
220  unit_assert(spectrumHasMetadata(*cache.mru().spectrum));
221  unit_assert(!spectrumHasBinaryData(*cache.mru().spectrum));
222  unit_assert_operator_equal(2, cache.lru().spectrum->index);
223  unit_assert(spectrumHasMetadata(*cache.lru().spectrum));
224 
225  s = slc.spectrum(2, true);
226 
227  if (os_) *os_ << cache << endl;
228  unit_assert_operator_equal(2, cache.size());
229  unit_assert_operator_equal(2, cache.mru().spectrum->index);
230  unit_assert(spectrumHasMetadata(*cache.mru().spectrum));
231  unit_assert(!spectrumHasBinaryData(*cache.mru().spectrum));
232  unit_assert_operator_equal(3, cache.lru().spectrum->index);
233  unit_assert(spectrumHasMetadata(*cache.lru().spectrum));
234 }

References pwiz::util::mru_list< Item, KeyExtractor >::empty(), pwiz::util::mru_list< Item, KeyExtractor >::lru(), makeSpectrumPtr(), pwiz::util::mru_list< Item, KeyExtractor >::max_size(), MemoryMRUCacheMode_MetaDataOnly, pwiz::util::mru_list< Item, KeyExtractor >::mru(), os_, pwiz::msdata::Serializer_MGF::read(), pwiz::msdata::MSData::run, pwiz::util::mru_list< Item, KeyExtractor >::size(), pwiz::msdata::SpectrumListCache::spectrum(), pwiz::msdata::SpectrumListCache::spectrumCache(), spectrumHasBinaryData(), spectrumHasMetadata(), pwiz::msdata::Run::spectrumListPtr, unit_assert, unit_assert_operator_equal, and pwiz::msdata::Serializer_MGF::write().

Referenced by test().

◆ testModeBinaryDataOnly()

void testModeBinaryDataOnly ( )

Definition at line 237 of file SpectrumListCacheTest.cpp.

238 {
239  // initialize list
240  MSData msd;
241  shared_ptr<SpectrumListSimple> sl(new SpectrumListSimple);
242  sl->spectra.push_back(makeSpectrumPtr(0, "S1"));
243  sl->spectra.push_back(makeSpectrumPtr(1, "S2"));
244  sl->spectra.push_back(makeSpectrumPtr(2, "S3"));
245  sl->spectra.push_back(makeSpectrumPtr(3, "S4"));
246  msd.run.spectrumListPtr = sl;
247 
248  // SpectrumListSimple returns the same shared_ptrs regardless of caching;
249  // serializing to MGF and back will produce different shared_ptrs
250  boost::shared_ptr<stringstream> ss(new stringstream);
251  Serializer_MGF serializer;
252  serializer.write(*ss, msd, 0);
253  serializer.read(ss, msd);
254 
255  // access a series of spectra and make sure the cache behaves appropriately:
256  // in binary-data-only mode, entries in the cache should:
257  // - never have metadata
258  // - always have binary data
259 
260  SpectrumPtr s;
261 
263  SpectrumListCache::CacheType& cache = slc.spectrumCache();
264 
265  unit_assert(cache.empty());
267 
268  // metadata-only access should not affect the cache
269  s = slc.spectrum(0, false);
270 
271  if (os_) *os_ << cache << endl;
272  unit_assert(cache.empty());
273  unit_assert_operator_equal(0, cache.size());
274 
275  // with-binary-data access should be cached without the metadata
276  s = slc.spectrum(1, true);
277 
278  if (os_) *os_ << cache << endl;
279  unit_assert_operator_equal(1, cache.size());
280  unit_assert_operator_equal(1, cache.mru().spectrum->index);
281  unit_assert(!spectrumHasMetadata(*cache.mru().spectrum));
282  unit_assert(spectrumHasBinaryData(*cache.mru().spectrum));
283 
284  s = slc.spectrum(2, false);
285 
286  if (os_) *os_ << cache << endl;
287  unit_assert_operator_equal(1, cache.size());
288  unit_assert_operator_equal(1, cache.mru().spectrum->index);
289  unit_assert(!spectrumHasMetadata(*cache.mru().spectrum));
290  unit_assert(spectrumHasBinaryData(*cache.mru().spectrum));
291 
292  s = slc.spectrum(3, true);
293 
294  if (os_) *os_ << cache << endl;
295  unit_assert_operator_equal(2, cache.size());
296  unit_assert_operator_equal(3, cache.mru().spectrum->index);
297  unit_assert(!spectrumHasMetadata(*cache.mru().spectrum));
298  unit_assert(spectrumHasBinaryData(*cache.mru().spectrum));
299  unit_assert_operator_equal(1, cache.lru().spectrum->index);
300  unit_assert(!spectrumHasMetadata(*cache.lru().spectrum));
301  unit_assert(spectrumHasBinaryData(*cache.lru().spectrum));
302 
303  s = slc.spectrum(1, true);
304 
305  if (os_) *os_ << cache << endl;
306  unit_assert_operator_equal(2, cache.size());
307  unit_assert_operator_equal(1, cache.mru().spectrum->index);
308  unit_assert(!spectrumHasMetadata(*cache.mru().spectrum));
309  unit_assert(spectrumHasBinaryData(*cache.mru().spectrum));
310  unit_assert_operator_equal(3, cache.lru().spectrum->index);
311  unit_assert(!spectrumHasMetadata(*cache.lru().spectrum));
312  unit_assert(spectrumHasBinaryData(*cache.lru().spectrum));
313 }

References pwiz::util::mru_list< Item, KeyExtractor >::empty(), pwiz::util::mru_list< Item, KeyExtractor >::lru(), makeSpectrumPtr(), pwiz::util::mru_list< Item, KeyExtractor >::max_size(), MemoryMRUCacheMode_BinaryDataOnly, pwiz::util::mru_list< Item, KeyExtractor >::mru(), os_, pwiz::msdata::Serializer_MGF::read(), pwiz::msdata::MSData::run, pwiz::util::mru_list< Item, KeyExtractor >::size(), pwiz::msdata::SpectrumListCache::spectrum(), pwiz::msdata::SpectrumListCache::spectrumCache(), spectrumHasBinaryData(), spectrumHasMetadata(), pwiz::msdata::Run::spectrumListPtr, unit_assert, unit_assert_operator_equal, and pwiz::msdata::Serializer_MGF::write().

Referenced by test().

◆ testModeMetaDataAndBinaryData()

void testModeMetaDataAndBinaryData ( )

Definition at line 316 of file SpectrumListCacheTest.cpp.

317 {
318  // initialize list
319  MSData msd;
320  shared_ptr<SpectrumListSimple> sl(new SpectrumListSimple);
321  sl->spectra.push_back(makeSpectrumPtr(0, "S1"));
322  sl->spectra.push_back(makeSpectrumPtr(1, "S2"));
323  sl->spectra.push_back(makeSpectrumPtr(2, "S3"));
324  sl->spectra.push_back(makeSpectrumPtr(3, "S4"));
325  msd.run.spectrumListPtr = sl;
326 
327  // SpectrumListSimple returns the same shared_ptrs regardless of caching;
328  // serializing to MGF and back will produce different shared_ptrs
329  boost::shared_ptr<stringstream> ss(new stringstream);
330  Serializer_MGF serializer;
331  serializer.write(*ss, msd, 0);
332  serializer.read(ss, msd);
333 
334  // access a series of spectra and make sure the cache behaves appropriately:
335  // in metadata-and-binary-data mode, entries in the cache should:
336  // - always have metadata
337  // - always have binary data
338 
339  SpectrumPtr s;
340 
341  SpectrumListCache slc(msd.run.spectrumListPtr, MemoryMRUCacheMode_MetaDataAndBinaryData, 2);
342  SpectrumListCache::CacheType& cache = slc.spectrumCache();
343 
344  unit_assert(cache.empty());
346 
347  // metadata-only access should not affect the cache
348  s = slc.spectrum(0, false);
349 
350  if (os_) *os_ << cache << endl;
351  unit_assert(cache.empty());
352  unit_assert_operator_equal(0, cache.size());
353 
354  s = slc.spectrum(1, true);
355 
356  // pointers should be equal
357  unit_assert_operator_equal(slc.spectrum(1, true), s);
358 
359  if (os_) *os_ << cache << endl;
360  unit_assert_operator_equal(1, cache.size());
361  unit_assert_operator_equal(1, cache.mru().spectrum->index);
362  unit_assert(spectrumHasMetadata(*cache.mru().spectrum));
363  unit_assert(spectrumHasBinaryData(*cache.mru().spectrum));
364 
365  s = slc.spectrum(2, false);
366 
367  if (os_) *os_ << cache << endl;
368  unit_assert_operator_equal(1, cache.size());
369  unit_assert_operator_equal(1, cache.mru().spectrum->index);
370  unit_assert(spectrumHasMetadata(*cache.mru().spectrum));
371  unit_assert(spectrumHasBinaryData(*cache.mru().spectrum));
372 
373  s = slc.spectrum(3, true);
374 
375  // pointers should be equal
376  unit_assert_operator_equal(slc.spectrum(3, true), s);
377 
378  if (os_) *os_ << cache << endl;
379  unit_assert_operator_equal(2, cache.size());
380  unit_assert_operator_equal(3, cache.mru().spectrum->index);
381  unit_assert(spectrumHasMetadata(*cache.mru().spectrum));
382  unit_assert(spectrumHasBinaryData(*cache.mru().spectrum));
383  unit_assert_operator_equal(1, cache.lru().spectrum->index);
384  unit_assert(spectrumHasMetadata(*cache.lru().spectrum));
385  unit_assert(spectrumHasBinaryData(*cache.lru().spectrum));
386 
387  s = slc.spectrum(2, true);
388 
389  if (os_) *os_ << cache << endl;
390  unit_assert_operator_equal(2, cache.size());
391  unit_assert_operator_equal(2, cache.mru().spectrum->index);
392  unit_assert(spectrumHasMetadata(*cache.mru().spectrum));
393  unit_assert(spectrumHasBinaryData(*cache.mru().spectrum));
394  unit_assert_operator_equal(3, cache.lru().spectrum->index);
395  unit_assert(spectrumHasMetadata(*cache.lru().spectrum));
396  unit_assert(spectrumHasBinaryData(*cache.lru().spectrum));
397 }

References pwiz::util::mru_list< Item, KeyExtractor >::empty(), pwiz::util::mru_list< Item, KeyExtractor >::lru(), makeSpectrumPtr(), pwiz::util::mru_list< Item, KeyExtractor >::max_size(), pwiz::util::mru_list< Item, KeyExtractor >::mru(), os_, pwiz::msdata::Serializer_MGF::read(), pwiz::msdata::MSData::run, pwiz::util::mru_list< Item, KeyExtractor >::size(), pwiz::msdata::SpectrumListCache::spectrum(), pwiz::msdata::SpectrumListCache::spectrumCache(), spectrumHasBinaryData(), spectrumHasMetadata(), pwiz::msdata::Run::spectrumListPtr, unit_assert, unit_assert_operator_equal, and pwiz::msdata::Serializer_MGF::write().

Referenced by test().

◆ testFileReads()

void testFileReads ( const char *  filename)

Definition at line 399 of file SpectrumListCacheTest.cpp.

399  {
400  std::string srcparent(__FILE__); // locate test data relative to this source file
401  // something like \ProteoWizard\pwiz\pwiz\data\msdata\SpectrumListCacheTest.cpp
402  size_t pos = srcparent.rfind("pwiz");
403  srcparent.resize(pos);
404  std::string example_data_dir = srcparent + "example_data/";
405  pwiz::msdata::MSDataFile msd1(example_data_dir + filename);
406  SpectrumListCache cache(msd1.run.spectrumListPtr, MemoryMRUCacheMode_MetaDataOnly, 2);
407  pwiz::msdata::MSDataFile msd2(example_data_dir + filename);
408  // test logic for efficient delayed read of binary data -
409  // we try to avoid reparsing the header since we have that cached
410  // mzML and mzXML readers can do this, others could probably be made to
411  int index = 3;
412  SpectrumPtr s=msd2.run.spectrumListPtr->spectrum(index, false);
413  SpectrumPtr c=cache.spectrum(index, false);
414  unit_assert(*s==*c);
415  unit_assert(!s->hasBinaryData());
416  unit_assert(!c->hasBinaryData());
417  s=msd2.run.spectrumListPtr->spectrum(index, true);
418  c=cache.spectrum(index, true);
419  unit_assert(*s==*c);
420  unit_assert(s->hasBinaryData());
421  unit_assert(c->hasBinaryData());
422  unit_assert(s->binaryDataArrayPtrs[0]->data[0]==
423  c->binaryDataArrayPtrs[0]->data[0]);
424  unit_assert(!s->binaryDataArrayPtrs[1]->data.empty());
425  unit_assert(!c->binaryDataArrayPtrs[1]->data.empty());
426  unit_assert(s->binaryDataArrayPtrs[1]->data[0]==
427  c->binaryDataArrayPtrs[1]->data[0]);
428 }

References MemoryMRUCacheMode_MetaDataOnly, pwiz::msdata::MSData::run, pwiz::msdata::SpectrumListCache::spectrum(), pwiz::msdata::Run::spectrumListPtr, and unit_assert.

Referenced by test().

◆ test()

void test ( )

Definition at line 431 of file SpectrumListCacheTest.cpp.

432 {
434  testModeOff();
438  // check the delayed-binary-read
439  // logic for mzML and mzXML readers
440  testFileReads("tiny.pwiz.mzXML");
441  testFileReads("tiny.pwiz.1.0.mzML");
442  testFileReads("tiny.pwiz.1.1.mzML");
443 }

References testFileReads(), testMemoryMRUCache(), testModeBinaryDataOnly(), testModeMetaDataAndBinaryData(), testModeMetaDataOnly(), and testModeOff().

Referenced by main().

◆ main()

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

Definition at line 446 of file SpectrumListCacheTest.cpp.

447 {
448  TEST_PROLOG(argc, argv)
449 
450  try
451  {
452  if (argc>1 && !strcmp(argv[1],"-v")) os_ = &cout;
453  test();
454  }
455  catch (exception& e)
456  {
457  TEST_FAILED(e.what())
458  }
459  catch (...)
460  {
461  TEST_FAILED("Caught unknown exception.")
462  }
463 
465 }

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

Variable Documentation

◆ os_

ostream* os_ = 0
testModeOff
void testModeOff()
Definition: SpectrumListCacheTest.cpp:122
MS_number_of_detector_counts
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:741
pwiz::msdata::SpectrumListCache::CacheEntry
a cache mapping spectrum indices to SpectrumPtrs
Definition: SpectrumListCache.hpp:42
pwiz::msdata::Spectrum
The structure that captures the generation of a peak list (including the underlying acquisitions)
Definition: MSData.hpp:505
testModeBinaryDataOnly
void testModeBinaryDataOnly()
Definition: SpectrumListCacheTest.cpp:237
pwiz::data::ParamContainer::userParams
std::vector< UserParam > userParams
a collection of uncontrolled user terms
Definition: ParamTypes.hpp:253
pwiz::util::BinaryData::size
size_t size() const
Definition: BinaryData.hpp:145
MS_MSn_spectrum
MS_MSn_spectrum
MSn spectrum: MSn refers to multi-stage MS2 experiments designed to record product ion spectra where ...
Definition: cv.hpp:2364
makeSpectrumPtr
SpectrumPtr makeSpectrumPtr(size_t index, const string &id)
Definition: SpectrumListCacheTest.cpp:86
testFileReads
void testFileReads(const char *filename)
Definition: SpectrumListCacheTest.cpp:399
pwiz::msdata::MSData::run
Run run
a run in mzML should correspond to a single, consecutive and coherent set of scans on an instrument.
Definition: MSData.hpp:886
pwiz::util::mru_list::end
iterator end()
Definition: mru_list.hpp:100
test
void test()
Definition: SpectrumListCacheTest.cpp:431
pwiz::msdata::BinaryDataArray::data
pwiz::util::BinaryData< double > data
the binary data.
Definition: MSData.hpp:410
pwiz::msdata::Serializer_MGF
MSData <-> MGF stream serialization.
Definition: Serializer_MGF.hpp:37
unit_assert_operator_equal
#define unit_assert_operator_equal(expected, actual)
Definition: unit.hpp:92
testModeMetaDataOnly
void testModeMetaDataOnly()
Definition: SpectrumListCacheTest.cpp:151
pwiz::msdata::Serializer_MGF::read
void read(boost::shared_ptr< std::istream > is, MSData &msd) const
read in MSData object from an MGF istream note: istream may be managed by MSData's SpectrumList,...
pwiz::msdata::ScanList::empty
bool empty() const
pwiz::msdata::MemoryMRUCache< CacheEntry, BOOST_MULTI_INDEX_MEMBER(CacheEntry, size_t, index) >
MemoryMRUCacheMode_BinaryDataOnly
MemoryMRUCacheMode_BinaryDataOnly
Definition: MemoryMRUCache.hpp:38
testMemoryMRUCache
void testMemoryMRUCache()
Definition: SpectrumListCacheTest.cpp:53
pwiz::util::mru_list::begin
iterator begin()
Definition: mru_list.hpp:99
pwiz::msdata::Spectrum::sourceFilePtr
SourceFilePtr sourceFilePtr
this attribute can optionally reference the 'id' of the appropriate sourceFile.
Definition: MSData.hpp:514
pwiz::util::mru_list::max_size
std::size_t max_size() const
Definition: mru_list.hpp:93
TEST_EPILOG
#define TEST_EPILOG
Definition: unit.hpp:183
pwiz::msdata::Spectrum::dataProcessingPtr
DataProcessingPtr dataProcessingPtr
this attribute can optionally reference the 'id' of the appropriate dataProcessing.
Definition: MSData.hpp:511
MemoryMRUCacheMode_MetaDataOnly
MemoryMRUCacheMode_MetaDataOnly
Definition: MemoryMRUCache.hpp:37
os_
ostream * os_
Definition: SpectrumListCacheTest.cpp:37
pwiz::util::BinaryData::push_back
void push_back(const T &value)
Definition: BinaryData.hpp:362
pwiz::msdata::SpectrumPtr
boost::shared_ptr< Spectrum > SpectrumPtr
Definition: MSData.hpp:573
pwiz::util::mru_list::lru
const item_type & lru() const
Definition: mru_list.hpp:97
pwiz::msdata::SpectrumListSimple
Simple writeable in-memory implementation of SpectrumList.
Definition: MSData.hpp:716
pwiz::msdata::Spectrum::scanList
ScanList scanList
list of scans
Definition: MSData.hpp:517
pwiz::msdata::Run::spectrumListPtr
SpectrumListPtr spectrumListPtr
all mass spectra and the acquisitions underlying them are described and attached here....
Definition: MSData.hpp:827
TEST_FAILED
#define TEST_FAILED(x)
Definition: unit.hpp:177
TEST_PROLOG
#define TEST_PROLOG(argc, argv)
Definition: unit.hpp:175
MS_ms_level
MS_ms_level
ms level: Stages of ms achieved in a multi stage mass spectrometry experiment.
Definition: cv.hpp:2139
pwiz::msdata::BinaryDataArray
The structure into which encoded binary data goes. Byte ordering is always little endian (Intel style...
Definition: MSData.hpp:404
MemoryMRUCacheMode_Off
MemoryMRUCacheMode_Off
Definition: MemoryMRUCache.hpp:36
pwiz::msdata::MSDataFile
MSData object plus file I/O.
Definition: MSDataFile.hpp:40
testModeMetaDataAndBinaryData
void testModeMetaDataAndBinaryData()
Definition: SpectrumListCacheTest.cpp:316
pwiz::data::ParamContainer::paramGroupPtrs
std::vector< ParamGroupPtr > paramGroupPtrs
a collection of references to ParamGroups
Definition: ParamTypes.hpp:247
pwiz::msdata::Spectrum::precursors
std::vector< Precursor > precursors
list and descriptions of precursors to the spectrum currently being described.
Definition: MSData.hpp:520
pwiz::msdata::MSData
This is the root element of ProteoWizard; it represents the mzML element, defined as: intended to cap...
Definition: MSData.hpp:849
spectrumHasBinaryData
bool spectrumHasBinaryData(const Spectrum &s)
Definition: SpectrumListCacheTest.cpp:117
pwiz::util::mru_list::mru
const item_type & mru() const
Definition: mru_list.hpp:96
pwiz::util::mru_list::size
std::size_t size() const
Definition: mru_list.hpp:92
pwiz::msdata::Serializer_MGF::write
void write(std::ostream &os, const MSData &msd, const pwiz::util::IterationListenerRegistry *iterationListenerRegistry=0) const
write MSData object to ostream as MGF; iterationListenerRegistry may be used to receive progress upda...
unit_assert
#define unit_assert(x)
Definition: unit.hpp:85
pwiz::msdata::Precursor
The method of precursor ion selection and activation.
Definition: MSData.hpp:311
pwiz::util::mru_list::empty
bool empty() const
Definition: mru_list.hpp:91
pwiz::msdata::SpectrumListCache
adds a level of flexible MRU caching to a SpectrumList processor chain
Definition: SpectrumListCache.hpp:37
spectrumHasMetadata
bool spectrumHasMetadata(const Spectrum &s)
Definition: SpectrumListCacheTest.cpp:106
pwiz::msdata::Spectrum::hasBinaryData
bool hasBinaryData() const
returns true iff has nonnull and nonempty BinaryDataArrayPtr
Definition: MSData.hpp:535
pwiz::data::ParamContainer::cvParams
std::vector< CVParam > cvParams
a collection of controlled vocabulary terms
Definition: ParamTypes.hpp:250