ProteoWizard
MSData.hpp
Go to the documentation of this file.
1 //
2 // $Id: MSData.hpp 4584 2013-05-24 19:37:52Z 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.
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.
238 
239  /// reference to a scan settings element defining global scan settings used by this configuration
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.
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
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.
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.
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.
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
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.
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.
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.
511 
512  /// this attribute can optionally reference the 'id' of the appropriate sourceFile.
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 
564 
565 typedef boost::shared_ptr<Spectrum> SpectrumPtr;
566 
567 
568 /// A single chromatogram.
570 {
571  /// default length of binary data arrays contained in this element.
573 
574  /// this attribute can optionally reference the 'id' of the appropriate dataProcessing.
576 
577  /// description of precursor ion information (i.e. Q1 settings)
579 
580  /// description of product ion information (i.e. Q3 settings)
582 
583  /// list of binary data arrays.
584  std::vector<BinaryDataArrayPtr> binaryDataArrayPtrs;
585 
586  Chromatogram() : defaultArrayLength(0) {}
587 
588  /// returns true iff the element contains no params and all members are empty or null
589  bool empty() const;
590 
591  /// copy binary data arrays into time-intensity pair array
592  void getTimeIntensityPairs(std::vector<TimeIntensityPair>& output) const;
593 
594  /// copy binary data arrays into time-intensity pair array
595  /// note: this overload is to allow client to allocate own buffer; the client
596  /// must determine the correct size beforehand, or an exception will be thrown
597  void getTimeIntensityPairs(TimeIntensityPair* output, size_t expectedSize) const;
598 
599  /// get time array (may be null)
600  BinaryDataArrayPtr getTimeArray() const;
601 
602  /// get intensity array (may be null)
603  BinaryDataArrayPtr getIntensityArray() const;
604 
605  /// set binary data arrays
606  void setTimeIntensityPairs(const std::vector<TimeIntensityPair>& input, CVID timeUnits, CVID intensityUnits);
607 
608  /// set binary data arrays
609  void setTimeIntensityPairs(const TimeIntensityPair* input, size_t size, CVID timeUnits, CVID intensityUnits);
610 
611  /// set time and intensity arrays separately (they must be the same size)
612  void setTimeIntensityArrays(const std::vector<double>& timeArray, const std::vector<double>& intensityArray, CVID timeUnits, CVID intensityUnits);
613 };
614 
615 
616 typedef boost::shared_ptr<Chromatogram> ChromatogramPtr;
617 
618 
619 // note: derived container to support dynamic linking on Windows
620 class IndexList : public std::vector<size_t> {};
621 
623 {
628 };
629 
630 ///
631 /// Interface for accessing spectra, which may be stored in memory
632 /// or backed by a data file (RAW, mzXML, mzML).
633 ///
634 /// Implementation notes:
635 ///
636 /// - Implementations are expected to keep a spectrum index in the form of
637 /// vector<SpectrumIdentity> or equivalent. The default find*() functions search
638 /// the index linearly. Implementations may provide constant time indexing.
639 ///
640 /// - The semantics of spectrum() may vary slightly with implementation. In particular,
641 /// a SpectrumList implementation that is backed by a file may choose either to cache
642 /// or discard the SpectrumPtrs for future access, with the caveat that the client
643 /// may write to the underlying data.
644 ///
645 /// - It is the implementation's responsibility to return a valid SpectrumPtr from spectrum().
646 /// If this cannot be done, an exception must be thrown.
647 ///
648 /// - The 'getBinaryData' flag is a hint if false : implementations may provide valid
649 /// BinaryDataArrayPtrs on spectrum(index, false); implementations *must* provide
650 /// valid BinaryDataArrayPtrs on spectrum(index, true).
651 ///
653 {
654  public:
655 
656  /// returns the number of spectra
657  virtual size_t size() const = 0;
658 
659  /// returns true iff (size() == 0) and (dataProcessingPtr.get() == NULL)
660  virtual bool empty() const;
661 
662  /// access to a spectrum index
663  virtual const SpectrumIdentity& spectrumIdentity(size_t index) const = 0;
664 
665  /// find id in the spectrum index (returns size() on failure)
666  virtual size_t find(const std::string& id) const;
667 
668  /// find all spectrum indexes with specified name/value pair
669  virtual IndexList findNameValue(const std::string& name, const std::string& value) const;
670 
671  /// find all spectrum indexes with spotID (returns empty vector on failure)
672  virtual IndexList findSpotID(const std::string& spotID) const;
673 
674  /// retrieve a spectrum by index
675  /// - binary data arrays will be provided if (getBinaryData == true);
676  /// - client may assume the underlying Spectrum* is valid
677  virtual SpectrumPtr spectrum(size_t index, bool getBinaryData = false) const = 0;
678 
679  /// get a copy of the seed spectrum, optionally with its binary data populated
680  /// this is useful for formats like mzML that can delay loading of binary data
681  /// - client may assume the underlying Spectrum* is valid
682  virtual SpectrumPtr spectrum(const SpectrumPtr &seed, bool getBinaryData) const {
683  return spectrum(seed->index, getBinaryData); // default implementation
684  };
685 
686  /// retrieve a spectrum by index
687  /// - detailLevel determines what fields are guaranteed present on the spectrum after the call
688  /// - client may assume the underlying Spectrum* is valid
689  virtual SpectrumPtr spectrum(size_t index, DetailLevel detailLevel) const
690  {
691  // By default faster metadeta access is not implemented
692  if (detailLevel == DetailLevel_FastMetadata || detailLevel == DetailLevel_InstantMetadata)
693  return SpectrumPtr(new Spectrum);
694 
695  return spectrum(index, detailLevel == DetailLevel_FullData);
696  }
697 
698  /// returns the data processing affecting spectra retrieved through this interface
699  /// - may return a null shared pointer
700  virtual const boost::shared_ptr<const DataProcessing> dataProcessingPtr() const;
701 
702  /// makes it easy to issue simple warnings without repeats (based on string hash)
703  void warn_once(const char *msg) const;
704 
705  virtual ~SpectrumList(){}
706 
707 private:
708  mutable std::set<size_t> warn_msg_hashes; // for warn_once use
709 };
710 
711 
712 typedef boost::shared_ptr<SpectrumList> SpectrumListPtr;
713 
714 
715 /// Simple writeable in-memory implementation of SpectrumList.
716 /// Note: This spectrum() implementation returns internal SpectrumPtrs.
718 {
719  std::vector<SpectrumPtr> spectra;
721 
722  // SpectrumList implementation
723 
724  virtual size_t size() const {return spectra.size();}
725  virtual bool empty() const {return spectra.empty() && !dp.get();}
726  virtual const SpectrumIdentity& spectrumIdentity(size_t index) const;
727  virtual SpectrumPtr spectrum(size_t index, bool getBinaryData) const;
728  virtual const boost::shared_ptr<const DataProcessing> dataProcessingPtr() const;
729 };
730 
731 
732 typedef boost::shared_ptr<SpectrumListSimple> SpectrumListSimplePtr;
733 
734 
735 ///
736 /// Interface for accessing chromatograms, which may be stored in memory
737 /// or backed by a data file (RAW, mzXML, mzML).
738 ///
739 /// Implementation notes:
740 ///
741 /// - Implementations are expected to keep a chromatogram index in the form of
742 /// vector<ChromatogramIdentity> or equivalent. The default find*() functions search
743 /// the index linearly. Implementations may provide constant time indexing.
744 ///
745 /// - The semantics of chromatogram() may vary slightly with implementation. In particular,
746 /// a ChromatogramList implementation that is backed by a file may choose either to cache
747 /// or discard the ChromatogramPtrs for future access, with the caveat that the client
748 /// may write to the underlying data.
749 ///
750 /// - It is the implementation's responsibility to return a valid ChromatogramPtr from chromatogram().
751 /// If this cannot be done, an exception must be thrown.
752 ///
753 /// - The 'getBinaryData' flag is a hint if false : implementations may provide valid
754 /// BinaryDataArrayPtrs on chromatogram(index, false); implementations *must* provide
755 /// valid BinaryDataArrayPtrs on chromatogram(index, true).
756 ///
758 {
759  public:
760 
761  /// returns the number of chromatograms
762  virtual size_t size() const = 0;
763 
764  /// returns true iff (size() == 0) and (dataProcessingPtr.get() == NULL)
765  bool empty() const;
766 
767  /// access to a chromatogram index
768  virtual const ChromatogramIdentity& chromatogramIdentity(size_t index) const = 0;
769 
770  /// find id in the chromatogram index (returns size() on failure)
771  virtual size_t find(const std::string& id) const;
772 
773  /// retrieve a chromatogram by index
774  /// - binary data arrays will be provided if (getBinaryData == true);
775  /// - client may assume the underlying Chromatogram* is valid
776  virtual ChromatogramPtr chromatogram(size_t index, bool getBinaryData = false) const = 0;
777 
778  /// returns the data processing affecting spectra retrieved through this interface
779  /// - may return a null shared pointer
780  virtual const boost::shared_ptr<const DataProcessing> dataProcessingPtr() const;
781 
782  virtual ~ChromatogramList(){}
783 };
784 
785 
786 typedef boost::shared_ptr<ChromatogramList> ChromatogramListPtr;
787 
788 
789 /// Simple writeable in-memory implementation of ChromatogramList.
790 /// Note: This chromatogram() implementation returns internal ChromatogramPtrs.
792 {
793  std::vector<ChromatogramPtr> chromatograms;
795 
796  // ChromatogramList implementation
797 
798  virtual size_t size() const {return chromatograms.size();}
799  virtual bool empty() const {return chromatograms.empty() && !dp.get();}
800  virtual const ChromatogramIdentity& chromatogramIdentity(size_t index) const;
801  virtual ChromatogramPtr chromatogram(size_t index, bool getBinaryData) const;
802  virtual const boost::shared_ptr<const DataProcessing> dataProcessingPtr() const;
803 };
804 
805 
806 typedef boost::shared_ptr<ChromatogramListSimple> ChromatogramListSimplePtr;
807 
808 
809 /// A run in mzML should correspond to a single, consecutive and coherent set of scans on an instrument.
811 {
812  /// a unique identifier for this run.
813  std::string id;
814 
815  /// 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.
817 
818  /// this attribute MUST reference the 'id' of the appropriate sample.
820 
821  /// the optional start timestamp of the run, in UT.
822  std::string startTimeStamp;
823 
824  /// default source file reference
826 
827  /// all mass spectra and the acquisitions underlying them are described and attached here. Subsidiary data arrays are also both described and attached here.
829 
830  /// all chromatograms for this run.
832 
833  Run(){}
834  bool empty() const;
835 
836  private:
837  // no copying - any implementation must handle:
838  // - SpectrumList cloning
839  // - internal cross-references to heap-allocated objects
840  Run(const Run&);
841  Run& operator=(const Run&);
842 };
843 
844 
845 namespace IO {struct HandlerMSData;} // forward declaration for friend
846 
847 
848 /// This is the root element of ProteoWizard; it represents the mzML element, defined as:
849 /// 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).
851 {
852  /// an optional accession number for the mzML document.
853  std::string accession;
854 
855  /// an optional id for the mzML document. It is recommended to use LSIDs when possible.
856  std::string id;
857 
858  /// container for one or more controlled vocabulary definitions.
859  /// 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.
860  std::vector<CV> cvs;
861 
862  /// information pertaining to the entire mzML file (i.e. not specific to any part of the data set) is stored here.
864 
865  /// container for a list of referenceableParamGroups
866  std::vector<ParamGroupPtr> paramGroupPtrs;
867 
868  /// list and descriptions of samples.
869  std::vector<SamplePtr> samplePtrs;
870 
871  /// list and descriptions of software used to acquire and/or process the data in this mzML file.
872  std::vector<SoftwarePtr> softwarePtrs;
873 
874  /// list with the descriptions of the acquisition settings applied prior to the start of data acquisition.
875  std::vector<ScanSettingsPtr> scanSettingsPtrs;
876 
877  /// list and descriptions of instrument configurations.
878  std::vector<InstrumentConfigurationPtr> instrumentConfigurationPtrs;
879 
880  /// list and descriptions of data processing applied to this data.
881  std::vector<DataProcessingPtr> dataProcessingPtrs;
882 
883  /// return dataProcessingPtrs augmented by the dataProcessingPtr() set in SpectrumList and/or ChromatogramList
884  std::vector<DataProcessingPtr> allDataProcessingPtrs() const;
885 
886  /// a run in mzML should correspond to a single, consecutive and coherent set of scans on an instrument.
888 
889  MSData();
890  virtual ~MSData();
891  bool empty() const;
892 
893  /// returns the version of this mzML document;
894  /// for a document created programmatically, the version is the current release version of mzML;
895  /// for a document created from a file/stream, the version is the schema version read from the file/stream
896  const std::string& version() const;
897 
898  // for detecting out of order filters
899  void filterApplied() {nFiltersApplied_++;};
900  int countFiltersApplied() const {return nFiltersApplied_;};
901 
902  private:
903  // no copying
904  MSData(const MSData&);
905  MSData& operator=(const MSData&);
906 
907  protected:
908  std::string version_; // schema version read from the file/stream
909  friend struct IO::HandlerMSData;
910  int nFiltersApplied_; // useful for flagging filters that need to be first, like vendor centroiding
911 };
912 
913 
914 typedef boost::shared_ptr<MSData> MSDataPtr;
915 
916 
917 namespace id {
918 
919 /// parses an id string into a map<string,string>
920 PWIZ_API_DECL std::map<std::string,std::string> parse(const std::string& id);
921 
922 /// convenience function to extract a named value from an id string
923 PWIZ_API_DECL std::string value(const std::string& id, const std::string& name);
924 
925 /// templated convenience function to extract a named value from an id string
926 template<typename value_type>
927 value_type valueAs(const std::string& id, const std::string& name)
928 {
929  std::string result = value(id, name);
930  return !result.empty() ? boost::lexical_cast<value_type>(result)
931  : boost::lexical_cast<value_type>(0);
932 }
933 
934 /// returns the nativeID format from the defaultSourceFilePtr if set,
935 /// or from sourceFilePtrs[0] if the list isn't empty,
936 /// or CVID_Unknown
938 
939 /// translates a "scan number" to a string that is correct for the given nativeID format;
940 /// semantic validity requires that scanNumber be parseable as an integer;
941 /// some nativeID formats cannot be translated to 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 translateScanNumberToNativeID(CVID nativeIDFormat, const std::string& scanNumber);
944 
945 /// translates a nativeID in the given nativeID format to a simple integer "scan number";
946 /// some nativeID formats cannot be translated from and will always return an empty string
947 /// currently supported formats: Thermo, Bruker/Agilent YEP, Bruker BAF, mzXML, MGF, and mzData
948 PWIZ_API_DECL std::string translateNativeIDToScanNumber(CVID nativeIDFormat, const std::string& id);
949 
950 /// abbreviates a nativeID ("name1=value1 name2=value2" translates to "value1.value2")
951 PWIZ_API_DECL std::string abbreviate(const std::string& id, char delimiter = '.');
952 
953 } // namespace id
954 
955 
956 } // namespace msdata
957 } // namespace pwiz
958 
959 
960 #endif // _MSDATA_HPP_
961 
IsolationWindow isolationWindow
this element captures the isolation (or 'selection') 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
virtual SpectrumPtr spectrum(const SpectrumPtr &seed, bool getBinaryData) const
get a copy of the seed spectrum, optionally with its binary data populated this is useful for formats...
Definition: MSData.hpp:682
Interface for accessing chromatograms, which may be stored in memory or backed by a data file (RAW...
Definition: MSData.hpp:757
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
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
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:878
The method of precursor ion selection and activation.
Definition: MSData.hpp:310
ChromatogramListPtr chromatogramListPtr
all chromatograms for this run.
Definition: MSData.hpp:831
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 'id' 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:793
boost::shared_ptr< Spectrum > SpectrumPtr
Definition: MSData.hpp:565
boost::shared_ptr< ChromatogramList > ChromatogramListPtr
Definition: MSData.hpp:786
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:908
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 'selection') 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 'id' of the appropriate SoftwareType.
Definition: MSData.hpp:259
size_t defaultArrayLength
default length of binary data arrays contained in this element.
Definition: MSData.hpp:572
std::set< size_t > warn_msg_hashes
Definition: MSData.hpp:708
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 'id' attribute of a ...
Definition: MSData.hpp:376
bool hasBinaryData() const
returns true iff has nonnull and nonempty BinaryDataArrayPtr
Definition: MSData.hpp:534
boost::shared_ptr< ChromatogramListSimple > ChromatogramListSimplePtr
Definition: MSData.hpp:806
PWIZ_API_DECL std::string abbreviate(const std::string &id, char delimiter= '.')
abbreviates a nativeID ("name1=value1 name2=value2" translates to "value1.value2") ...
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:569
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:863
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:578
std::vector< ScanSettingsPtr > scanSettingsPtrs
list with the descriptions of the acquisition settings applied prior to the start of data acquisition...
Definition: MSData.hpp:875
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 'id' 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:652
std::string id
an optional id for the mzML document. It is recommended to use LSIDs when possible.
Definition: MSData.hpp:856
std::string id
a unique identifier for this run.
Definition: MSData.hpp:813
DataProcessingPtr dataProcessingPtr
this optional attribute may reference the 'id' attribute of the appropriate dataProcessing.
Definition: MSData.hpp:406
SourceFilePtr defaultSourceFilePtr
default source file reference
Definition: MSData.hpp:825
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'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:810
Simple writeable in-memory implementation of ChromatogramList.
Definition: MSData.hpp:791
Run run
a run in mzML should correspond to a single, consecutive and coherent set of scans on an instrument...
Definition: MSData.hpp:887
std::string accession
an optional accession number for the mzML document.
Definition: MSData.hpp:853
std::vector< Target > targets
target list (or 'inclusion list') 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:927
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:241
Activation activation
the type and energy level used for activation.
Definition: MSData.hpp:331
virtual bool empty() const
returns true iff (size() == 0) and (dataProcessingPtr.get() == NULL)
Definition: MSData.hpp:725
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:581
std::string version
the software version.
Definition: MSData.hpp:184
boost::shared_ptr< SpectrumList > SpectrumListPtr
Definition: MSData.hpp:712
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()
size_t index
the zero-based, consecutive index of the spectrum in the SpectrumList.
Definition: MSData.hpp:472
#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:860
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'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:822
boost::shared_ptr< MSData > MSDataPtr
Definition: MSData.hpp:914
InstrumentConfigurationPtr instrumentConfigurationPtr
this attribute MUST reference the 'id' 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
virtual size_t size() const
returns the number of spectra
Definition: MSData.hpp:724
virtual bool empty() const
Definition: MSData.hpp:799
This element captures the isolation (or 'selection') 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:869
std::vector< double > data
the binary data.
Definition: MSData.hpp:409
virtual size_t size() const
returns the number of chromatograms
Definition: MSData.hpp:798
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
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:828
DataProcessingPtr dataProcessingPtr
this attribute can optionally reference the 'id' of the appropriate dataProcessing.
Definition: MSData.hpp:575
std::vector< ParamGroupPtr > paramGroupPtrs
container for a list of referenceableParamGroups
Definition: MSData.hpp:866
Identifying information for a spectrum.
Definition: MSData.hpp:469
std::vector< SpectrumPtr > spectra
Definition: MSData.hpp:719
std::vector< SoftwarePtr > softwarePtrs
list and descriptions of software used to acquire and/or process the data in this mzML file...
Definition: MSData.hpp:872
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:881
std::vector< BinaryDataArrayPtr > binaryDataArrayPtrs
list of binary data arrays.
Definition: MSData.hpp:584
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 'id' att...
Definition: MSData.hpp:318
SourceFilePtr sourceFilePtr
this attribute can optionally reference the 'id' of the appropriate sourceFile.
Definition: MSData.hpp:513
boost::shared_ptr< SpectrumListSimple > SpectrumListSimplePtr
Definition: MSData.hpp:732
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
int countFiltersApplied() const
Definition: MSData.hpp:900
DataProcessingPtr dataProcessingPtr
this attribute can optionally reference the 'id' 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
virtual SpectrumPtr spectrum(size_t index, DetailLevel detailLevel) const
retrieve a spectrum by index
Definition: MSData.hpp:689
SamplePtr samplePtr
this attribute MUST reference the 'id' of the appropriate sample.
Definition: MSData.hpp:819
This is the root element of ProteoWizard; it represents the mzML element, defined as: intended to cap...
Definition: MSData.hpp:850
std::string id
an identifier for this instrument configuration.
Definition: MSData.hpp:231
SourceFilePtr sourceFilePtr
if this attribute is set, it must reference the 'id' attribute of a sourceFile representing the exter...
Definition: MSData.hpp:372
Simple writeable in-memory implementation of SpectrumList.
Definition: MSData.hpp:717
boost::shared_ptr< Chromatogram > ChromatogramPtr
Definition: MSData.hpp:616
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 'id' of the default instrument configuration. If a scan does not re...
Definition: MSData.hpp:816