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
30using namespace pwiz::cv;
31using namespace pwiz::util;
32using namespace pwiz::data;
33
34
35ostream* 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
66const char* mzmlScanTime =
67 "<cvParam cvLabel=\"MS\" accession=\"MS:1000016\" name=\"scan start time\" value=\"5.890500\" "
68 "unitAccession=\"UO:0000031\" unitName=\"minute\"/>\n";
69
70const char* mzmlCollisionEnergy =
71 "<cvParam cvLabel=\"MS\" accession=\"MS:1000045\" name=\"collision energy\" value=\"35.00\" "
72 "unitAccession=\"UO:0000266\" unitName=\"electronvolt\"/>\n";
73
74
75void 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
138void 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));
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));
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{
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
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
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
268int 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();
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
int main(int argc, char *argv[])
void testParamContainer()
const char * mzmlScanTime
void testIsChildOf()
const char * mzmlCollisionEnergy
ostream * os_
void testIs()
void test()
WriteCVParam(ostream &os)
void operator()(const CVParam &param)
UO_unit
unit: A unit of measurement is a standardized quantity of a physical quality.
Definition cv.hpp:13803
MS_spectrum_type
spectrum type: Spectrum type.
Definition cv.hpp:2286
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
UO_minute
minute: A time unit which is equal to 60 seconds.
Definition cv.hpp:13896
MS_highest_observed_m_z
highest observed m/z: Highest m/z value observed in the m/z array.
Definition cv.hpp:2187
MS_collision_induced_dissociation
collision-induced dissociation: The dissociation of an ion after collisional excitation....
Definition cv.hpp:747
MS_dissociation_method
dissociation method: Fragmentation method used for dissociation or fragmentation.
Definition cv.hpp:408
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_reflectron_on
reflectron on: Reflectron is on.
Definition cv.hpp:636
MS_lowest_observed_m_z
lowest observed m/z: Lowest m/z value observed in the m/z array.
Definition cv.hpp:2190
MS_PQD
PQD (pulsed q dissociation): A process that involves precursor ion activation at high Q,...
Definition cv.hpp:2457
MS_collision_energy
collision energy: Energy for an ion experiencing collision with a stationary gas particle resulting i...
Definition cv.hpp:411
MS_ms_level
ms level: Stages of ms achieved in a multi stage mass spectrometry experiment.
Definition cv.hpp:2139
MS_MSn_spectrum
MSn spectrum: MSn refers to multi-stage MS2 experiments designed to record product ion spectra where ...
Definition cv.hpp:2364
MS_CID
CID (collision-induced dissociation): The dissociation of an ion after collisional excitation....
Definition cv.hpp:750
MS_peak_picking
peak picking: Spectral peak processing conducted on the acquired data to convert profile data to cent...
Definition cv.hpp:369
CVID_Unknown
Definition cv.hpp:114
MS_ETD
ETD (electron transfer dissociation): A process to fragment ions in a mass spectrometer by inducing f...
Definition cv.hpp:2451
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
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
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
MS_ion_optics_attribute
ion optics attribute: Ion optics involves components that help focus ion streams in mass spectrometry...
Definition cv.hpp:2061
MS_selected_ion_m_z
selected ion m/z: Mass-to-charge ratio of an selected ion.
Definition cv.hpp:2901
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_deisotoping
deisotoping: The removal of isotope peaks to represent the fragment ion as one data point and is comm...
Definition cv.hpp:363
MS_plasma_desorption
plasma desorption: The ionization of material in a solid sample by bombarding it with ionic or neutra...
Definition cv.hpp:759
MS_ionization_type
ionization type: The method by which gas phase ions are generated from the sample.
Definition cv.hpp:285
MS_precursor_activation_attribute
precursor activation attribute: Precursor Activation Attribute.
Definition cv.hpp:2136
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
MS_reflectron_off
reflectron off: Reflectron is off.
Definition cv.hpp:633
PWIZ_API_DECL const CVTermInfo & cvTermInfo(CVID cvid)
returns CV term info for the specified CVID
boost::shared_ptr< ParamGroup > ParamGroupPtr
std::string name
Definition cv.hpp:14947
std::string id
Definition cv.hpp:14946
represents a tag-value pair, where the tag comes from the controlled vocabulary
double timeInSeconds() const
convenience function to return time in seconds (throws if units not a time unit)
value_type valueAs() const
templated value access with type conversion
functor for finding children of a specified CVID in a collection of CVParams:
functor for finding CVParam with specified exact CVID in a collection of CVParams:
The base class for elements that may contain cvParams, userParams, or paramGroup references.
void set(CVID cvid, const std::string &value="", CVID units=CVID_Unknown)
set/add a CVParam (not recursive)
std::vector< ParamGroupPtr > paramGroupPtrs
a collection of references to ParamGroups
bool hasCVParamChild(CVID cvid) const
returns true iff cvParams contains a child (is_a) of cvid (recursive)
CVParam cvParam(CVID cvid) const
finds cvid in the container:
std::vector< CVParam > cvParams
a collection of controlled vocabulary terms
UserParam userParam(const std::string &) const
finds UserParam with specified name
std::vector< CVParam > cvParamChildren(CVID cvid) const
finds all children of cvid in the container:
ValueT cvParamValueOrDefault(CVID cvid, ValueT defaultValue) const
finds cvid in the container:
std::vector< UserParam > userParams
a collection of uncontrolled user terms
CVParam cvParamChild(CVID cvid) const
finds child of cvid in the container:
bool hasCVParam(CVID cvid) const
returns true iff cvParams contains exact cvid (recursive)
ValueT cvParamChildValueOrDefault(CVID cvid, ValueT defaultValue) const
finds child of cvid in the container:
A collection of CVParam and UserParam elements that can be referenced from elsewhere in this mzML doc...
Uncontrolled user parameters (essentially allowing free text). Before using these,...
CVID units
an optional CV parameter for the unit term associated with the value, if any (e.g....
value_type valueAs() const
Templated value access with type conversion.
bool empty() const
returns true iff name, value, type, and units are all empty
std::string name
the name for the parameter.
std::string type
the datatype of the parameter, where appropriate (e.g.: xsd:float).
#define unit_assert(x)
Definition unit.hpp:85
#define TEST_EPILOG
Definition unit.hpp:183
#define TEST_FAILED(x)
Definition unit.hpp:177
#define unit_assert_equal(x, y, epsilon)
Definition unit.hpp:99
#define unit_assert_operator_equal(expected, actual)
Definition unit.hpp:92
#define TEST_PROLOG(argc, argv)
Definition unit.hpp:175