ProteoWizard
SpectrumList_ScanSummerTest.cpp
Go to the documentation of this file.
1 //
2 // $Id$
3 //
4 //
5 // Original author: William French <william.r.french <a.t> vanderbilt.edu>
6 //
7 // Copyright 2008 Vanderbilt University - Nashville, TN 37232
8 //
9 // Licensed under the Apache License, Version 2.0 (the "License");
10 // you may not use this file except in compliance with the License.
11 // You may obtain a copy of the License at
12 //
13 // http://www.apache.org/licenses/LICENSE-2.0
14 //
15 // Unless required by applicable law or agreed to in writing, software
16 // distributed under the License is distributed on an "AS IS" BASIS,
17 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 // See the License for the specific language governing permissions and
19 // limitations under the License.
20 //
21 
22 
29 
30 using namespace pwiz::util;
31 using namespace pwiz::msdata;
32 using namespace pwiz::analysis;
33 
34 ostream* os_ = 0;
35 
36 ostream& operator<< (ostream& os, const vector<double>& v)
37 {
38  os << "(";
39  for (size_t i=0; i < v.size(); ++i)
40  os << " " << v[i];
41  os << " )";
42  return os;
43 }
44 
46 {
47  // space-delimited doubles
48  const char* inputMZArray;
49  const char* inputIntensityArray;
51  double rTime;
52  double ionMobility;
53 };
54 
56 {
57 
58  { "112 112.0000001 112.1 120 121 123 124 128 129",
59  " 3 2 5 0 1 4 2 1 7",
60  120.0,
61  20.0,
62  0.0},
63 
64  { "112.0001 119 120 121 122 123 124 127 128 129",
65  " 1 4 5 6 7 8 9 10 11 12",
66  120.01,
67  20.1,
68  0.0},
69 
70  { "200 200.1 200.2 200.9 202",
71  "1.0 3.0 1.0 0.0 3.0",
72  401.23,
73  21.1,
74  1.0},
75 
76  { "120 126 127",
77  "7 7 7",
78  119.96,
79  21.05,
80  0.0},
81 
82  { "200.1 200.2 200.3 200.8 200.9",
83  "1.0 3.0 1.0 1.0 4.0",
84  401.19,
85  21.2,
86  1.01},
87 
88  { "200.1 200.2 200.3 200.8 200.9",
89  "1.0 3.0 1.0 1.0 4.0",
90  401.21,
91  21.3,
92  2.0},
93 };
94 
96 {
97 
98  { "112 112.1 119 120 121 122 123 124 126 127 128 129",
99  "6 5 4 12 7 7 12 11 7 17 12 19",
100  120.0,
101  20.1, // median of 20 20.1 21.05
102  0.0},
103 
104  { "200 200.1 200.2 200.3 200.8 200.9 202",
105  "1.0 4.0 4.0 1.0 1.0 4.0 3.0",
106  401.21, // median of 401.19 401.23
107  21.15, // median of 21.1 21.2
108  1.005}, // median of 1 1.01
109 
110  { "200.1 200.2 200.3 200.8 200.9",
111  "1.0 3.0 1.0 1.0 4.0",
112  401.21,
113  21.3,
114  2.0},
115 };
116 
118 const size_t goldStandardSize = sizeof(goldStandard) / sizeof(TestScanSummerCalculator);
119 
120 vector<double> parseDoubleArray(const string& doubleArray)
121 {
122  vector<double> doubleVector;
123  vector<string> tokens;
124  bal::split(tokens, doubleArray, bal::is_space(), bal::token_compress_on);
125  if (!tokens.empty())
126  for (size_t i=0; i < tokens.size(); ++i)
127  if (!tokens[i].empty())
128  doubleVector.push_back(lexical_cast<double>(tokens[i]));
129  return doubleVector;
130 }
131 
132 int test()
133 {
134  int failedTests = 0;
135 
136  // create the spectrum list
138  SpectrumListPtr originalList(sl);
139 
140  for (size_t i=0; i < testScanSummerSize; ++i)
141  {
143  SpectrumPtr s(new Spectrum);
144  s->set(MS_MSn_spectrum);
145  s->set(MS_ms_level,2);
146  s->index = i;
147  s->scanList.scans.push_back(Scan());
148  Scan& scanRef = s->scanList.scans[0];
149  scanRef.set(MS_scan_start_time,t.rTime,UO_second);
150  if (t.ionMobility > 0)
152  s->precursors.push_back(Precursor(t.inputPrecursorMZ));
153 
154  vector<double> inputMZArray = parseDoubleArray(t.inputMZArray);
155  vector<double> inputIntensityArray = parseDoubleArray(t.inputIntensityArray);
156  s->setMZIntensityArrays(inputMZArray, inputIntensityArray, MS_number_of_detector_counts);
157  s->defaultArrayLength = inputMZArray.size();
158 
159  scanRef.scanWindows.push_back(ScanWindow());
160  scanRef.scanWindows[0].set(MS_scan_window_lower_limit,inputMZArray[0]);
161  scanRef.scanWindows[0].set(MS_scan_window_upper_limit,inputMZArray[inputMZArray.size()-1]);
162 
163  sl->spectra.push_back(s);
164  }
165 
166 
167  vector<double> goldMZArray = parseDoubleArray(goldStandard[0].inputMZArray);
168  vector<double> goldIntensityArray = parseDoubleArray(goldStandard[0].inputIntensityArray);
169 
170  // run spectral summation
171  try
172  {
173 
174  SpectrumListPtr calculator(new SpectrumList_ScanSummer(originalList, 0.05, 10, 0.5));
175 
176  for (size_t i=0; i < calculator->size(); ++i)
177  {
178  SpectrumPtr s = calculator->spectrum(i,true);
179  BinaryData<double>& mzs = s->getMZArray()->data;
180  BinaryData<double>& intensities = s->getIntensityArray()->data;
181  Precursor& precursor = s->precursors[0];
182  SelectedIon& selectedIon = precursor.selectedIons[0];
183  double precursorMZ = selectedIon.cvParam(MS_selected_ion_m_z).valueAs<double>();
184  double rTime = s->scanList.scans[0].cvParam(MS_scan_start_time).timeInSeconds();
185  double ionMobility = s->scanList.scans[0].cvParamValueOrDefault(MS_inverse_reduced_ion_mobility, 0.0);
186 
187  vector<double> goldMZArray = parseDoubleArray(goldStandard[i].inputMZArray);
188  vector<double> goldIntensityArray = parseDoubleArray(goldStandard[i].inputIntensityArray);
189 
190  unit_assert_operator_equal(goldMZArray.size(), mzs.size());
191  unit_assert_operator_equal(goldIntensityArray.size(), intensities.size());
192  unit_assert_equal(goldStandard[i].inputPrecursorMZ, precursorMZ, 1e-8);
193  unit_assert_equal(goldStandard[i].rTime, rTime, 1e-8);
194  unit_assert_equal(goldStandard[i].ionMobility, ionMobility, 1e-8);
195 
196  for (size_t j=0; j < mzs.size(); ++j)
197  {
198  unit_assert_equal(mzs[j], goldMZArray[j], 1e-5);
199  unit_assert_equal(intensities[j], goldIntensityArray[j], 1e-5);
200  }
201 
202  }
203 
204 
205 
206 
207  }
208  catch (exception& e)
209  {
210  cerr << "Test failed:\n" << e.what() << endl;
211  ++failedTests;
212  }
213  return failedTests;
214 }
215 
216 
217 int main(int argc, char* argv[])
218 {
219  TEST_PROLOG(argc, argv)
220 
221  try
222  {
223  if (argc>1 && !strcmp(argv[1],"-v")) os_ = &cout;
224  int failedTests = test();
225  unit_assert_operator_equal(0, failedTests);
226  }
227  catch (exception& e)
228  {
229  TEST_FAILED(e.what())
230  }
231  catch (...)
232  {
233  TEST_FAILED("Caught unknown exception.")
234  }
235 
237 }
pwiz::msdata::SpectrumListPtr
boost::shared_ptr< SpectrumList > SpectrumListPtr
Definition: MSData.hpp:711
testScanSummerSize
const size_t testScanSummerSize
Definition: SpectrumList_ScanSummerTest.cpp:117
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
examples.hpp
pwiz::msdata::Spectrum
The structure that captures the generation of a peak list (including the underlying acquisitions)
Definition: MSData.hpp:506
CVTranslator.hpp
unit_assert_equal
#define unit_assert_equal(x, y, epsilon)
Definition: unit.hpp:99
TestScanSummerCalculator::rTime
double rTime
Definition: SpectrumList_ScanSummerTest.cpp:51
pwiz::util::BinaryData::size
size_t size() const
Definition: BinaryData.hpp:145
pwiz::data::peakdata::Scan
Definition: PeakData.hpp:135
MS_scan_start_time
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:309
pwiz::analysis
Definition: ChromatogramList_Filter.hpp:37
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
TestScanSummerCalculator::ionMobility
double ionMobility
Definition: SpectrumList_ScanSummerTest.cpp:52
pwiz::msdata
Definition: DemuxTypes.hpp:27
UO_second
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:13833
unit_assert_operator_equal
#define unit_assert_operator_equal(expected, actual)
Definition: unit.hpp:92
MS_inverse_reduced_ion_mobility
MS_inverse_reduced_ion_mobility
inverse reduced ion mobility: Ion mobility measurement for an ion or spectrum of ions as measured in ...
Definition: cv.hpp:8868
MS_scan_window_upper_limit
MS_scan_window_upper_limit
scan window upper limit: The lower m/z bound of a mass spectrometer scan window.
Definition: cv.hpp:2106
pwiz::data::CVParam::valueAs
value_type valueAs() const
templated value access with type conversion
Definition: ParamTypes.hpp:112
main
int main(int argc, char *argv[])
Definition: SpectrumList_ScanSummerTest.cpp:217
TestScanSummerCalculator::inputPrecursorMZ
double inputPrecursorMZ
Definition: SpectrumList_ScanSummerTest.cpp:50
pwiz::util
Definition: almost_equal.hpp:33
pwiz::msdata::ScanWindow
TODO.
Definition: MSData.hpp:362
TEST_EPILOG
#define TEST_EPILOG
Definition: unit.hpp:183
pwiz::data::ParamContainer::cvParam
CVParam cvParam(CVID cvid) const
finds cvid in the container:
parseDoubleArray
vector< double > parseDoubleArray(const string &doubleArray)
Definition: SpectrumList_ScanSummerTest.cpp:120
TextWriter.hpp
Std.hpp
MS_scan_window_lower_limit
MS_scan_window_lower_limit
scan window lower limit: The upper m/z bound of a mass spectrometer scan window.
Definition: cv.hpp:2109
pwiz::msdata::SpectrumPtr
boost::shared_ptr< Spectrum > SpectrumPtr
Definition: MSData.hpp:573
testScanSummerCalculators
TestScanSummerCalculator testScanSummerCalculators[]
Definition: SpectrumList_ScanSummerTest.cpp:55
MS_selected_ion_m_z
MS_selected_ion_m_z
selected ion m/z: Mass-to-charge ratio of an selected ion.
Definition: cv.hpp:2901
pwiz::util::BinaryData< double >
pwiz::msdata::SpectrumListSimple
Simple writeable in-memory implementation of SpectrumList.
Definition: MSData.hpp:717
MS_volt_second_per_square_centimeter
MS_volt_second_per_square_centimeter
volt-second per square centimeter: An electrical mobility unit that equals the speed [cm/s] an ion re...
Definition: cv.hpp:8862
SpectrumList_ScanSummer.hpp
os_
ostream * os_
Definition: SpectrumList_ScanSummerTest.cpp:34
TEST_FAILED
#define TEST_FAILED(x)
Definition: unit.hpp:177
TEST_PROLOG
#define TEST_PROLOG(argc, argv)
Definition: unit.hpp:175
TestScanSummerCalculator
Definition: SpectrumList_ScanSummerTest.cpp:46
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::SelectedIon
TODO.
Definition: MSData.hpp:297
test
int test()
Definition: SpectrumList_ScanSummerTest.cpp:132
operator<<
ostream & operator<<(ostream &os, const vector< double > &v)
Definition: SpectrumList_ScanSummerTest.cpp:36
goldStandard
TestScanSummerCalculator goldStandard[]
Definition: SpectrumList_ScanSummerTest.cpp:95
goldStandardSize
const size_t goldStandardSize
Definition: SpectrumList_ScanSummerTest.cpp:118
pwiz::msdata::Precursor::selectedIons
std::vector< SelectedIon > selectedIons
this list of precursor ions that were selected.
Definition: MSData.hpp:329
unit.hpp
TestScanSummerCalculator::inputIntensityArray
const char * inputIntensityArray
Definition: SpectrumList_ScanSummerTest.cpp:49
pwiz::analysis::SpectrumList_ScanSummer
Provides a custom-sorted spectrum list.
Definition: SpectrumList_ScanSummer.hpp:56
pwiz::msdata::Precursor
The method of precursor ion selection and activation.
Definition: MSData.hpp:312
pwiz::msdata::SpectrumListSimple::spectra
std::vector< SpectrumPtr > spectra
Definition: MSData.hpp:718
TestScanSummerCalculator::inputMZArray
const char * inputMZArray
Definition: SpectrumList_ScanSummerTest.cpp:48