ProteoWizard
MSData.hpp
Go to the documentation of this file.
1 //
2 // $Id: MSData.hpp 6452 2014-07-03 19:01:15Z pcbrefugee $
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 #ifndef _MSDATA_HPP_
25 #define _MSDATA_HPP_
26 
27 
30 #include "boost/shared_ptr.hpp"
31 #include "boost/iostreams/positioning.hpp"
32 #include <vector>
33 #include <string>
34 #include <map>
35 #include <set>
36 
37 
38 namespace pwiz {
39 namespace msdata {
40 
41 
42  using namespace pwiz::data;
43 
44 
45 PWIZ_API_DECL std::vector<CV> defaultCVList();
46 
47 
48 /// This summarizes the different types of spectra that can be expected in the file. This is expected to aid processing software in skipping files that do not contain appropriate spectrum types for it.
50 
51 
52 /// Description of the source file, including location and type.
54 {
55  /// an identifier for this file.
56  std::string id;
57 
58  /// name of the source file, without reference to location (either URI or local path).
59  std::string name;
60 
61  /// URI-formatted location where the file was retrieved.
62  std::string location;
63 
64  SourceFile(const std::string _id = "",
65  const std::string _name = "",
66  const std::string _location = "");
67 
68 
69  /// returns true iff the element contains no params and all members are empty or null
70  bool empty() const;
71 };
72 
73 
74 /// Description of the source file, including location and type.
75 typedef boost::shared_ptr<SourceFile> SourceFilePtr;
76 
77 
78 /// Structure allowing the use of a controlled (cvParam) or uncontrolled vocabulary (userParam), or a reference to a predefined set of these in this mzML file (paramGroupRef).
80 
81 
82 /// Information pertaining to the entire mzML file (i.e. not specific to any part of the data set) is stored here.
84 {
85  /// this summarizes the different types of spectra that can be expected in the file. This is expected to aid processing software in skipping files that do not contain appropriate spectrum types for it.
86  FileContent fileContent;
87 
88  /// list and descriptions of the source files this mzML document was generated or derived from.
89  std::vector<SourceFilePtr> sourceFilePtrs;
90 
91  /// structure allowing the use of a controlled (cvParam) or uncontrolled vocabulary (userParam), or a reference to a predefined set of these in this mzML file (paramGroupRef)
92  std::vector<Contact> contacts;
93 
94  /// returns true iff all members are empty or null
95  bool empty() const;
96 };
97 
98 
99 /// Expansible description of the sample used to generate the dataset, named in sampleName.
101 {
102  /// a unique identifier across the samples with which to reference this sample description.
103  std::string id;
104 
105  /// an optional name for the sample description, mostly intended as a quick mnemonic.
106  std::string name;
107 
108  Sample(const std::string _id = "",
109  const std::string _name = "");
110 
111 
112  /// returns true iff the element contains no params and all members are empty or null
113  bool empty() const;
114 };
115 
116 
117 typedef boost::shared_ptr<Sample> SamplePtr;
118 
119 
121 {
126 };
127 
128 
129 /// A component of an instrument corresponding to a source (i.e. ion source), an analyzer (i.e. mass analyzer), or a detector (i.e. ion detector)
131 {
132  /// the type of component (Source, Analyzer, or Detector)
134 
135  /// this attribute MUST be used to indicate the order in which the components are encountered from source to detector (e.g., in a Q-TOF, the quadrupole would have the lower order number, and the TOF the higher number of the two).
136  int order;
137 
138  Component() : type(ComponentType_Unknown), order(0) {}
139  Component(ComponentType type, int order) : type(type), order(order) {}
140  Component(CVID cvid, int order) { define(cvid, order); }
141 
142  void define(CVID cvid, int order);
143 
144  /// returns true iff the element contains no params and all members are empty or null
145  bool empty() const;
146 };
147 
148 
149 //struct PWIZ_API_DECL Source : public Component {};
150 //struct PWIZ_API_DECL Analyzer : public Component {};
151 //struct PWIZ_API_DECL Detector : public Component {};
152 
153 
154 /// List with the different components used in the mass spectrometer. At least one source, one mass analyzer and one detector need to be specified.
155 struct PWIZ_API_DECL ComponentList : public std::vector<Component>
156 {
157  /// returns the source component with ordinal <index+1>
158  Component& source(size_t index);
159 
160  /// returns the analyzer component with ordinal <index+1>
161  Component& analyzer(size_t index);
162 
163  /// returns the detector component with ordinal <index+1>
164  Component& detector(size_t index);
165 
166  /// returns the source component with ordinal <index+1>
167  const Component& source(size_t index) const;
168 
169  /// returns the analyzer component with ordinal <index+1>
170  const Component& analyzer(size_t index) const;
171 
172  /// returns the detector component with ordinal <index+1>
173  const Component& detector(size_t index) const;
174 };
175 
176 
177 /// A piece of software.
179 {
180  /// an identifier for this software that is unique across all SoftwareTypes.
181  std::string id;
182 
183  /// the software version.
184  std::string version;
185 
186  Software(const std::string& _id = "");
187 
188  Software(const std::string& _id,
189  const CVParam& _param,
190  const std::string& _version);
191 
192  /// returns true iff all members are empty or null
193  bool empty() const;
194 };
195 
196 
197 typedef boost::shared_ptr<Software> SoftwarePtr;
198 
199 
200 /// TODO
202 
203 
204 /// Description of the acquisition settings of the instrument prior to the start of the run.
206 {
207  /// a unique identifier for this acquisition setting.
208  std::string id;
209 
210  /// container for a list of source file references.
211  std::vector<SourceFilePtr> sourceFilePtrs;
212 
213  /// target list (or 'inclusion list') configured prior to the run.
214  std::vector<Target> targets;
215 
216  ScanSettings(const std::string& _id = "");
217 
218 
219  /// returns true iff the element contains no params and all members are empty or null
220  bool empty() const;
221 };
222 
223 
224 typedef boost::shared_ptr<ScanSettings> ScanSettingsPtr;
225 
226 
227 /// Description of a particular hardware configuration of a mass spectrometer. Each configuration MUST have one (and only one) of the three different components used for an analysis. For hybrid instruments, such as an LTQ-FT, there MUST be one configuration for each permutation of the components that is used in the document. For software configuration, reference the appropriate ScanSettings element.
229 {
230  /// an identifier for this instrument configuration.
231  std::string id;
232 
233  /// list with the different components used in the mass spectrometer. At least one source, one mass analyzer and one detector need to be specified.
235 
236  /// reference to a previously defined software element.
237  SoftwarePtr softwarePtr;
238 
239  /// reference to a scan settings element defining global scan settings used by this configuration
240  ScanSettingsPtr scanSettingsPtr;
241 
242  InstrumentConfiguration(const std::string& _id = "");
243 
244  /// returns true iff the element contains no params and all members are empty or null
245  bool empty() const;
246 };
247 
248 
249 typedef boost::shared_ptr<InstrumentConfiguration> InstrumentConfigurationPtr;
250 
251 
252 /// Description of the default peak processing method. This element describes the base method used in the generation of a particular mzML file. Variable methods should be described in the appropriate acquisition section - if no acquisition-specific details are found, then this information serves as the default.
254 {
255  /// this attributes allows a series of consecutive steps to be placed in the correct order.
256  int order;
257 
258  /// this attribute MUST reference the 'id' of the appropriate SoftwareType.
259  SoftwarePtr softwarePtr;
260 
261  ProcessingMethod() : order(0) {}
262 
263  /// returns true iff the element contains no params and all members are empty or null
264  bool empty() const;
265 };
266 
267 
268 typedef boost::shared_ptr<ProcessingMethod> ProcessingMethodPtr;
269 
270 
271 /// Description of the way in which a particular software was used.
273 {
274  /// a unique identifier for this data processing that is unique across all DataProcessingTypes.
275  std::string id;
276 
277  /// description of the default peak processing method(s). This element describes the base method used in the generation of a particular mzML file. Variable methods should be described in the appropriate acquisition section - if no acquisition-specific details are found, then this information serves as the default.
278  std::vector<ProcessingMethod> processingMethods;
279 
280  DataProcessing(const std::string& _id = "");
281 
282  /// returns true iff the element contains no params and all members are empty or null
283  bool empty() const;
284 };
285 
286 
287 typedef boost::shared_ptr<DataProcessing> DataProcessingPtr;
288 
289 
290 /// This element captures the isolation (or 'selection') window configured to isolate one or more precursors.
292 
293 
294 /// TODO
296 {
298  explicit SelectedIon(double mz);
299  explicit SelectedIon(double mz, double intensity, CVID intensityUnit);
300  explicit SelectedIon(double mz, int chargeState);
301  explicit SelectedIon(double mz, double intensity, int chargeState, CVID intensityUnit);
302 };
303 
304 
305 /// The type and energy level used for activation.
307 
308 
309 /// The method of precursor ion selection and activation
311 {
312  /// for precursor spectra that are external to this document, this attribute MUST reference the 'id' attribute of a sourceFile representing that external document.
313  /// note: this attribute is mutually exclusive with spectrumID; i.e. use one or the other but not both
314  SourceFilePtr sourceFilePtr;
315 
316  /// for precursor spectra that are external to this document, this string MUST correspond to the 'id' attribute of a spectrum in the external document indicated by 'sourceFileRef'.
317  /// note: this attribute is mutually exclusive with spectrumID; i.e. use one or the other but not both
318  std::string externalSpectrumID;
319 
320  /// reference to the id attribute of the spectrum from which the precursor was selected.
321  /// note: this attribute is mutually exclusive with externalSpectrumID; i.e. use one or the other but not both
322  std::string spectrumID;
323 
324  /// this element captures the isolation (or 'selection') window configured to isolate one or more precursors.
325  IsolationWindow isolationWindow;
326 
327  /// this list of precursor ions that were selected.
328  std::vector<SelectedIon> selectedIons;
329 
330  /// the type and energy level used for activation.
331  Activation activation;
332 
334  explicit Precursor(double mz);
335  explicit Precursor(double mz, double intensity, CVID intensityUnit);
336  explicit Precursor(double mz, int chargeState);
337  explicit Precursor(double mz, double intensity, int chargeState, CVID intensityUnit);
338 
339 
340  /// returns true iff the element contains no params and all members are empty or null
341  bool empty() const;
342 };
343 
344 
345 /// product ion information
347 {
348  /// this element captures the isolation (or 'selection') window configured to isolate one or more precursors.
349  IsolationWindow isolationWindow;
350 
351  /// returns true iff the element contains no params and all members are empty or null
352  bool empty() const;
353 
354  /// returns true iff this product's isolation window is equal to that product's
355  bool operator==(const Product& that) const;
356 };
357 
358 
359 /// TODO
361 {
363  ScanWindow(double low, double high, CVID unit);
364 };
365 
366 
367 /// Scan or acquisition from original raw file used to create this peak list, as specified in sourceFile.
369 {
370  /// if this attribute is set, it must reference the 'id' attribute of a sourceFile representing the external document containing the spectrum referred to by 'externalSpectrumID'.
371  /// note: this attribute is mutually exclusive with spectrumID; i.e. use one or the other but not both
372  SourceFilePtr sourceFilePtr;
373 
374  /// for scans that are external to this document, this string must correspond to the 'id' attribute of a spectrum in the external document indicated by 'sourceFileRef'.
375  /// note: this attribute is mutually exclusive with spectrumID; i.e. use one or the other but not both
376  std::string externalSpectrumID;
377 
378  /// for scans that are local to this document, this attribute can be used to reference the 'id' attribute of the spectrum corresponding to the scan.
379  /// note: this attribute is mutually exclusive with externalSpectrumID; i.e. use one or the other but not both
380  std::string spectrumID;
381 
382  /// this attribute MUST reference the 'id' attribute of the appropriate instrument configuration.
383  InstrumentConfigurationPtr instrumentConfigurationPtr;
384 
385  /// container for a list of select windows.
386  std::vector<ScanWindow> scanWindows;
387 
388  /// returns true iff the element contains no params and all members are empty or null
389  bool empty() const;
390 };
391 
392 
393 /// List and descriptions of scans.
395 {
396  std::vector<Scan> scans;
397 
398  bool empty() const;
399 };
400 
401 
402 /// The structure into which encoded binary data goes. Byte ordering is always little endian (Intel style). Computers using a different endian style MUST convert to/from little endian when writing/reading mzML
404 {
405  /// this optional attribute may reference the 'id' attribute of the appropriate dataProcessing.
406  DataProcessingPtr dataProcessingPtr;
407 
408  /// the binary data.
409  std::vector<double> data;
410 
411  /// returns true iff the element contains no params and all members are empty or null
412  bool empty() const;
413 };
414 
415 
416 typedef boost::shared_ptr<BinaryDataArray> BinaryDataArrayPtr;
417 
418 
419 #pragma pack(1)
420 /// The data point type of a mass spectrum.
422 {
423  double mz;
424  double intensity;
425 
427  : mz(0), intensity(0)
428  {}
429 
430  MZIntensityPair(double mz, double intensity)
431  : mz(mz), intensity(intensity)
432  {}
433 
434  /// returns true iff mz and intensity are pairwise equal
435  bool operator==(const MZIntensityPair& that) const;
436 };
437 #pragma pack()
438 
439 
440 PWIZ_API_DECL std::ostream& operator<<(std::ostream& os, const MZIntensityPair& mzi);
441 
442 
443 #pragma pack(1)
444 /// The data point type of a chromatogram.
446 {
447  double time;
448  double intensity;
449 
451  : time(0), intensity(0)
452  {}
453 
454  TimeIntensityPair(double time, double intensity)
455  : time(time), intensity(intensity)
456  {}
457 
458  /// returns true iff time and intensity are pairwise equal
459  bool operator==(const TimeIntensityPair& that) const;
460 };
461 #pragma pack()
462 
463 
464 PWIZ_API_DECL std::ostream& operator<<(std::ostream& os, const TimeIntensityPair& ti);
465 
466 const size_t IDENTITY_INDEX_NONE = (size_t)-1;
467 
468 /// Identifying information for a spectrum
470 {
471  /// the zero-based, consecutive index of the spectrum in the SpectrumList.
472  size_t index;
473 
474  /// a unique identifier for this spectrum. It should be expected that external files may use this identifier together with the mzML filename or accession to reference a particular spectrum.
475  std::string id;
476 
477  /// the identifier for the spot from which this spectrum was derived, if a MALDI or similar run.
478  std::string spotID;
479 
480  /// for file-based MSData implementations, this attribute may refer to the spectrum's position in the file
481  boost::iostreams::stream_offset sourceFilePosition;
482 
483 
484  SpectrumIdentity() : index(IDENTITY_INDEX_NONE), sourceFilePosition((boost::iostreams::stream_offset)-1) {}
485 };
486 
487 /// Identifying information for a chromatogram
489 {
490  /// the zero-based, consecutive index of the chromatogram in the ChromatogramList.
491  size_t index;
492 
493  /// a unique identifier for this chromatogram. It should be expected that external files may use this identifier together with the mzML filename or accession to reference a particular chromatogram.
494  std::string id;
495 
496  /// for file-based MSData implementations, this attribute may refer to the chromatogram's position in the file
497  boost::iostreams::stream_offset sourceFilePosition;
498 
499  ChromatogramIdentity() : index(IDENTITY_INDEX_NONE), sourceFilePosition(-1) {}
500 };
501 
502 
503 /// The structure that captures the generation of a peak list (including the underlying acquisitions)
505 {
506  /// default length of binary data arrays contained in this element.
508 
509  /// this attribute can optionally reference the 'id' of the appropriate dataProcessing.
510  DataProcessingPtr dataProcessingPtr;
511 
512  /// this attribute can optionally reference the 'id' of the appropriate sourceFile.
513  SourceFilePtr sourceFilePtr;
514 
515  /// list of scans
517 
518  /// list and descriptions of precursors to the spectrum currently being described.
519  std::vector<Precursor> precursors;
520 
521  /// list and descriptions of product ion information
522  std::vector<Product> products;
523 
524  /// list of binary data arrays.
525  std::vector<BinaryDataArrayPtr> binaryDataArrayPtrs;
526 
527 
528  Spectrum() : defaultArrayLength(0) {}
529 
530  /// returns true iff the element contains no params and all members are empty or null
531  bool empty() const;
532 
533  /// returns true iff has nonnull and nonempty BinaryDataArrayPtr
534  bool hasBinaryData() const {
535  return binaryDataArrayPtrs.size() &&
536  binaryDataArrayPtrs[0] &&
537  !binaryDataArrayPtrs[0]->data.empty();
538  };
539 
540  /// copy binary data arrays into m/z-intensity pair array
541  void getMZIntensityPairs(std::vector<MZIntensityPair>& output) const;
542 
543  /// copy binary data arrays into m/z-intensity pair array
544  /// note: this overload is to allow client to allocate own buffer; the client
545  /// must determine the correct size beforehand, or an exception will be thrown
546  void getMZIntensityPairs(MZIntensityPair* output, size_t expectedSize) const;
547 
548  /// get m/z array (may be null)
549  BinaryDataArrayPtr getMZArray() const;
550 
551  /// get intensity array (may be null)
552  BinaryDataArrayPtr getIntensityArray() const;
553 
554  /// set binary data arrays
555  void setMZIntensityPairs(const std::vector<MZIntensityPair>& input, CVID intensityUnits);
556 
557  /// set binary data arrays
558  void setMZIntensityPairs(const MZIntensityPair* input, size_t size, CVID intensityUnits);
559 
560  /// set m/z and intensity arrays separately (they must be the same size)
561  void setMZIntensityArrays(const std::vector<double>& mzArray, const std::vector<double>& intensityArray, CVID intensityUnits);
562 
563  /// set m/z and intensity arrays separately (they must be the same size) by swapping the vector contents
564  /// this allows for a more nearly zero copy setup. Contents of mzArray and intensityArray are undefined after calling.
565  void swapMZIntensityArrays(std::vector<double>& mzArray, std::vector<double>& intensityArray, CVID intensityUnits);
566 };
567 
568 
569 typedef boost::shared_ptr<Spectrum> SpectrumPtr;
570 
571 
572 /// A single chromatogram.
574 {
575  /// default length of binary data arrays contained in this element.
577 
578  /// this attribute can optionally reference the 'id' of the appropriate dataProcessing.
579  DataProcessingPtr dataProcessingPtr;
580 
581  /// description of precursor ion information (i.e. Q1 settings)
583 
584  /// description of product ion information (i.e. Q3 settings)
586 
587  /// list of binary data arrays.
588  std::vector<BinaryDataArrayPtr> binaryDataArrayPtrs;
589 
590  Chromatogram() : defaultArrayLength(0) {}
591 
592  /// returns true iff the element contains no params and all members are empty or null
593  bool empty() const;
594 
595  /// copy binary data arrays into time-intensity pair array
596  void getTimeIntensityPairs(std::vector<TimeIntensityPair>& output) const;
597 
598  /// copy binary data arrays into time-intensity pair array
599  /// note: this overload is to allow client to allocate own buffer; the client
600  /// must determine the correct size beforehand, or an exception will be thrown
601  void getTimeIntensityPairs(TimeIntensityPair* output, size_t expectedSize) const;
602 
603  /// get time array (may be null)
604  BinaryDataArrayPtr getTimeArray() const;
605 
606  /// get intensity array (may be null)
607  BinaryDataArrayPtr getIntensityArray() const;
608 
609  /// set binary data arrays
610  void setTimeIntensityPairs(const std::vector<TimeIntensityPair>& input, CVID timeUnits, CVID intensityUnits);
611 
612  /// set binary data arrays
613  void setTimeIntensityPairs(const TimeIntensityPair* input, size_t size, CVID timeUnits, CVID intensityUnits);
614 
615  /// set time and intensity arrays separately (they must be the same size)
616  void setTimeIntensityArrays(const std::vector<double>& timeArray, const std::vector<double>& intensityArray, CVID timeUnits, CVID intensityUnits);
617 };
618 
619 
620 typedef boost::shared_ptr<Chromatogram> ChromatogramPtr;
621 
622 
623 // note: derived container to support dynamic linking on Windows
624 class IndexList : public std::vector<size_t> {};
625 
627 {
632 };
633 
634 ///
635 /// Interface for accessing spectra, which may be stored in memory
636 /// or backed by a data file (RAW, mzXML, mzML).
637 ///
638 /// Implementation notes:
639 ///
640 /// - Implementations are expected to keep a spectrum index in the form of
641 /// vector<SpectrumIdentity> or equivalent. The default find*() functions search
642 /// the index linearly. Implementations may provide constant time indexing.
643 ///
644 /// - The semantics of spectrum() may vary slightly with implementation. In particular,
645 /// a SpectrumList implementation that is backed by a file may choose either to cache
646 /// or discard the SpectrumPtrs for future access, with the caveat that the client
647 /// may write to the underlying data.
648 ///
649 /// - It is the implementation's responsibility to return a valid SpectrumPtr from spectrum().
650 /// If this cannot be done, an exception must be thrown.
651 ///
652 /// - The 'getBinaryData' flag is a hint if false : implementations may provide valid
653 /// BinaryDataArrayPtrs on spectrum(index, false); implementations *must* provide
654 /// valid BinaryDataArrayPtrs on spectrum(index, true).
655 ///
657 {
658  public:
659 
660  /// returns the number of spectra
661  virtual size_t size() const = 0;
662 
663  /// returns true iff (size() == 0) and (dataProcessingPtr.get() == NULL)
664  virtual bool empty() const;
665 
666  /// access to a spectrum index
667  virtual const SpectrumIdentity& spectrumIdentity(size_t index) const = 0;
668 
669  /// find id in the spectrum index (returns size() on failure)
670  virtual size_t find(const std::string& id) const;
671 
672  /// find an abbreviated id (e.g. "1.1.123.2" for "sample=1 period=1 cycle=123 experiment=2") in the spectrum index (returns size() on failure)
673  virtual size_t findAbbreviated(const std::string& abbreviatedId, char delimiter = '.') const;
674 
675  /// find all spectrum indexes with specified name/value pair
676  virtual IndexList findNameValue(const std::string& name, const std::string& value) const;
677 
678  /// find all spectrum indexes with spotID (returns empty vector on failure)
679  virtual IndexList findSpotID(const std::string& spotID) const;
680 
681  /// retrieve a spectrum by index
682  /// - binary data arrays will be provided if (getBinaryData == true);
683  /// - client may assume the underlying Spectrum* is valid
684  virtual SpectrumPtr spectrum(size_t index, bool getBinaryData = false) const = 0;
685 
686  /// get a copy of the seed spectrum, optionally with its binary data populated
687  /// this is useful for formats like mzML that can delay loading of binary data
688  /// - client may assume the underlying Spectrum* is valid
689  virtual SpectrumPtr spectrum(const SpectrumPtr& seed, bool getBinaryData) const;
690 
691  /// retrieve a spectrum by index
692  /// - detailLevel determines what fields are guaranteed present on the spectrum after the call
693  /// - client may assume the underlying Spectrum* is valid
694  virtual SpectrumPtr spectrum(size_t index, DetailLevel detailLevel) const;
695 
696  /// returns the data processing affecting spectra retrieved through this interface
697  /// - may return a null shared pointer
698  virtual const boost::shared_ptr<const DataProcessing> dataProcessingPtr() const;
699 
700  /// issues a warning once per SpectrumList instance (based on string hash)
701  virtual void warn_once(const char* msg) const;
702 
703  virtual ~SpectrumList(){}
704 };
705 
706 
707 typedef boost::shared_ptr<SpectrumList> SpectrumListPtr;
708 
709 
710 /// Simple writeable in-memory implementation of SpectrumList.
711 /// Note: This spectrum() implementation returns internal SpectrumPtrs.
713 {
714  std::vector<SpectrumPtr> spectra;
715  DataProcessingPtr dp;
716 
717  // SpectrumList implementation
718 
719  virtual size_t size() const {return spectra.size();}
720  virtual bool empty() const {return spectra.empty() && !dp.get();}
721  virtual const SpectrumIdentity& spectrumIdentity(size_t index) const;
722  virtual SpectrumPtr spectrum(size_t index, bool getBinaryData) const;
723  virtual const boost::shared_ptr<const DataProcessing> dataProcessingPtr() const;
724 };
725 
726 
727 typedef boost::shared_ptr<SpectrumListSimple> SpectrumListSimplePtr;
728 
729 
730 ///
731 /// Interface for accessing chromatograms, which may be stored in memory
732 /// or backed by a data file (RAW, mzXML, mzML).
733 ///
734 /// Implementation notes:
735 ///
736 /// - Implementations are expected to keep a chromatogram index in the form of
737 /// vector<ChromatogramIdentity> or equivalent. The default find*() functions search
738 /// the index linearly. Implementations may provide constant time indexing.
739 ///
740 /// - The semantics of chromatogram() may vary slightly with implementation. In particular,
741 /// a ChromatogramList implementation that is backed by a file may choose either to cache
742 /// or discard the ChromatogramPtrs for future access, with the caveat that the client
743 /// may write to the underlying data.
744 ///
745 /// - It is the implementation's responsibility to return a valid ChromatogramPtr from chromatogram().
746 /// If this cannot be done, an exception must be thrown.
747 ///
748 /// - The 'getBinaryData' flag is a hint if false : implementations may provide valid
749 /// BinaryDataArrayPtrs on chromatogram(index, false); implementations *must* provide
750 /// valid BinaryDataArrayPtrs on chromatogram(index, true).
751 ///
753 {
754  public:
755 
756  /// returns the number of chromatograms
757  virtual size_t size() const = 0;
758 
759  /// returns true iff (size() == 0) and (dataProcessingPtr.get() == NULL)
760  bool empty() const;
761 
762  /// access to a chromatogram index
763  virtual const ChromatogramIdentity& chromatogramIdentity(size_t index) const = 0;
764 
765  /// find id in the chromatogram index (returns size() on failure)
766  virtual size_t find(const std::string& id) const;
767 
768  /// retrieve a chromatogram by index
769  /// - binary data arrays will be provided if (getBinaryData == true);
770  /// - client may assume the underlying Chromatogram* is valid
771  virtual ChromatogramPtr chromatogram(size_t index, bool getBinaryData = false) const = 0;
772 
773  /// returns the data processing affecting spectra retrieved through this interface
774  /// - may return a null shared pointer
775  virtual const boost::shared_ptr<const DataProcessing> dataProcessingPtr() const;
776 
777  virtual ~ChromatogramList(){}
778 };
779 
780 
781 typedef boost::shared_ptr<ChromatogramList> ChromatogramListPtr;
782 
783 
784 /// Simple writeable in-memory implementation of ChromatogramList.
785 /// Note: This chromatogram() implementation returns internal ChromatogramPtrs.
787 {
788  std::vector<ChromatogramPtr> chromatograms;
789  DataProcessingPtr dp;
790 
791  // ChromatogramList implementation
792 
793  virtual size_t size() const {return chromatograms.size();}
794  virtual bool empty() const {return chromatograms.empty() && !dp.get();}
795  virtual const ChromatogramIdentity& chromatogramIdentity(size_t index) const;
796  virtual ChromatogramPtr chromatogram(size_t index, bool getBinaryData) const;
797  virtual const boost::shared_ptr<const DataProcessing> dataProcessingPtr() const;
798 };
799 
800 
801 typedef boost::shared_ptr<ChromatogramListSimple> ChromatogramListSimplePtr;
802 
803 
804 /// A run in mzML should correspond to a single, consecutive and coherent set of scans on an instrument.
806 {
807  /// a unique identifier for this run.
808  std::string id;
809 
810  /// this attribute MUST reference the 'id' of the default instrument configuration. If a scan does not reference an instrument configuration, it implicitly refers to this configuration.
811  InstrumentConfigurationPtr defaultInstrumentConfigurationPtr;
812 
813  /// this attribute MUST reference the 'id' of the appropriate sample.
814  SamplePtr samplePtr;
815 
816  /// the optional start timestamp of the run, in UT.
817  std::string startTimeStamp;
818 
819  /// default source file reference
820  SourceFilePtr defaultSourceFilePtr;
821 
822  /// all mass spectra and the acquisitions underlying them are described and attached here. Subsidiary data arrays are also both described and attached here.
823  SpectrumListPtr spectrumListPtr;
824 
825  /// all chromatograms for this run.
826  ChromatogramListPtr chromatogramListPtr;
827 
828  Run(){}
829  bool empty() const;
830 
831  private:
832  // no copying - any implementation must handle:
833  // - SpectrumList cloning
834  // - internal cross-references to heap-allocated objects
835  Run(const Run&);
836  Run& operator=(const Run&);
837 };
838 
839 
840 namespace IO {struct HandlerMSData;} // forward declaration for friend
841 
842 
843 /// This is the root element of ProteoWizard; it represents the mzML element, defined as:
844 /// intended to capture the use of a mass spectrometer, the data generated, and the initial processing of that data (to the level of the peak list).
846 {
847  /// an optional accession number for the mzML document.
848  std::string accession;
849 
850  /// an optional id for the mzML document. It is recommended to use LSIDs when possible.
851  std::string id;
852 
853  /// container for one or more controlled vocabulary definitions.
854  /// note: one of the <cv> elements in this list MUST be the PSI MS controlled vocabulary. All <cvParam> elements in the document MUST refer to one of the <cv> elements in this list.
855  std::vector<CV> cvs;
856 
857  /// information pertaining to the entire mzML file (i.e. not specific to any part of the data set) is stored here.
859 
860  /// container for a list of referenceableParamGroups
861  std::vector<ParamGroupPtr> paramGroupPtrs;
862 
863  /// list and descriptions of samples.
864  std::vector<SamplePtr> samplePtrs;
865 
866  /// list and descriptions of software used to acquire and/or process the data in this mzML file.
867  std::vector<SoftwarePtr> softwarePtrs;
868 
869  /// list with the descriptions of the acquisition settings applied prior to the start of data acquisition.
870  std::vector<ScanSettingsPtr> scanSettingsPtrs;
871 
872  /// list and descriptions of instrument configurations.
873  std::vector<InstrumentConfigurationPtr> instrumentConfigurationPtrs;
874 
875  /// list and descriptions of data processing applied to this data.
876  std::vector<DataProcessingPtr> dataProcessingPtrs;
877 
878  /// return dataProcessingPtrs augmented by the dataProcessingPtr() set in SpectrumList and/or ChromatogramList
879  std::vector<DataProcessingPtr> allDataProcessingPtrs() const;
880 
881  /// a run in mzML should correspond to a single, consecutive and coherent set of scans on an instrument.
883 
884  MSData();
885  virtual ~MSData();
886  bool empty() const;
887 
888  /// returns the version of this mzML document;
889  /// for a document created programmatically, the version is the current release version of mzML;
890  /// for a document created from a file/stream, the version is the schema version read from the file/stream
891  const std::string& version() const;
892 
893  // for detecting out of order filters
894  void filterApplied() {nFiltersApplied_++;};
895  int countFiltersApplied() const {return nFiltersApplied_;};
896 
897  private:
898  // no copying
899  MSData(const MSData&);
900  MSData& operator=(const MSData&);
901 
902  protected:
903  std::string version_; // schema version read from the file/stream
904  friend struct IO::HandlerMSData;
905  int nFiltersApplied_; // useful for flagging filters that need to be first, like vendor centroiding
906 };
907 
908 
909 typedef boost::shared_ptr<MSData> MSDataPtr;
910 
911 
912 namespace id {
913 
914 /// parses an id string into a map<string,string>
915 PWIZ_API_DECL std::map<std::string,std::string> parse(const std::string& id);
916 
917 /// convenience function to extract a named value from an id string
918 PWIZ_API_DECL std::string value(const std::string& id, const std::string& name);
919 
920 /// templated convenience function to extract a named value from an id string
921 template<typename value_type>
922 value_type valueAs(const std::string& id, const std::string& name)
923 {
924  std::string result = value(id, name);
925  return !result.empty() ? boost::lexical_cast<value_type>(result)
926  : boost::lexical_cast<value_type>(0);
927 }
928 
929 /// returns the nativeID format from the defaultSourceFilePtr if set,
930 /// or from sourceFilePtrs[0] if the list isn't empty,
931 /// or CVID_Unknown
933 
934 /// translates a "scan number" to a string that is correct for the given nativeID format;
935 /// semantic validity requires that scanNumber be parseable as an integer;
936 /// some nativeID formats cannot be translated to and will always return an empty string
937 /// currently supported formats: Thermo, Bruker/Agilent YEP, Bruker BAF, mzXML, MGF, and mzData
938 PWIZ_API_DECL std::string translateScanNumberToNativeID(CVID nativeIDFormat, const std::string& scanNumber);
939 
940 /// translates a nativeID in the given nativeID format to a simple integer "scan number";
941 /// some nativeID formats cannot be translated from and will always return an empty string
942 /// currently supported formats: Thermo, Bruker/Agilent YEP, Bruker BAF, mzXML, MGF, and mzData
943 PWIZ_API_DECL std::string translateNativeIDToScanNumber(CVID nativeIDFormat, const std::string& id);
944 
945 /// abbreviates a nativeID ("name1=value1 name2=value2" translates to "value1.value2")
946 PWIZ_API_DECL std::string abbreviate(const std::string& id, char delimiter = '.');
947 
948 } // namespace id
949 
950 
951 } // namespace msdata
952 } // namespace pwiz
953 
954 
955 #endif // _MSDATA_HPP_
956 
IsolationWindow isolationWindow
this element captures the isolation (or &#39;selection&#39;) window configured to isolate one or more precurs...
Definition: MSData.hpp:349
Structure allowing the use of a controlled (cvParam) or uncontrolled vocabulary (userParam), or a reference to a predefined set of these in this mzML file (paramGroupRef).
Definition: MSData.hpp:79
std::vector< Product > products
list and descriptions of product ion information
Definition: MSData.hpp:522
This summarizes the different types of spectra that can be expected in the file. This is expected to ...
Definition: MSData.hpp:49
product ion information
Definition: MSData.hpp:346
The type and energy level used for activation.
Definition: MSData.hpp:306
Interface for accessing chromatograms, which may be stored in memory or backed by a data file (RAW...
Definition: MSData.hpp:752
std::string id
a unique identifier for this chromatogram. It should be expected that external files may use this ide...
Definition: MSData.hpp:494
std::vector< SourceFilePtr > sourceFilePtrs
list and descriptions of the source files this mzML document was generated or derived from...
Definition: MSData.hpp:89
PWIZ_API_DECL std::string abbreviate(const std::string &id, char delimiter='.')
abbreviates a nativeID ("name1=value1 name2=value2" translates to "value1.value2") ...
Description of the way in which a particular software was used.
Definition: MSData.hpp:272
ComponentList componentList
list with the different components used in the mass spectrometer. At least one source, one mass analyzer and one detector need to be specified.
Definition: MSData.hpp:234
virtual size_t size() const
returns the number of spectra
Definition: MSData.hpp:719
ScanList scanList
list of scans
Definition: MSData.hpp:516
const size_t IDENTITY_INDEX_NONE
Definition: MSData.hpp:466
boost::shared_ptr< ProcessingMethod > ProcessingMethodPtr
Definition: MSData.hpp:268
boost::shared_ptr< Software > SoftwarePtr
Definition: MSData.hpp:197
Description of the source file, including location and type.
Definition: MSData.hpp:53
PWIZ_API_DECL std::ostream & operator<<(std::ostream &os, const BinaryDataEncoder::Config &config)
Scan or acquisition from original raw file used to create this peak list, as specified in sourceFile...
Definition: MSData.hpp:368
std::vector< InstrumentConfigurationPtr > instrumentConfigurationPtrs
list and descriptions of instrument configurations.
Definition: MSData.hpp:873
The method of precursor ion selection and activation.
Definition: MSData.hpp:310
ChromatogramListPtr chromatogramListPtr
all chromatograms for this run.
Definition: MSData.hpp:826
std::vector< BinaryDataArrayPtr > binaryDataArrayPtrs
list of binary data arrays.
Definition: MSData.hpp:525
SourceFilePtr sourceFilePtr
for precursor spectra that are external to this document, this attribute MUST reference the &#39;id&#39; attr...
Definition: MSData.hpp:314
A component of an instrument corresponding to a source (i.e. ion source), an analyzer (i...
Definition: MSData.hpp:130
SoftwarePtr softwarePtr
reference to a previously defined software element.
Definition: MSData.hpp:237
std::vector< ChromatogramPtr > chromatograms
Definition: MSData.hpp:788
boost::shared_ptr< Spectrum > SpectrumPtr
Definition: MSData.hpp:569
boost::shared_ptr< ChromatogramList > ChromatogramListPtr
Definition: MSData.hpp:781
boost::shared_ptr< ScanSettings > ScanSettingsPtr
Definition: MSData.hpp:224
TimeIntensityPair(double time, double intensity)
Definition: MSData.hpp:454
std::string name
an optional name for the sample description, mostly intended as a quick mnemonic. ...
Definition: MSData.hpp:106
std::string version_
Definition: MSData.hpp:903
std::vector< ProcessingMethod > processingMethods
description of the default peak processing method(s). This element describes the base method used in ...
Definition: MSData.hpp:278
std::vector< Precursor > precursors
list and descriptions of precursors to the spectrum currently being described.
Definition: MSData.hpp:519
ScanSettingsPtr scanSettingsPtr
reference to a scan settings element defining global scan settings used by this configuration ...
Definition: MSData.hpp:240
IsolationWindow isolationWindow
this element captures the isolation (or &#39;selection&#39;) window configured to isolate one or more precurs...
Definition: MSData.hpp:325
boost::shared_ptr< DataProcessing > DataProcessingPtr
Definition: MSData.hpp:287
SoftwarePtr softwarePtr
this attribute MUST reference the &#39;id&#39; of the appropriate SoftwareType.
Definition: MSData.hpp:259
size_t defaultArrayLength
default length of binary data arrays contained in this element.
Definition: MSData.hpp:576
ComponentType type
the type of component (Source, Analyzer, or Detector)
Definition: MSData.hpp:133
PWIZ_API_DECL CVID getDefaultNativeIDFormat(const MSData &msd)
returns the nativeID format from the defaultSourceFilePtr if set, or from sourceFilePtrs[0] if the li...
std::string id
an identifier for this file.
Definition: MSData.hpp:56
std::string name
name of the source file, without reference to location (either URI or local path).
Definition: MSData.hpp:59
std::string externalSpectrumID
for scans that are external to this document, this string must correspond to the &#39;id&#39; attribute of a ...
Definition: MSData.hpp:376
boost::shared_ptr< ChromatogramListSimple > ChromatogramListSimplePtr
Definition: MSData.hpp:801
int order
this attribute MUST be used to indicate the order in which the components are encountered from source...
Definition: MSData.hpp:136
size_t index
the zero-based, consecutive index of the chromatogram in the ChromatogramList.
Definition: MSData.hpp:491
A single chromatogram.
Definition: MSData.hpp:573
FileDescription fileDescription
information pertaining to the entire mzML file (i.e. not specific to any part of the data set) is sto...
Definition: MSData.hpp:858
std::string id
a unique identifier across the samples with which to reference this sample description.
Definition: MSData.hpp:103
FileContent fileContent
this summarizes the different types of spectra that can be expected in the file. This is expected to ...
Definition: MSData.hpp:86
Precursor precursor
description of precursor ion information (i.e. Q1 settings)
Definition: MSData.hpp:582
std::vector< ScanSettingsPtr > scanSettingsPtrs
list with the descriptions of the acquisition settings applied prior to the start of data acquisition...
Definition: MSData.hpp:870
float lexical_cast(const std::string &str)
std::string spectrumID
for scans that are local to this document, this attribute can be used to reference the &#39;id&#39; attribute...
Definition: MSData.hpp:380
Interface for accessing spectra, which may be stored in memory or backed by a data file (RAW...
Definition: MSData.hpp:656
std::string id
an optional id for the mzML document. It is recommended to use LSIDs when possible.
Definition: MSData.hpp:851
std::string id
a unique identifier for this run.
Definition: MSData.hpp:808
DataProcessingPtr dataProcessingPtr
this optional attribute may reference the &#39;id&#39; attribute of the appropriate dataProcessing.
Definition: MSData.hpp:406
SourceFilePtr defaultSourceFilePtr
default source file reference
Definition: MSData.hpp:820
std::string id
a unique identifier for this spectrum. It should be expected that external files may use this identif...
Definition: MSData.hpp:475
PWIZ_API_DECL std::map< std::string, std::string > parse(const std::string &id)
parses an id string into a map<string,string>
size_t defaultArrayLength
default length of binary data arrays contained in this element.
Definition: MSData.hpp:507
std::string location
URI-formatted location where the file was retrieved.
Definition: MSData.hpp:62
boost::iostreams::stream_offset sourceFilePosition
for file-based MSData implementations, this attribute may refer to the spectrum&#39;s position in the fil...
Definition: MSData.hpp:481
Description of the default peak processing method. This element describes the base method used in the...
Definition: MSData.hpp:253
Information pertaining to the entire mzML file (i.e. not specific to any part of the data set) is sto...
Definition: MSData.hpp:83
std::string spectrumID
reference to the id attribute of the spectrum from which the precursor was selected.
Definition: MSData.hpp:322
int order
this attributes allows a series of consecutive steps to be placed in the correct order.
Definition: MSData.hpp:256
The data point type of a mass spectrum.
Definition: MSData.hpp:421
A run in mzML should correspond to a single, consecutive and coherent set of scans on an instrument...
Definition: MSData.hpp:805
Simple writeable in-memory implementation of ChromatogramList.
Definition: MSData.hpp:786
Run run
a run in mzML should correspond to a single, consecutive and coherent set of scans on an instrument...
Definition: MSData.hpp:882
std::string accession
an optional accession number for the mzML document.
Definition: MSData.hpp:848
std::vector< Target > targets
target list (or &#39;inclusion list&#39;) configured prior to the run.
Definition: MSData.hpp:214
value_type valueAs(const std::string &id, const std::string &name)
templated convenience function to extract a named value from an id string
Definition: MSData.hpp:922
virtual bool empty() const
returns true iff (size() == 0) and (dataProcessingPtr.get() == NULL)
Definition: MSData.hpp:720
std::string id
a unique identifier for this data processing that is unique across all DataProcessingTypes.
Definition: MSData.hpp:275
The base class for elements that may contain cvParams, userParams, or paramGroup references.
Definition: ParamTypes.hpp:244
Activation activation
the type and energy level used for activation.
Definition: MSData.hpp:331
bool hasBinaryData() const
returns true iff has nonnull and nonempty BinaryDataArrayPtr
Definition: MSData.hpp:534
std::string id
a unique identifier for this acquisition setting.
Definition: MSData.hpp:208
std::vector< ScanWindow > scanWindows
container for a list of select windows.
Definition: MSData.hpp:386
Product product
description of product ion information (i.e. Q3 settings)
Definition: MSData.hpp:585
std::string version
the software version.
Definition: MSData.hpp:184
boost::shared_ptr< SpectrumList > SpectrumListPtr
Definition: MSData.hpp:707
std::vector< Contact > contacts
structure allowing the use of a controlled (cvParam) or uncontrolled vocabulary (userParam), or a reference to a predefined set of these in this mzML file (paramGroupRef)
Definition: MSData.hpp:92
PWIZ_API_DECL std::vector< CV > defaultCVList()
virtual size_t size() const
returns the number of chromatograms
Definition: MSData.hpp:793
size_t index
the zero-based, consecutive index of the spectrum in the SpectrumList.
Definition: MSData.hpp:472
int countFiltersApplied() const
Definition: MSData.hpp:895
#define PWIZ_API_DECL
Definition: Export.hpp:32
double mz(double neutralMass, int protonDelta, int electronDelta=0, int neutronDelta=0)
Definition: Ion.hpp:78
std::vector< CV > cvs
container for one or more controlled vocabulary definitions.
Definition: MSData.hpp:855
The data point type of a chromatogram.
Definition: MSData.hpp:445
boost::iostreams::stream_offset sourceFilePosition
for file-based MSData implementations, this attribute may refer to the chromatogram&#39;s position in the...
Definition: MSData.hpp:497
A piece of software.
Definition: MSData.hpp:178
std::string startTimeStamp
the optional start timestamp of the run, in UT.
Definition: MSData.hpp:817
boost::shared_ptr< MSData > MSDataPtr
Definition: MSData.hpp:909
InstrumentConfigurationPtr instrumentConfigurationPtr
this attribute MUST reference the &#39;id&#39; attribute of the appropriate instrument configuration.
Definition: MSData.hpp:383
List with the different components used in the mass spectrometer. At least one source, one mass analyzer and one detector need to be specified.
Definition: MSData.hpp:155
std::vector< SourceFilePtr > sourceFilePtrs
container for a list of source file references.
Definition: MSData.hpp:211
This element captures the isolation (or &#39;selection&#39;) window configured to isolate one or more precurs...
Definition: MSData.hpp:291
std::string spotID
the identifier for the spot from which this spectrum was derived, if a MALDI or similar run...
Definition: MSData.hpp:478
std::vector< SamplePtr > samplePtrs
list and descriptions of samples.
Definition: MSData.hpp:864
std::vector< double > data
the binary data.
Definition: MSData.hpp:409
Description of a particular hardware configuration of a mass spectrometer. Each configuration MUST ha...
Definition: MSData.hpp:228
boost::shared_ptr< InstrumentConfiguration > InstrumentConfigurationPtr
Definition: MSData.hpp:249
std::vector< Scan > scans
Definition: MSData.hpp:396
The structure into which encoded binary data goes. Byte ordering is always little endian (Intel style...
Definition: MSData.hpp:403
virtual bool empty() const
Definition: MSData.hpp:794
std::vector< SelectedIon > selectedIons
this list of precursor ions that were selected.
Definition: MSData.hpp:328
SpectrumListPtr spectrumListPtr
all mass spectra and the acquisitions underlying them are described and attached here. Subsidiary data arrays are also both described and attached here.
Definition: MSData.hpp:823
DataProcessingPtr dataProcessingPtr
this attribute can optionally reference the &#39;id&#39; of the appropriate dataProcessing.
Definition: MSData.hpp:579
std::vector< ParamGroupPtr > paramGroupPtrs
container for a list of referenceableParamGroups
Definition: MSData.hpp:861
Identifying information for a spectrum.
Definition: MSData.hpp:469
std::vector< SpectrumPtr > spectra
Definition: MSData.hpp:714
std::vector< SoftwarePtr > softwarePtrs
list and descriptions of software used to acquire and/or process the data in this mzML file...
Definition: MSData.hpp:867
Description of the acquisition settings of the instrument prior to the start of the run...
Definition: MSData.hpp:205
std::vector< DataProcessingPtr > dataProcessingPtrs
list and descriptions of data processing applied to this data.
Definition: MSData.hpp:876
std::vector< BinaryDataArrayPtr > binaryDataArrayPtrs
list of binary data arrays.
Definition: MSData.hpp:588
List and descriptions of scans.
Definition: MSData.hpp:394
Component(ComponentType type, int order)
Definition: MSData.hpp:139
PWIZ_API_DECL bool operator==(const TruncatedLorentzianParameters &t, const TruncatedLorentzianParameters &u)
Expansible description of the sample used to generate the dataset, named in sampleName.
Definition: MSData.hpp:100
std::string externalSpectrumID
for precursor spectra that are external to this document, this string MUST correspond to the &#39;id&#39; att...
Definition: MSData.hpp:318
SourceFilePtr sourceFilePtr
this attribute can optionally reference the &#39;id&#39; of the appropriate sourceFile.
Definition: MSData.hpp:513
boost::shared_ptr< SpectrumListSimple > SpectrumListSimplePtr
Definition: MSData.hpp:727
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
MZIntensityPair(double mz, double intensity)
Definition: MSData.hpp:430
PWIZ_API_DECL std::string translateNativeIDToScanNumber(CVID nativeIDFormat, const std::string &id)
translates a nativeID in the given nativeID format to a simple integer "scan number"; some nativeID f...
Identifying information for a chromatogram.
Definition: MSData.hpp:488
Component(CVID cvid, int order)
Definition: MSData.hpp:140
boost::shared_ptr< Sample > SamplePtr
Definition: MSData.hpp:117
DataProcessingPtr dataProcessingPtr
this attribute can optionally reference the &#39;id&#39; of the appropriate dataProcessing.
Definition: MSData.hpp:510
The structure that captures the generation of a peak list (including the underlying acquisitions) ...
Definition: MSData.hpp:504
SamplePtr samplePtr
this attribute MUST reference the &#39;id&#39; of the appropriate sample.
Definition: MSData.hpp:814
This is the root element of ProteoWizard; it represents the mzML element, defined as: intended to cap...
Definition: MSData.hpp:845
std::string id
an identifier for this instrument configuration.
Definition: MSData.hpp:231
SourceFilePtr sourceFilePtr
if this attribute is set, it must reference the &#39;id&#39; attribute of a sourceFile representing the exter...
Definition: MSData.hpp:372
Simple writeable in-memory implementation of SpectrumList.
Definition: MSData.hpp:712
boost::shared_ptr< Chromatogram > ChromatogramPtr
Definition: MSData.hpp:620
boost::shared_ptr< BinaryDataArray > BinaryDataArrayPtr
Definition: MSData.hpp:416
PWIZ_API_DECL std::string translateScanNumberToNativeID(CVID nativeIDFormat, const std::string &scanNumber)
translates a "scan number" to a string that is correct for the given nativeID format; semantic validi...
represents a tag-value pair, where the tag comes from the controlled vocabulary
Definition: ParamTypes.hpp:44
std::string id
an identifier for this software that is unique across all SoftwareTypes.
Definition: MSData.hpp:181
boost::shared_ptr< SourceFile > SourceFilePtr
Description of the source file, including location and type.
Definition: MSData.hpp:75
InstrumentConfigurationPtr defaultInstrumentConfigurationPtr
this attribute MUST reference the &#39;id&#39; of the default instrument configuration. If a scan does not re...
Definition: MSData.hpp:811