ProteoWizard
Functions | Variables
PeakDataTest.cpp File Reference
#include "PeakData.hpp"
#include "pwiz/utility/misc/unit.hpp"
#include <boost/filesystem/operations.hpp>
#include "pwiz/utility/misc/Std.hpp"

Go to the source code of this file.

Functions

PeakFamily initializePeakFamily ()
 
Scan initializeScan ()
 
Software initializeSoftware ()
 
PeakData initializePeakData ()
 
PeakelPtr initializePeakel ()
 
void testPeakEquality ()
 
void testPeak ()
 
void testPeakFamily ()
 
void testScan ()
 
void testSoftware ()
 
void testPeakData ()
 
void testPeakel ()
 
void testPeakelAux ()
 
void testPeakelConstruction ()
 
void testFeature ()
 
void testFeatureAux ()
 
void test ()
 
int main (int argc, char *argv[])
 

Variables

ostream * os_ = 0
 

Function Documentation

◆ initializePeakFamily()

PeakFamily initializePeakFamily ( )

Definition at line 38 of file PeakDataTest.cpp.

39 {
40  PeakFamily peakFamily;
41 
42  peakFamily.mzMonoisotopic = 329.86;
43  peakFamily.charge = 3;
44  peakFamily.score = 0.11235811;
45 
46  Peak peak;
47  Peak a;
48  Peak boo;
49 
50  peak.mz = 329.86;
51  a.mz = 109.87;
52  boo.mz = 6.022141730;
53 
54  peakFamily.peaks.push_back(peak);
55  peakFamily.peaks.push_back(a);
56  peakFamily.peaks.push_back(boo);
57 
58  return peakFamily;
59 
60 }

References pwiz::data::peakdata::PeakFamily::charge, pwiz::data::peakdata::Peak::mz, pwiz::data::peakdata::PeakFamily::mzMonoisotopic, pwiz::data::peakdata::PeakFamily::peaks, and pwiz::data::peakdata::PeakFamily::score.

Referenced by initializePeakel(), initializeScan(), and testPeakFamily().

◆ initializeScan()

Scan initializeScan ( )

◆ initializeSoftware()

Software initializeSoftware ( )

Definition at line 83 of file PeakDataTest.cpp.

84 {
85  Software software;
86  software.name = "World of Warcraft";
87  software.version = "Wrath of the Lich King";
88  software.source = "Blizzard Entertainment";
89 
90  Software::Parameter parameter1("Burke ping","level 70");
91  Software::Parameter parameter2("Kate ping", "level 0");
92 
93  software.parameters.push_back(parameter1);
94  software.parameters.push_back(parameter2);
95 
96  return software;
97 
98 }

References pwiz::data::peakdata::Software::name, pwiz::data::peakdata::Software::parameters, pwiz::data::peakdata::Software::source, and pwiz::data::peakdata::Software::version.

Referenced by initializePeakData(), and testSoftware().

◆ initializePeakData()

PeakData initializePeakData ( )

Definition at line 100 of file PeakDataTest.cpp.

101 {
102  PeakData pd;
103 
104  Software software = initializeSoftware();
105  pd.software = software;
106 
107  Scan scan = initializeScan();
108 
109  pd.scans.push_back(scan);
110  pd.scans.push_back(scan);
111 
112  return pd;
113 
114 }

References initializeScan(), initializeSoftware(), pwiz::data::peakdata::PeakData::scans, and pwiz::data::peakdata::PeakData::software.

Referenced by testPeakData().

◆ initializePeakel()

PeakelPtr initializePeakel ( )

Definition at line 116 of file PeakDataTest.cpp.

117 {
118  PeakelPtr pkl(new Peakel);
119  pkl->mz = 432.1;
120  pkl->retentionTime = 1234.56;
121  pkl->maxIntensity = 9876.54;
122  pkl->totalIntensity = 32123.45;
123  pkl->mzVariance = 6.023;
124 
125  PeakFamily peakFamily = initializePeakFamily();
126 
127  pkl->peaks = peakFamily.peaks;
128 
129  return pkl;
130 }

References initializePeakFamily(), and pwiz::data::peakdata::PeakFamily::peaks.

Referenced by testFeature(), and testPeakel().

◆ testPeakEquality()

void testPeakEquality ( )

Definition at line 133 of file PeakDataTest.cpp.

134 {
135  if (os_) *os_ << "testPeakEquality()" <<endl;
136 
137  Peak peak;
138 
139  peak.id = 5;
140  peak.mz = 1;
141  peak.retentionTime = 1.5;
142  peak.intensity = 2;
143  peak.area = 3;
144  peak.error = 4;
145 
146  Peak peak2 = peak;
147 
148  unit_assert(peak == peak2);
149  peak.attributes[Peak::Attribute_Phase] = 4.20;
150  unit_assert(peak != peak2);
151  peak2.attributes[Peak::Attribute_Phase] = 4.20;
152  peak2.attributes[Peak::Attribute_Decay] = 6.66;
153  unit_assert(peak != peak2);
154  peak.attributes[Peak::Attribute_Decay] = 6.66;
155  unit_assert(peak == peak2);
156 }

References pwiz::data::peakdata::Peak::area, pwiz::data::peakdata::Peak::attributes, pwiz::data::peakdata::Peak::error, pwiz::data::peakdata::Peak::id, pwiz::data::peakdata::Peak::intensity, pwiz::data::peakdata::Peak::mz, os_, pwiz::data::peakdata::Peak::retentionTime, and unit_assert.

Referenced by test().

◆ testPeak()

void testPeak ( )

Definition at line 159 of file PeakDataTest.cpp.

160 {
161  if (os_) *os_ << "testPeak()" <<endl;
162 
163  // instantiate a Peak
164 
165  Peak peak;
166 
167  peak.id = 5;
168  peak.mz = 1;
169  peak.retentionTime = 1.5;
170  peak.intensity = 2;
171  peak.area = 3;
172  peak.error = 4;
173 
174  peak.data.push_back(OrderedPair(1,2));
175  peak.data.push_back(OrderedPair(3,4));
176 
177  peak.attributes[Peak::Attribute_Frequency] = 5;
178  peak.attributes[Peak::Attribute_Phase] = 6;
179  peak.attributes[Peak::Attribute_Decay] = 7;
180 
181  if (os_) *os_ << peak << endl;
182 
183  // write out XML to a stream
184 
185  ostringstream oss;
186  XMLWriter writer(oss);
187  peak.write(writer);
188 
189  // allocate a new Peak
190 
191  Peak peakIn;
192  unit_assert(peak != peakIn);
193 
194  // read from stream into new Peak
195 
196  istringstream iss(oss.str());
197  peakIn.read(iss);
198  if (os_) *os_ << peakIn << endl;
199 
200  // verify that new Peak is the same as old Peak
201 
202  unit_assert(peak == peakIn);
203 }

References pwiz::data::peakdata::Peak::area, pwiz::data::peakdata::Peak::attributes, pwiz::data::peakdata::Peak::data, pwiz::data::peakdata::Peak::error, pwiz::data::peakdata::Peak::id, pwiz::data::peakdata::Peak::intensity, pwiz::data::peakdata::Peak::mz, os_, pwiz::data::peakdata::Peak::read(), pwiz::data::peakdata::Peak::retentionTime, unit_assert, and pwiz::data::peakdata::Peak::write().

Referenced by test().

◆ testPeakFamily()

void testPeakFamily ( )

Definition at line 206 of file PeakDataTest.cpp.

207 {
208  // initialize a PeakFamily
209 
210  PeakFamily jetsons = initializePeakFamily();
211 
212  // write out XML to a stream
213 
214  ostringstream oss;
215  XMLWriter writer(oss);
216 
217 
218  jetsons.write(writer);
219 
220  // instantiate new PeakFamily
221 
222  PeakFamily flintstones;
223 
224  // read from stream into new PeakFamily
225  istringstream iss(oss.str());
226  flintstones.read(iss);
227 
228  // verify that new PeakFamily is the same as old PeakFamily
229 
230  unit_assert(flintstones == jetsons);
231  if (os_) *os_ << "Testing PeakFamily ... " << endl << oss.str() <<endl;
232 }

References initializePeakFamily(), os_, pwiz::data::peakdata::PeakFamily::read(), unit_assert, and pwiz::data::peakdata::PeakFamily::write().

Referenced by test().

◆ testScan()

void testScan ( )

Definition at line 234 of file PeakDataTest.cpp.

235 {
236  // initialize a new Scan
237 
238  Scan scan = initializeScan();
239 
240  // write out XML to a stream
241  ostringstream oss_scan;
242  XMLWriter writer_scan(oss_scan);
243  scan.write(writer_scan);
244 
245  // instantiate a second Scan
246  Scan scan2;
247 
248  // read it back in
249  istringstream iss_scan(oss_scan.str());
250  scan2.read(iss_scan);
251 
252 
253 
254  // assert that the two Scans are equal
255 
256  unit_assert(scan == scan2);
257  if (os_) *os_ << "Testing Scan ... " << endl << oss_scan.str() << endl;
258 
259 }

References initializeScan(), os_, pwiz::data::peakdata::Scan::read(), unit_assert, and pwiz::data::peakdata::Scan::write().

Referenced by test().

◆ testSoftware()

void testSoftware ( )

Definition at line 261 of file PeakDataTest.cpp.

262 {
263  // initialize a new Software
264 
265  Software software = initializeSoftware();
266 
267  // write out XML to a stream
268  ostringstream oss_soft;
269  XMLWriter writer_soft(oss_soft);
270  software.write(writer_soft);
271 
272  // instantiate another Software
273  Software software2;
274 
275  // read it back in
276  istringstream iss_soft(oss_soft.str());
277  software2.read(iss_soft);
278 
279  // assert that the two Softwares are equal
280 
281  unit_assert(software == software2);
282  if (os_) *os_ << "Testing Software ... " << endl << oss_soft.str() <<endl;
283 
284 }

References initializeSoftware(), os_, pwiz::data::peakdata::Software::read(), unit_assert, and pwiz::data::peakdata::Software::write().

Referenced by test().

◆ testPeakData()

void testPeakData ( )

Definition at line 286 of file PeakDataTest.cpp.

287 {
288  // initialize a PeakData
289 
291 
292  ostringstream oss_pd;
293  XMLWriter writer_pd(oss_pd);
294  pd.write(writer_pd);
295 
296  // instantiate another PeakData
297 
298  PeakData pd2;
299 
300  // read into it
301 
302  istringstream iss_pd(oss_pd.str());
303  pd2.read(iss_pd);
304 
305  // assert that the two PeakData are equal
306 
307  unit_assert(pd == pd2);
308  if (os_) *os_ << "Testing PeakData ... " << endl << oss_pd.str()<<endl;
309 
310 }

References initializePeakData(), os_, pwiz::data::peakdata::PeakData::read(), unit_assert, and pwiz::data::peakdata::PeakData::write().

Referenced by test().

◆ testPeakel()

void testPeakel ( )

Definition at line 312 of file PeakDataTest.cpp.

313 {
314  // initialize a peakel
315 
316  PeakelPtr dill = initializePeakel();
317 
318  // write it out
319  ostringstream oss_pkl;
320  XMLWriter writer_pkl(oss_pkl);
321  dill->write(writer_pkl);
322 
323  // instantiate another Peakel
324 
325  Peakel gherkin;
326 
327  // read into it
328  istringstream iss_pkl(oss_pkl.str());
329  gherkin.read(iss_pkl);
330 
331  // assert that the two Peakels are equal
332 
333  unit_assert(*dill == gherkin);
334  if (os_) *os_ << "Testing Peakel ... " << endl << oss_pkl.str() << endl;
335 }

References initializePeakel(), os_, pwiz::data::peakdata::Peakel::read(), and unit_assert.

Referenced by test().

◆ testPeakelAux()

void testPeakelAux ( )

Definition at line 338 of file PeakDataTest.cpp.

339 {
340  Peakel p;
341  p.retentionTime = 420;
342  unit_assert(p.retentionTimeMin() == 420);
343  unit_assert(p.retentionTimeMax() == 420);
344 
345  p.peaks.resize(2);
346  p.peaks[0].retentionTime = 666;
347  p.peaks[1].retentionTime = 667;
348  unit_assert(p.retentionTimeMin() == 666);
349  unit_assert(p.retentionTimeMax() == 667);
350 }

References pwiz::data::peakdata::Peakel::peaks, pwiz::data::peakdata::Peakel::retentionTime, pwiz::data::peakdata::Peakel::retentionTimeMax(), pwiz::data::peakdata::Peakel::retentionTimeMin(), and unit_assert.

Referenced by test().

◆ testPeakelConstruction()

void testPeakelConstruction ( )

Definition at line 353 of file PeakDataTest.cpp.

354 {
355  Peak peak(420, 666);
356  Peakel peakel(Peak(420,666));
357  unit_assert(peakel.mz == 420);
358  unit_assert(peakel.retentionTime == 666);
359  unit_assert(peakel.peaks.size() == 1);
360  unit_assert(peakel.peaks[0] == peak);
361 }

References pwiz::data::peakdata::Peakel::mz, pwiz::data::peakdata::Peakel::peaks, pwiz::data::peakdata::Peakel::retentionTime, and unit_assert.

Referenced by test().

◆ testFeature()

void testFeature ( )

Definition at line 364 of file PeakDataTest.cpp.

365 {
366  // initialize a new Feature
367 
368  Feature feature;
369  feature.mz = 1863.0101;
370  feature.retentionTime = 1492.1012;
371  feature.charge = 3;
372  feature.totalIntensity = 1776.0704;
373  feature.rtVariance = 1969.0720;
374  feature.score = 420.0;
375  feature.error = 666.0;
376 
377  PeakelPtr stateFair = initializePeakel();
378  PeakelPtr deli = initializePeakel();
379 
380  feature.peakels.push_back(stateFair);
381  feature.peakels.push_back(deli);
382 
383  // write it out
384  ostringstream oss_f;
385  XMLWriter writer_f(oss_f);
386  feature.write(writer_f);
387 
388  // instantiate another feature
389 
390  Feature feature2;
391 
392  // read into it
393 
394  istringstream iss(oss_f.str());
395  feature2.read(iss);
396 
397  // assert that the two Features are equal
398 
399  if (os_)
400  {
401  *os_ << "Testing Feature ... " << endl << oss_f.str() << endl;
402  *os_ << "feature2:\n";
403  XMLWriter writer(*os_);
404  feature2.write(writer);
405  }
406 
407  unit_assert(feature == feature2);
408 }

References pwiz::data::peakdata::Feature::charge, pwiz::data::peakdata::Feature::error, initializePeakel(), pwiz::data::peakdata::Feature::mz, os_, pwiz::data::peakdata::Feature::peakels, pwiz::data::peakdata::Feature::read(), pwiz::data::peakdata::Feature::retentionTime, pwiz::data::peakdata::Feature::rtVariance, pwiz::data::peakdata::Feature::score, pwiz::data::peakdata::Feature::totalIntensity, unit_assert, and pwiz::data::peakdata::Feature::write().

Referenced by test().

◆ testFeatureAux()

void testFeatureAux ( )

Definition at line 411 of file PeakDataTest.cpp.

412 {
413  Feature feature;
414  feature.retentionTime = 420;
415  unit_assert(feature.retentionTimeMin() == 420);
416  unit_assert(feature.retentionTimeMax() == 420);
417 
418  // retention time ranges determined by first two peakels
419 
420  PeakelPtr dill(new Peakel);
421  dill->peaks.push_back(Peak(666,419));
422  dill->peaks.push_back(Peak(666,423));
423 
424  PeakelPtr sweet(new Peakel);
425  sweet->peaks.push_back(Peak(666,421));
426  sweet->peaks.push_back(Peak(666,424));
427 
428  PeakelPtr gherkin(new Peakel);
429  gherkin->peaks.push_back(Peak(666,418));
430  gherkin->peaks.push_back(Peak(666,425));
431 
432  feature.peakels.push_back(dill);
433  feature.peakels.push_back(sweet);
434  feature.peakels.push_back(gherkin);
435 
436  unit_assert(feature.retentionTimeMin() == 419);
437  unit_assert(feature.retentionTimeMax() == 424);
438 }

References pwiz::data::peakdata::Feature::peakels, pwiz::data::peakdata::Feature::retentionTime, pwiz::data::peakdata::Feature::retentionTimeMax(), pwiz::data::peakdata::Feature::retentionTimeMin(), and unit_assert.

Referenced by test().

◆ test()

void test ( )

◆ main()

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

Definition at line 458 of file PeakDataTest.cpp.

459 {
460  TEST_PROLOG(argc, argv)
461 
462  try
463  {
464  if (argc>1 && !strcmp(argv[1],"-v")) os_ = &cout;
465  if (os_) *os_ << "PeakDataTest\n";
466 
467  test();
468  }
469  catch (exception& e)
470  {
471  TEST_FAILED(e.what())
472  }
473  catch (...)
474  {
475  TEST_FAILED("Caught unknown exception.")
476  }
477 
479 }

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

Variable Documentation

◆ os_

ostream* os_ = 0
pwiz::data::peakdata::Feature::retentionTime
double retentionTime
Definition: PeakData.hpp:268
pwiz::data::peakdata::Peak::data
std::vector< pwiz::math::OrderedPair > data
Definition: PeakData.hpp:63
pwiz::data::peakdata::PeakData
Definition: PeakData.hpp:190
pwiz::minimxml::XMLWriter
The XMLWriter class provides simple, tag-level XML syntax writing.
Definition: XMLWriter.hpp:47
pwiz::data::peakdata::Peak::error
double error
Definition: PeakData.hpp:61
initializeSoftware
Software initializeSoftware()
Definition: PeakDataTest.cpp:83
pwiz::data::peakdata::Peakel::retentionTimeMin
double retentionTimeMin() const
pwiz::data::peakdata::Peak
Definition: PeakData.hpp:52
pwiz::data::peakdata::Peakel::retentionTime
double retentionTime
Definition: PeakData.hpp:215
pwiz::data::peakdata::Feature::mz
double mz
Definition: PeakData.hpp:267
pwiz::data::peakdata::Feature::score
double score
Definition: PeakData.hpp:272
testPeakel
void testPeakel()
Definition: PeakDataTest.cpp:312
pwiz::data::peakdata::PeakFamily::write
void write(minimxml::XMLWriter &writer) const
initializeScan
Scan initializeScan()
Definition: PeakDataTest.cpp:62
pwiz::data::peakdata::Scan::retentionTime
double retentionTime
Definition: PeakData.hpp:139
pwiz::data::peakdata::Software::parameters
std::vector< Parameter > parameters
Definition: PeakData.hpp:179
pwiz::data::peakdata::Feature::retentionTimeMax
double retentionTimeMax() const
pwiz::data::peakdata::Peak::id
int id
Definition: PeakData.hpp:54
testSoftware
void testSoftware()
Definition: PeakDataTest.cpp:261
pwiz::data::peakdata::PeakFamily
Definition: PeakData.hpp:111
pwiz::data::peakdata::Software
Definition: PeakData.hpp:158
pwiz::data::peakdata::Scan::observationDuration
double observationDuration
Definition: PeakData.hpp:140
pwiz::data::peakdata::Scan
Definition: PeakData.hpp:134
pwiz::data::peakdata::Peakel::retentionTimeMax
double retentionTimeMax() const
pwiz::data::peakdata::Scan::nativeID
std::string nativeID
Definition: PeakData.hpp:137
test
void test()
Definition: PeakDataTest.cpp:441
testPeakelAux
void testPeakelAux()
Definition: PeakDataTest.cpp:338
pwiz::data::peakdata::Feature::error
double error
Definition: PeakData.hpp:273
pwiz::data::peakdata::Peakel
struct for an eluted peak (PEAK ELution)
Definition: PeakData.hpp:211
pwiz::data::peakdata::Software::write
void write(minimxml::XMLWriter &xmlWriter) const
pwiz::data::peakdata::Peakel::read
void read(std::istream &is)
pwiz::data::peakdata::PeakFamily::peaks
std::vector< Peak > peaks
Definition: PeakData.hpp:116
TEST_EPILOG
#define TEST_EPILOG
Definition: unit.hpp:183
testScan
void testScan()
Definition: PeakDataTest.cpp:234
pwiz::data::peakdata::Peak::intensity
double intensity
Definition: PeakData.hpp:59
initializePeakFamily
PeakFamily initializePeakFamily()
Definition: PeakDataTest.cpp:38
pwiz::data::peakdata::PeakelPtr
boost::shared_ptr< Peakel > PeakelPtr
Definition: PeakData.hpp:242
pwiz::data::CalibrationParameters::A
double A
Definition: CalibrationParameters.hpp:47
testPeakFamily
void testPeakFamily()
Definition: PeakDataTest.cpp:206
testPeakData
void testPeakData()
Definition: PeakDataTest.cpp:286
testPeakEquality
void testPeakEquality()
Definition: PeakDataTest.cpp:133
pwiz::data::peakdata::Scan::read
void read(std::istream &is)
pwiz::data::peakdata::Peak::retentionTime
double retentionTime
Definition: PeakData.hpp:57
pwiz::data::peakdata::Peak::mz
double mz
Definition: PeakData.hpp:56
pwiz::data::peakdata::Software::name
std::string name
Definition: PeakData.hpp:161
pwiz::data::peakdata::Scan::peakFamilies
std::vector< PeakFamily > peakFamilies
Definition: PeakData.hpp:142
pwiz::data::peakdata::Scan::write
void write(minimxml::XMLWriter &writer) const
pwiz::data::peakdata::Software::version
std::string version
Definition: PeakData.hpp:162
pwiz::data::peakdata::PeakFamily::score
double score
Definition: PeakData.hpp:115
pwiz::data::peakdata::Feature::charge
int charge
Definition: PeakData.hpp:269
TEST_FAILED
#define TEST_FAILED(x)
Definition: unit.hpp:177
pwiz::data::peakdata::PeakFamily::read
void read(std::istream &is)
TEST_PROLOG
#define TEST_PROLOG(argc, argv)
Definition: unit.hpp:175
pwiz::data::peakdata::Feature
Definition: PeakData.hpp:261
pwiz::data::peakdata::Peak::write
void write(minimxml::XMLWriter &writer) const
testPeakelConstruction
void testPeakelConstruction()
Definition: PeakDataTest.cpp:353
pwiz::data::peakdata::PeakData::software
Software software
Definition: PeakData.hpp:193
pwiz::data::CalibrationParameters::B
double B
Definition: CalibrationParameters.hpp:48
pwiz::data::peakdata::PeakFamily::charge
int charge
Definition: PeakData.hpp:114
os_
ostream * os_
Definition: PeakDataTest.cpp:36
pwiz::data::peakdata::Feature::read
void read(std::istream &is)
pwiz::data::peakdata::Software::source
std::string source
Definition: PeakData.hpp:163
pwiz::data::peakdata::Feature::retentionTimeMin
double retentionTimeMin() const
pwiz::data::peakdata::Peak::read
void read(std::istream &is)
pwiz::data::peakdata::Scan::calibrationParameters
CalibrationParameters calibrationParameters
Definition: PeakData.hpp:141
testFeature
void testFeature()
Definition: PeakDataTest.cpp:364
pwiz::data::peakdata::PeakData::write
void write(pwiz::minimxml::XMLWriter &xmlWriter) const
pwiz::data::peakdata::Peak::area
double area
Definition: PeakData.hpp:60
pwiz::data::peakdata::Scan::index
size_t index
Definition: PeakData.hpp:136
pwiz::data::peakdata::Software::Parameter
Definition: PeakData.hpp:165
pwiz::math::OrderedPair
Definition: OrderedPair.hpp:39
pwiz::data::peakdata::Peakel::peaks
std::vector< Peak > peaks
Definition: PeakData.hpp:221
testPeak
void testPeak()
Definition: PeakDataTest.cpp:159
pwiz::data::peakdata::Feature::rtVariance
double rtVariance
Definition: PeakData.hpp:271
pwiz::data::peakdata::Feature::peakels
std::vector< PeakelPtr > peakels
Definition: PeakData.hpp:274
pwiz::data::peakdata::PeakFamily::mzMonoisotopic
double mzMonoisotopic
Definition: PeakData.hpp:113
pwiz::data::peakdata::PeakData::scans
std::vector< Scan > scans
Definition: PeakData.hpp:194
unit_assert
#define unit_assert(x)
Definition: unit.hpp:85
pwiz::data::peakdata::Scan::scanNumber
int scanNumber
Definition: PeakData.hpp:138
initializePeakData
PeakData initializePeakData()
Definition: PeakDataTest.cpp:100
testFeatureAux
void testFeatureAux()
Definition: PeakDataTest.cpp:411
pwiz::data::peakdata::PeakData::read
void read(std::istream &is)
pwiz::data::peakdata::Peak::attributes
Attributes attributes
Definition: PeakData.hpp:75
pwiz::data::peakdata::Software::read
void read(std::istream &is)
pwiz::data::peakdata::Feature::write
void write(pwiz::minimxml::XMLWriter &xmlWriter) const
initializePeakel
PeakelPtr initializePeakel()
Definition: PeakDataTest.cpp:116
pwiz::data::peakdata::Feature::totalIntensity
double totalIntensity
Definition: PeakData.hpp:270