ProteoWizard
ParamTypesTest.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 "ParamTypes.hpp"
27 #include <cstring>
28 
29 
30 using namespace pwiz::cv;
31 using namespace pwiz::util;
32 using namespace pwiz::data;
33 
34 
35 ostream* os_ = 0;
36 
37 
39 {
40  public:
41 
42  WriteCVParam(ostream& os) : os_(os) {}
43 
44  void operator()(const CVParam& param)
45  {
46  os_ << "<cvParam "
47  << "cvLabel=\"" << cvTermInfo(param.cvid).id.substr(0,2) << "\" "
48  << "accession=\"" << cvTermInfo(param.cvid).id << "\" "
49  << "name=\"" << cvTermInfo(param.cvid).name << "\" "
50  << "value=\"" << param.value << "\"";
51 
52  if (param.units != CVID_Unknown)
53  {
54  os_ << " unitAccession=\"" << cvTermInfo(param.units).id << "\" "
55  << "unitName=\"" << cvTermInfo(param.units).name << "\"";
56  }
57 
58  os_ << "/>\n";
59  }
60 
61  private:
62  ostream& os_;
63 };
64 
65 
66 const char* mzmlScanTime =
67  "<cvParam cvLabel=\"MS\" accession=\"MS:1000016\" name=\"scan start time\" value=\"5.890500\" "
68  "unitAccession=\"UO:0000031\" unitName=\"minute\"/>\n";
69 
70 const char* mzmlCollisionEnergy =
71  "<cvParam cvLabel=\"MS\" accession=\"MS:1000045\" name=\"collision energy\" value=\"35.00\" "
72  "unitAccession=\"UO:0000266\" unitName=\"electronvolt\"/>\n";
73 
74 
75 void test()
76 {
77  vector<CVParam> params;
78 
79  params.push_back(CVParam(MS_lowest_observed_m_z, 420));
80  params.push_back(CVParam(MS_highest_observed_m_z, 2000.012345));
81  params.push_back(CVParam(MS_m_z, "goober"));
82  params.push_back(CVParam(MS_scan_start_time, 5.890500, UO_minute));
83  params.push_back(CVParam(MS_collision_energy, 35.00, UO_electronvolt));
84  params.push_back(CVParam(MS_deisotoping, true));
85  params.push_back(CVParam(MS_peak_picking, false));
86 
87  if (os_)
88  {
89  *os_ << "params:\n";
90  copy(params.begin(), params.end(), ostream_iterator<CVParam>(*os_, "\n"));
91  *os_ << endl;
92 
93  *os_ << "as mzML <cvParam> elements:\n";
94  for_each(params.begin(), params.end(), WriteCVParam(*os_));
95  *os_ << endl;
96 
97  *os_ << "value casting:\n";
98  int temp = params[0].valueAs<int>();
99  *os_ << temp << endl;
100  float temp2 = params[1].valueAs<float>();
101  *os_ << temp2 << endl;
102  string temp3 = params[2].valueAs<string>();
103  *os_ << temp3 << "\n\n";
104  }
105 
106  // verify simple things
107  unit_assert(420 == params[0].valueAs<int>());
108  unit_assert(2000.012345 == params[1].valueAs<double>());
109  unit_assert("goober" == params[2].value);
110  unit_assert(5.890500 == params[3].valueAs<double>());
111  unit_assert(35.00 == params[4].valueAs<double>());
112  unit_assert(params[0] == CVParam(MS_lowest_observed_m_z, 420));
113  unit_assert(params[1] != CVParam(MS_lowest_observed_m_z, 420));
115  unit_assert(params[5].valueAs<bool>() == true);
116  unit_assert(params[6].valueAs<bool>() == false);
117 
118  // verify manual mzml writing -- this is to verify that we have enough
119  // info to write <cvParam> elements as required by mzML
120 
121  ostringstream ossScanTime;
122  CVParam scanTime(MS_scan_start_time, "5.890500", UO_minute);
123  (WriteCVParam(ossScanTime))(scanTime);
124  if (os_) *os_ << "mzmlScanTime: " << mzmlScanTime << endl
125  << "ossScanTime: " << ossScanTime.str() << endl;
126  unit_assert(ossScanTime.str() == mzmlScanTime);
127  if (os_) *os_ << "scan time in seconds: " << scanTime.timeInSeconds() << endl;
128  unit_assert_equal(scanTime.timeInSeconds(), 5.8905 * 60, 1e-10);
129 
130  ostringstream ossCollisionEnergy;
131  (WriteCVParam(ossCollisionEnergy))(CVParam(MS_collision_energy, "35.00", UO_electronvolt));
132  if (os_) *os_ << "mzmlCollisionEnergy: " << mzmlCollisionEnergy << endl
133  << "ossCollisionEnergy: " << ossCollisionEnergy.str() << endl;
134  unit_assert(ossCollisionEnergy.str() == mzmlCollisionEnergy);
135 }
136 
137 
138 void testIs()
139 {
140  vector<CVParam> params;
141  params.push_back(CVParam(MS_plasma_desorption));
142  params.push_back(CVParam(MS_lowest_observed_m_z, 420));
143  params.push_back(CVParam(MS_collision_induced_dissociation));
144 
145  vector<CVParam>::const_iterator it =
146  find_if(params.begin(), params.end(), CVParamIs(MS_lowest_observed_m_z));
147 
148  unit_assert(it->value == "420");
149 }
150 
151 
153 {
154  // example of how to search through a collection of CVParams
155  // to find the first one whose cvid IsA specified CVID
156 
157  vector<CVParam> params;
158  params.push_back(CVParam(MS_lowest_observed_m_z, 420));
159  params.push_back(CVParam(MS_plasma_desorption));
160  params.push_back(CVParam(MS_collision_induced_dissociation));
161  params.push_back(CVParam(UO_electronvolt));
162  params.push_back(CVParam(MS_highest_observed_m_z, 2400.0));
163 
164  vector<CVParam>::const_iterator itDiss =
165  find_if(params.begin(), params.end(), CVParamIsChildOf(MS_dissociation_method));
166 
167  vector<CVParam>::const_iterator itUnit =
168  find_if(params.begin(), params.end(), CVParamIsChildOf(UO_unit));
169 
170  if (os_)
171  {
172  *os_ << "find dissociation method: "
173  << (itDiss!=params.end() ? cvTermInfo(itDiss->cvid).name : "not found")
174  << endl;
175 
176  *os_ << "find unit: "
177  << (itUnit!=params.end() ? cvTermInfo(itUnit->cvid).name : "not found")
178  << endl;
179 
180  }
181 
182  unit_assert(itDiss!=params.end() && itDiss->cvid==MS_plasma_desorption);
183  unit_assert(itUnit!=params.end() && itUnit->cvid==UO_electronvolt);
184 }
185 
186 
188 {
189  ParamContainer pc;
190  pc.cvParams.push_back(MS_reflectron_on);
191  pc.cvParams.push_back(MS_MSn_spectrum);
192  pc.cvParams.push_back(MS_reflectron_off);
193  pc.cvParams.push_back(CVParam(MS_ionization_type, 420));
194  pc.userParams.push_back(UserParam("name1", "1", "type1", UO_second));
195  pc.userParams.push_back(UserParam("name2", "2", "type2", UO_minute));
196 
197  ParamGroupPtr pg(new ParamGroup);
198  pg->cvParams.push_back(CVParam(UO_dalton, 666));
199  pc.paramGroupPtrs.push_back(pg);
200 
205 
208 
213 
216 
217  string result = "goober";
218  result = pc.cvParam(MS_selected_ion_m_z).value;
219  unit_assert(result == "");
220  result = pc.cvParam(MS_ionization_type).value;
221  unit_assert(result == "420");
222  result = pc.cvParam(UO_dalton).value;
223  unit_assert(result == "666");
224 
225  UserParam userParam = pc.userParam("name");
226  unit_assert(userParam.empty());
227  userParam = pc.userParam("name1");
228  unit_assert(userParam.name == "name1");
229  unit_assert(userParam.valueAs<int>() == 1);
230  unit_assert(userParam.type == "type1");
231  unit_assert(userParam.units == UO_second);
232  userParam = pc.userParam("name2");
233  unit_assert(userParam.name == "name2");
234  unit_assert(userParam.valueAs<double>() == 2);
235  unit_assert(userParam.type == "type2");
236  unit_assert(userParam.units == UO_minute);
237  unit_assert(pc.userParam("goober").valueAs<int>() == 0);
238 
239  pc.set(MS_ms_level, 2);
240  unit_assert(pc.cvParam(MS_ms_level).valueAs<int>() == 2);
241  pc.set(MS_ms_level, 3);
242  unit_assert(pc.cvParam(MS_ms_level).valueAs<int>() == 3);
243 
244  pc.set(MS_deisotoping, true);
245  unit_assert(pc.cvParam(MS_deisotoping).valueAs<bool>() == true);
246  pc.set(MS_deisotoping, false);
247  unit_assert(pc.cvParam(MS_deisotoping).valueAs<bool>() == false);
248 
252 
253  pc.set(MS_electric_field_strength, 123.4);
256 
257  pc.set(MS_CID);
258  pc.set(MS_ETD);
259  pg->set(MS_PQD);
260  vector<CVParam> dissociationMethods = pc.cvParamChildren(MS_dissociation_method);
261  unit_assert(dissociationMethods.size() == 3);
262  unit_assert(dissociationMethods[0] == MS_CID);
263  unit_assert(dissociationMethods[1] == MS_ETD);
264  unit_assert(dissociationMethods[2] == MS_PQD);
265 }
266 
267 
268 int main(int argc, char* argv[])
269 {
270  TEST_PROLOG(argc, argv)
271 
272  try
273  {
274  if (argc>1 && !strcmp(argv[1],"-v")) os_ = &cout;
275  test();
276  testIs();
277  testIsChildOf();
279  }
280  catch (exception& e)
281  {
282  TEST_FAILED(e.what())
283  }
284  catch (...)
285  {
286  TEST_FAILED("Caught unknown exception.")
287  }
288 
290 }
291 
pwiz::data::UserParam
Uncontrolled user parameters (essentially allowing free text). Before using these,...
Definition: ParamTypes.hpp:185
pwiz::data::UserParam::type
std::string type
the datatype of the parameter, where appropriate (e.g.: xsd:float).
Definition: ParamTypes.hpp:194
MS_deisotoping
MS_deisotoping
deisotoping: The removal of isotope peaks to represent the fragment ion as one data point and is comm...
Definition: cv.hpp:363
MS_ion_optics_attribute
MS_ion_optics_attribute
ion optics attribute: Ion optics involves components that help focus ion streams in mass spectrometry...
Definition: cv.hpp:2061
unit_assert_equal
#define unit_assert_equal(x, y, epsilon)
Definition: unit.hpp:99
pwiz::cv
Definition: cv.hpp:108
MS_peak_picking
MS_peak_picking
peak picking: Spectral peak processing conducted on the acquired data to convert profile data to cent...
Definition: cv.hpp:369
MS_plasma_desorption
MS_plasma_desorption
plasma desorption: The ionization of material in a solid sample by bombarding it with ionic or neutra...
Definition: cv.hpp:759
testIs
void testIs()
Definition: ParamTypesTest.cpp:138
UO_mass_unit
UO_mass_unit
mass unit: A unit which is a standard measure of the amount of matter/energy of a physical object.
Definition: cv.hpp:13809
testParamContainer
void testParamContainer()
Definition: ParamTypesTest.cpp:187
pwiz::data::ParamContainer::userParams
std::vector< UserParam > userParams
a collection of uncontrolled user terms
Definition: ParamTypes.hpp:253
UO_unit
UO_unit
unit: A unit of measurement is a standardized quantity of a physical quality.
Definition: cv.hpp:13803
MS_ETD
MS_ETD
ETD (electron transfer dissociation): A process to fragment ions in a mass spectrometer by inducing f...
Definition: cv.hpp:2451
pwiz::data
Definition: BinaryIndexStream.hpp:31
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
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
pwiz::msdata::id::value
PWIZ_API_DECL std::string value(const std::string &id, const std::string &name)
convenience function to extract a named value from an id string
pwiz::data::CVParam::timeInSeconds
double timeInSeconds() const
convenience function to return time in seconds (throws if units not a time unit)
pwiz::data::UserParam::valueAs
value_type valueAs() const
Templated value access with type conversion.
Definition: ParamTypes.hpp:214
MS_PQD
MS_PQD
PQD (pulsed q dissociation): A process that involves precursor ion activation at high Q,...
Definition: cv.hpp:2457
pwiz::data::CVParamIsChildOf
functor for finding children of a specified CVID in a collection of CVParams:
Definition: ParamTypes.hpp:164
pwiz::data::UserParam::units
CVID units
an optional CV parameter for the unit term associated with the value, if any (e.g....
Definition: ParamTypes.hpp:197
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_ionization_type
MS_ionization_type
ionization type: The method by which gas phase ions are generated from the sample.
Definition: cv.hpp:285
pwiz::data::ParamContainer::cvParamValueOrDefault
ValueT cvParamValueOrDefault(CVID cvid, ValueT defaultValue) const
finds cvid in the container:
Definition: ParamTypes.hpp:272
pwiz::data::ParamGroup
A collection of CVParam and UserParam elements that can be referenced from elsewhere in this mzML doc...
Definition: ParamTypes.hpp:346
WriteCVParam::operator()
void operator()(const CVParam &param)
Definition: ParamTypesTest.cpp:44
pwiz::data::CVParam::valueAs
value_type valueAs() const
templated value access with type conversion
Definition: ParamTypes.hpp:112
pwiz::data::ParamGroupPtr
boost::shared_ptr< ParamGroup > ParamGroupPtr
Definition: ParamTypes.hpp:239
pwiz::util
Definition: almost_equal.hpp:33
UO_electronvolt
UO_electronvolt
electronvolt: A non-SI unit of energy (eV) defined as the energy acquired by a single unbound electro...
Definition: cv.hpp:14595
MS_collision_energy
MS_collision_energy
collision energy: Energy for an ion experiencing collision with a stationary gas particle resulting i...
Definition: cv.hpp:411
TEST_EPILOG
#define TEST_EPILOG
Definition: unit.hpp:183
pwiz::cv::CVTermInfo::name
std::string name
Definition: cv.hpp:14947
pwiz::data::CVParam::units
CVID units
Definition: ParamTypes.hpp:48
ParamTypes.hpp
pwiz::data::ParamContainer::userParam
UserParam userParam(const std::string &) const
finds UserParam with specified name
pwiz::data::ParamContainer::cvParam
CVParam cvParam(CVID cvid) const
finds cvid in the container:
CVID_Unknown
CVID_Unknown
Definition: cv.hpp:114
pwiz::data::ParamContainer
The base class for elements that may contain cvParams, userParams, or paramGroup references.
Definition: ParamTypes.hpp:244
pwiz::data::ParamContainer::hasCVParamChild
bool hasCVParamChild(CVID cvid) const
returns true iff cvParams contains a child (is_a) of cvid (recursive)
MS_electric_field_strength
MS_electric_field_strength
electric field strength: The magnitude of the force per unit charge at a given point in space.
Definition: cv.hpp:1485
WriteCVParam
Definition: ParamTypesTest.cpp:38
pwiz::data::CVParam::value
std::string value
Definition: ParamTypes.hpp:47
Std.hpp
pwiz::data::ParamContainer::hasCVParam
bool hasCVParam(CVID cvid) const
returns true iff cvParams contains exact cvid (recursive)
pwiz::cv::cvTermInfo
const PWIZ_API_DECL CVTermInfo & cvTermInfo(CVID cvid)
returns CV term info for the specified CVID
pwiz::data::ParamContainer::cvParamChildren
std::vector< CVParam > cvParamChildren(CVID cvid) const
finds all children of cvid in the container:
test
void test()
Definition: ParamTypesTest.cpp:75
pwiz::data::CVParamIs
functor for finding CVParam with specified exact CVID in a collection of CVParams:
Definition: ParamTypes.hpp:151
mzmlCollisionEnergy
const char * mzmlCollisionEnergy
Definition: ParamTypesTest.cpp:70
pwiz::data::ParamContainer::cvParamChild
CVParam cvParamChild(CVID cvid) const
finds child of cvid in the container:
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
MS_spectrum_type
MS_spectrum_type
spectrum type: Spectrum type.
Definition: cv.hpp:2286
mzmlScanTime
const char * mzmlScanTime
Definition: ParamTypesTest.cpp:66
TEST_FAILED
#define TEST_FAILED(x)
Definition: unit.hpp:177
UO_dalton
UO_dalton
dalton: An independently to the base SI units defined mass unit which is equal to one twelfth of the ...
Definition: cv.hpp:14460
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::data::ParamContainer::set
void set(CVID cvid, const std::string &value="", CVID units=CVID_Unknown)
set/add a CVParam (not recursive)
MS_reflectron_on
MS_reflectron_on
reflectron on: Reflectron is on.
Definition: cv.hpp:636
MS_m_z
MS_m_z
m/z: Three-character symbol m/z is used to denote the quantity formed by dividing the mass of an ion ...
Definition: cv.hpp:384
pwiz::data::UserParam::empty
bool empty() const
returns true iff name, value, type, and units are all empty
os_
ostream * os_
Definition: ParamTypesTest.cpp:35
pwiz::data::ParamContainer::paramGroupPtrs
std::vector< ParamGroupPtr > paramGroupPtrs
a collection of references to ParamGroups
Definition: ParamTypes.hpp:247
WriteCVParam::WriteCVParam
WriteCVParam(ostream &os)
Definition: ParamTypesTest.cpp:42
MS_dissociation_method
MS_dissociation_method
dissociation method: Fragmentation method used for dissociation or fragmentation.
Definition: cv.hpp:408
MS_highest_observed_m_z
MS_highest_observed_m_z
highest observed m/z: Highest m/z value observed in the m/z array.
Definition: cv.hpp:2187
pwiz::data::CVParam::cvid
CVID cvid
Definition: ParamTypes.hpp:46
pwiz::cv::CVTermInfo::id
std::string id
Definition: cv.hpp:14946
pwiz::data::ParamContainer::cvParamChildValueOrDefault
ValueT cvParamChildValueOrDefault(CVID cvid, ValueT defaultValue) const
finds child of cvid in the container:
Definition: ParamTypes.hpp:283
MS_collision_induced_dissociation
MS_collision_induced_dissociation
collision-induced dissociation: The dissociation of an ion after collisional excitation....
Definition: cv.hpp:747
MS_reflectron_off
MS_reflectron_off
reflectron off: Reflectron is off.
Definition: cv.hpp:633
unit.hpp
unit_assert
#define unit_assert(x)
Definition: unit.hpp:85
MS_lowest_observed_m_z
MS_lowest_observed_m_z
lowest observed m/z: Lowest m/z value observed in the m/z array.
Definition: cv.hpp:2190
MS_precursor_activation_attribute
MS_precursor_activation_attribute
precursor activation attribute: Precursor Activation Attribute.
Definition: cv.hpp:2136
UO_minute
UO_minute
minute: A time unit which is equal to 60 seconds.
Definition: cv.hpp:13896
main
int main(int argc, char *argv[])
Definition: ParamTypesTest.cpp:268
pwiz::data::CVParam
represents a tag-value pair, where the tag comes from the controlled vocabulary
Definition: ParamTypes.hpp:44
MS_CID
MS_CID
CID (collision-induced dissociation): The dissociation of an ion after collisional excitation....
Definition: cv.hpp:750
testIsChildOf
void testIsChildOf()
Definition: ParamTypesTest.cpp:152
pwiz::data::UserParam::name
std::string name
the name for the parameter.
Definition: ParamTypes.hpp:188
WriteCVParam::os_
ostream & os_
Definition: ParamTypesTest.cpp:62
pwiz::data::ParamContainer::cvParams
std::vector< CVParam > cvParams
a collection of controlled vocabulary terms
Definition: ParamTypes.hpp:250