ProteoWizard
Classes | Functions | Variables
PrecursorRecalculatorDefaultTest.cpp File Reference
#include "PrecursorRecalculatorDefault.hpp"
#include "pwiz/data/msdata/BinaryDataEncoder.hpp"
#include "pwiz/analysis/peakdetect/PeakFamilyDetectorFT.hpp"
#include "pwiz/utility/misc/unit.hpp"
#include "boost/filesystem/path.hpp"
#include "boost/filesystem/fstream.hpp"
#include "pwiz/utility/misc/Std.hpp"

Go to the source code of this file.

Classes

struct  TestInfo
 

Functions

void test ()
 
void test2 ()
 
vector< MZIntensityPairreadData (const bfs::path &filename)
 
shared_ptr< PrecursorRecalculatorDefaultcreatePrecursorRecalculator_msprefix ()
 
void validateRecalculation (const MZIntensityPair *begin, const MZIntensityPair *end, PrecursorRecalculatorDefault &pr, const TestInfo &testInfo)
 
void test5peptide (const bfs::path &datadir)
 
void runSpecialTest (const bfs::path &filename, size_t pairCount, const TestInfo &testInfo)
 
void runTests (const bfs::path &datadir)
 
int main (int argc, char *argv[])
 

Variables

ostream * os_ = 0
 
double testData_ []
 
const size_t testDataSize_ = sizeof(testData_)/sizeof(double)
 
const MZIntensityPairtestDataBegin_ = reinterpret_cast<MZIntensityPair*>(testData_)
 
const MZIntensityPairtestDataEnd_ = reinterpret_cast<MZIntensityPair*>(testData_+testDataSize_)
 

Function Documentation

§ test()

void test ( )

Definition at line 389 of file PrecursorRecalculatorDefaultTest.cpp.

References pwiz::analysis::PeakFamilyDetectorFT::Config::cp, pwiz::analysis::PrecursorRecalculator::PrecursorInfo::mz, pwiz::chemistry::Ion::mz(), pwiz::analysis::PrecursorRecalculatorDefault::Config::mzLeftWidth, pwiz::analysis::PrecursorRecalculatorDefault::Config::mzRightWidth, os_, pwiz::analysis::PrecursorRecalculatorDefault::Config::peakFamilyDetector, pwiz::analysis::PrecursorRecalculatorDefault::recalculate(), pwiz::data::CalibrationParameters::thermo_FT(), unit_assert, and unit_assert_equal.

Referenced by runTests().

390 {
391  if (os_) *os_ << "test()\n" << flush;
392 
393  // instantiate PeakFamilyDetector
394 
395  PeakFamilyDetectorFT::Config pfdftConfig;
396  pfdftConfig.cp = CalibrationParameters::thermo_FT();
397  shared_ptr<PeakFamilyDetector> pfd(new PeakFamilyDetectorFT(pfdftConfig));
398 
399  // instantiate PrecursorRecalculatorDefault
400 
402  config.peakFamilyDetector = pfd;
403  config.mzLeftWidth = 1;
404  config.mzRightWidth = 2.5;
405  PrecursorRecalculatorDefault pr(config);
406 
407  // recalculate
408 
409  PrecursorRecalculator::PrecursorInfo initialEstimate;
410  initialEstimate.mz = 821.92;
411  vector<PrecursorRecalculator::PrecursorInfo> result;
412  pr.recalculate(testDataBegin_, testDataEnd_, initialEstimate, result);
413 
414  // validate result
415 
416  unit_assert(result.size() == 1);
417  unit_assert_equal(result[0].mz, 821.41, 1e-2);
418 }
#define unit_assert_equal(x, y, epsilon)
Definition: unit.hpp:99
FT-specific implementation of PeakFamilyDetector.
const MZIntensityPair * testDataBegin_
double mz(double neutralMass, int protonDelta, int electronDelta=0, int neutronDelta=0)
Definition: Ion.hpp:78
const MZIntensityPair * testDataEnd_
#define unit_assert(x)
Definition: unit.hpp:85

§ test2()

void test2 ( )

Definition at line 421 of file PrecursorRecalculatorDefaultTest.cpp.

References pwiz::analysis::PeakFamilyDetectorFT::Config::cp, pwiz::analysis::PrecursorRecalculator::PrecursorInfo::mz, pwiz::chemistry::Ion::mz(), pwiz::analysis::PrecursorRecalculatorDefault::Config::mzLeftWidth, pwiz::analysis::PrecursorRecalculatorDefault::Config::mzRightWidth, os_, pwiz::analysis::PrecursorRecalculatorDefault::Config::peakFamilyDetector, pwiz::analysis::PrecursorRecalculatorDefault::recalculate(), pwiz::data::CalibrationParameters::thermo_FT(), unit_assert, and unit_assert_equal.

Referenced by runTests().

422 {
423  if (os_) *os_ << "test2()\n" << flush;
424 
425  // instantiate PeakFamilyDetector
426 
427  PeakFamilyDetectorFT::Config pfdftConfig;
428  pfdftConfig.cp = CalibrationParameters::thermo_FT();
429  shared_ptr<PeakFamilyDetector> pfd(new PeakFamilyDetectorFT(pfdftConfig));
430 
431  // instantiate PrecursorRecalculatorDefault
432 
434  config.peakFamilyDetector = pfd;
435  config.mzLeftWidth = 4;
436  config.mzRightWidth = 2.5;
437  PrecursorRecalculatorDefault pr(config);
438 
439  // recalculate
440 
441  PrecursorRecalculator::PrecursorInfo initialEstimate;
442  initialEstimate.mz = 821.92;
443  vector<PrecursorRecalculator::PrecursorInfo> result;
444  pr.recalculate(testDataBegin_, testDataEnd_, initialEstimate, result);
445 
446  // validate result
447 
448  unit_assert(result.size() == 2);
449  unit_assert_equal(result[0].mz, 821.41, 1e-2);
450  unit_assert_equal(result[1].mz, 818.42, 1e-2);
451 }
#define unit_assert_equal(x, y, epsilon)
Definition: unit.hpp:99
FT-specific implementation of PeakFamilyDetector.
const MZIntensityPair * testDataBegin_
double mz(double neutralMass, int protonDelta, int electronDelta=0, int neutronDelta=0)
Definition: Ion.hpp:78
const MZIntensityPair * testDataEnd_
#define unit_assert(x)
Definition: unit.hpp:85

§ readData()

vector<MZIntensityPair> readData ( const bfs::path &  filename)

Definition at line 454 of file PrecursorRecalculatorDefaultTest.cpp.

References pwiz::msdata::BinaryDataEncoder::Config::byteOrder, pwiz::msdata::BinaryDataEncoder::ByteOrder_BigEndian, pwiz::msdata::BinaryDataEncoder::Config::compression, pwiz::msdata::BinaryDataEncoder::Compression_Zlib, pwiz::msdata::BinaryDataEncoder::decode(), pwiz::msdata::BinaryDataEncoder::Config::precision, pwiz::msdata::BinaryDataEncoder::Precision_32, and unit_assert.

Referenced by runSpecialTest(), and test5peptide().

455 {
456  // data stored as 32-bit big-endian zlib m/z-intensity pairs (mzXML with zlib)
457 
458  bfs::ifstream is(filename);
459  if (!is) throw runtime_error(("[PrecursorRecalculatorDefaultTest::readData()] Unable to open file " + filename.string()).c_str());
460  string encoded;
461  is >> encoded;
462 
463  BinaryDataEncoder::Config bdeConfig;
464  bdeConfig.precision = BinaryDataEncoder::Precision_32;
465  bdeConfig.byteOrder = BinaryDataEncoder::ByteOrder_BigEndian;
466  bdeConfig.compression = BinaryDataEncoder::Compression_Zlib;
467 
468  BinaryDataEncoder encoder(bdeConfig);
469  vector<double> data;
470  encoder.decode(encoded, data);
471 
472  unit_assert(!data.empty() && data.size()%2 == 0);
473  vector<MZIntensityPair> result(data.size()/2);
474  copy(data.begin(), data.end(), reinterpret_cast<double*>(&result[0]));
475  return result;
476 }
encoding/decoding configuration
#define unit_assert(x)
Definition: unit.hpp:85

§ createPrecursorRecalculator_msprefix()

shared_ptr<PrecursorRecalculatorDefault> createPrecursorRecalculator_msprefix ( )

Definition at line 479 of file PrecursorRecalculatorDefaultTest.cpp.

References pwiz::analysis::PeakFamilyDetectorFT::Config::cp, pwiz::analysis::PrecursorRecalculatorDefault::Config::mzLeftWidth, pwiz::analysis::PrecursorRecalculatorDefault::Config::mzRightWidth, pwiz::analysis::PrecursorRecalculatorDefault::Config::peakFamilyDetector, and pwiz::data::CalibrationParameters::thermo_FT().

Referenced by runSpecialTest(), and test5peptide().

480 {
481  // instantiate PeakFamilyDetector
482 
483  PeakFamilyDetectorFT::Config pfdftConfig;
484  pfdftConfig.cp = CalibrationParameters::thermo_FT();
485  shared_ptr<PeakFamilyDetector> pfd(new PeakFamilyDetectorFT(pfdftConfig));
486 
487  // instantiate PrecursorRecalculatorDefault
488 
490  config.peakFamilyDetector = pfd;
491  config.mzLeftWidth = 3;
492  config.mzRightWidth = 1.6;
493  return shared_ptr<PrecursorRecalculatorDefault>(new PrecursorRecalculatorDefault(config));
494 }
FT-specific implementation of PeakFamilyDetector.

§ validateRecalculation()

void validateRecalculation ( const MZIntensityPair begin,
const MZIntensityPair end,
PrecursorRecalculatorDefault pr,
const TestInfo testInfo 
)

Definition at line 513 of file PrecursorRecalculatorDefaultTest.cpp.

References TestInfo::chargeTrue, pwiz::analysis::PrecursorRecalculator::PrecursorInfo::mz, pwiz::chemistry::Ion::mz(), TestInfo::mzInitialEstimate, TestInfo::mzTrue, os_, pwiz::analysis::PrecursorRecalculatorDefault::recalculate(), unit_assert, and unit_assert_equal.

Referenced by runSpecialTest(), and test5peptide().

517 {
518  // recalculate
519 
520  PrecursorRecalculator::PrecursorInfo initialEstimate;
521  initialEstimate.mz = testInfo.mzInitialEstimate;
522 
523  vector<PrecursorRecalculator::PrecursorInfo> result;
524  pr.recalculate(begin, end, initialEstimate, result);
525 
526  // validate result
527 
528  if (os_)
529  for (vector<PrecursorRecalculator::PrecursorInfo>::const_iterator it=result.begin(), end=result.end(); it!=end; ++it)
530  *os_ << " " << it->mz << " " << it->charge << endl;
531 
532  unit_assert(result.size() >= 1);
533  unit_assert_equal(result[0].mz, testInfo.mzTrue, 1e-2);
534  unit_assert(result[0].charge == testInfo.chargeTrue);
535 }
#define unit_assert_equal(x, y, epsilon)
Definition: unit.hpp:99
double mz(double neutralMass, int protonDelta, int electronDelta=0, int neutronDelta=0)
Definition: Ion.hpp:78
virtual void recalculate(const MZIntensityPair *begin, const MZIntensityPair *end, const PrecursorInfo &initialEstimate, std::vector< PrecursorInfo > &result) const
#define unit_assert(x)
Definition: unit.hpp:85

§ test5peptide()

void test5peptide ( const bfs::path &  datadir)

Definition at line 538 of file PrecursorRecalculatorDefaultTest.cpp.

References createPrecursorRecalculator_msprefix(), os_, readData(), unit_assert, and validateRecalculation().

Referenced by runTests().

539 {
540  if (os_) *os_ << "test5peptide()\n" << flush;
541 
542  vector<MZIntensityPair> data = readData(datadir / "5peptide.b64");
543  unit_assert(data.size() == 19914);
544 
545  shared_ptr<PrecursorRecalculatorDefault> pr = createPrecursorRecalculator_msprefix();
546 
547  const MZIntensityPair* begin = &data[0];
548  const MZIntensityPair* end = begin + data.size();
549 
550  validateRecalculation(begin, end, *pr, TestInfo(810.79, 810.42, 2));
551  validateRecalculation(begin, end, *pr, TestInfo(837.34, 836.96, 2));
552  validateRecalculation(begin, end, *pr, TestInfo(725.36, 724.91, 2));
553  validateRecalculation(begin, end, *pr, TestInfo(558.87, 558.31, 3));
554  validateRecalculation(begin, end, *pr, TestInfo(812.33, 810.42, 2));
555  validateRecalculation(begin, end, *pr, TestInfo(810.75, 810.42, 2));
556  validateRecalculation(begin, end, *pr, TestInfo(837.96, 836.96, 2));
557  validateRecalculation(begin, end, *pr, TestInfo(644.06, 643.37, 2));
558  validateRecalculation(begin, end, *pr, TestInfo(725.68, 724.91, 2));
559  validateRecalculation(begin, end, *pr, TestInfo(559.19, 558.31, 3));
560  validateRecalculation(begin, end, *pr, TestInfo(811.41, 810.42, 2));
561  validateRecalculation(begin, end, *pr, TestInfo(674.64, 674.37, 2));
562  validateRecalculation(begin, end, *pr, TestInfo(882.45, 882.47, 1));
563 }
void validateRecalculation(const MZIntensityPair *begin, const MZIntensityPair *end, PrecursorRecalculatorDefault &pr, const TestInfo &testInfo)
vector< MZIntensityPair > readData(const bfs::path &filename)
The data point type of a mass spectrum.
Definition: MSData.hpp:421
shared_ptr< PrecursorRecalculatorDefault > createPrecursorRecalculator_msprefix()
#define unit_assert(x)
Definition: unit.hpp:85

§ runSpecialTest()

void runSpecialTest ( const bfs::path &  filename,
size_t  pairCount,
const TestInfo testInfo 
)

Definition at line 566 of file PrecursorRecalculatorDefaultTest.cpp.

References TestInfo::chargeTrue, createPrecursorRecalculator_msprefix(), TestInfo::mzInitialEstimate, TestInfo::mzTrue, os_, readData(), testInfo(), unit_assert, and validateRecalculation().

Referenced by runTests().

567 {
568  if (os_) *os_ << "runSpecialTest: " << filename << " " << testInfo.mzInitialEstimate << " "
569  << testInfo.mzTrue << " " << testInfo.chargeTrue << endl;
570 
571  vector<MZIntensityPair> data = readData(filename);
572  unit_assert(data.size() == pairCount);
573  shared_ptr<PrecursorRecalculatorDefault> pr = createPrecursorRecalculator_msprefix();
574  validateRecalculation(&*data.begin(), &*data.begin()+data.size(), *pr, testInfo);
575 }
void validateRecalculation(const MZIntensityPair *begin, const MZIntensityPair *end, PrecursorRecalculatorDefault &pr, const TestInfo &testInfo)
vector< MZIntensityPair > readData(const bfs::path &filename)
shared_ptr< PrecursorRecalculatorDefault > createPrecursorRecalculator_msprefix()
#define unit_assert(x)
Definition: unit.hpp:85
void testInfo()

§ runTests()

void runTests ( const bfs::path &  datadir)

Definition at line 578 of file PrecursorRecalculatorDefaultTest.cpp.

References runSpecialTest(), test(), test2(), and test5peptide().

Referenced by main().

579 {
580  test();
581  test2();
582  test5peptide(datadir);
583 
584  runSpecialTest(datadir / "special_1a.b64", 12118, TestInfo(484.2727357, 484.28, 0));
585  runSpecialTest(datadir / "special_1b.b64", 17767, TestInfo(930.0000218, 929.99, 2));
586 
587  // noise floor calculation issue (due to big neighbor)
588  runSpecialTest(datadir / "special_2a.b64", 4802, TestInfo(705.0000091, 704.32, 2));
589 
590  // charge state determination (window must be > 1.5amu to the right)
591  runSpecialTest(datadir / "special_2b.b64", 8897, TestInfo(961.0000167, 960.9639, 2));
592 
593  // monoisotopic peak threshold must be lenient
594  runSpecialTest(datadir / "special_2c.b64", 7006, TestInfo(731.090919, 730.36, 3));
595  runSpecialTest(datadir / "special_2d.b64", 12512, TestInfo(730.3599854,730.36, 3));
596 
597  // charge state calculation issues due to small 1-neutron peak
598  runSpecialTest(datadir / "special_3a.b64", 5721, TestInfo(560.3636411, 560.28, 2));
599  runSpecialTest(datadir / "special_3b.b64", 5342, TestInfo(820.6363762, 820.47, 2));
600 
601  // charge state calculation issues due to small 1-neutron peak
602  runSpecialTest(datadir / "special_4a.b64", 4142, TestInfo(791.5454722, 791.37, 2));
603 
604  // charge state regression due to generous acceptance of charge 2 scores
605  runSpecialTest(datadir / "special_5a.b64", 12324, TestInfo(445.0000073, 445.12, 1));
606  runSpecialTest(datadir / "special_5a.b64", 12324, TestInfo(407.9090971, 408.31, 1));
607  runSpecialTest(datadir / "special_5a.b64", 12324, TestInfo(462.0000078, 462.14, 1));
608  runSpecialTest(datadir / "special_5a.b64", 12324, TestInfo(536.0909191, 536.16, 1));
609  runSpecialTest(datadir / "special_5a.b64", 12324, TestInfo(519.0909186, 519.14, 1));
610 
611  // lonely peaks
612  runSpecialTest(datadir / "special_6a.b64", 12358, TestInfo(1682.636408, 1683.39, 0));
613  runSpecialTest(datadir / "special_6b.b64", 12280, TestInfo(1565.636404, 1563.74, 0));
614  runSpecialTest(datadir / "special_6c.b64", 12245, TestInfo(1668.545498, 1667.55, 0));
615  runSpecialTest(datadir / "special_6d.b64", 12386, TestInfo(1851.545504, 1849.69, 0));
616  runSpecialTest(datadir / "special_6e.b64", 12221, TestInfo(1444.636401, 1442.54, 0));
617 }
void test5peptide(const bfs::path &datadir)
void runSpecialTest(const bfs::path &filename, size_t pairCount, const TestInfo &testInfo)

§ main()

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

Definition at line 620 of file PrecursorRecalculatorDefaultTest.cpp.

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

621 {
622  TEST_PROLOG(argc, argv)
623 
624  try
625  {
626  bfs::path datadir = ".";
627 
628  for (int i=1; i<argc; i++)
629  {
630  if (!strcmp(argv[i],"-v"))
631  os_ = &cout;
632  else
633  // hack to allow running unit test from a different directory:
634  // Jamfile passes full path to specified input file.
635  // we want the path, so we can ignore filename
636  datadir = bfs::path(argv[i]).branch_path();
637  }
638 
639  runTests(datadir);
640 
641  }
642  catch (exception& e)
643  {
644  TEST_FAILED(e.what())
645  }
646  catch (...)
647  {
648  TEST_FAILED("Caught unknown exception.")
649  }
650 
652 }
void runTests(const bfs::path &datadir)
#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

§ testData_

double testData_[]

Definition at line 42 of file PrecursorRecalculatorDefaultTest.cpp.

Referenced by initializeWithTestData().

§ testDataSize_

const size_t testDataSize_ = sizeof(testData_)/sizeof(double)

Definition at line 384 of file PrecursorRecalculatorDefaultTest.cpp.

Referenced by initializeWithTestData().

§ testDataBegin_

const MZIntensityPair* testDataBegin_ = reinterpret_cast<MZIntensityPair*>(testData_)

Definition at line 385 of file PrecursorRecalculatorDefaultTest.cpp.

§ testDataEnd_

const MZIntensityPair* testDataEnd_ = reinterpret_cast<MZIntensityPair*>(testData_+testDataSize_)

Definition at line 386 of file PrecursorRecalculatorDefaultTest.cpp.