OpenMS
MSExperiment.h
Go to the documentation of this file.
1 // Copyright (c) 2002-2023, The OpenMS Team -- EKU Tuebingen, ETH Zurich, and FU Berlin
2 // SPDX-License-Identifier: BSD-3-Clause
3 //
4 // --------------------------------------------------------------------------
5 // $Maintainer: Timo Sachsenberg $
6 // $Authors: Marc Sturm, Tom Waschischeck $
7 // --------------------------------------------------------------------------
8 
9 #pragma once
10 
17 
18 #include <vector>
19 
20 
21 namespace OpenMS
22 {
23  class Peak1D;
24  class ChromatogramPeak;
25 
44  class OPENMS_DLLAPI MSExperiment final : public RangeManagerContainer<RangeRT, RangeMZ, RangeIntensity, RangeMobility>,
46  {
47 
48 public:
49  typedef Peak1D PeakT;
51 
53 
54  typedef PeakT PeakType;
71  typedef std::vector<SpectrumType> Base;
73 
75 
76  typedef std::vector<SpectrumType>::iterator Iterator;
79  typedef std::vector<SpectrumType>::const_iterator ConstIterator;
85 
87  // Attention: these refer to the spectra vector only!
89  typedef Base::value_type value_type;
90  typedef Base::iterator iterator;
91  typedef Base::const_iterator const_iterator;
92 
95 
97  MSExperiment(const MSExperiment & source);
98 
101 
104 
107 
110 
112  ~MSExperiment() override;
113 
115  bool operator==(const MSExperiment & rhs) const;
116 
118  bool operator!=(const MSExperiment & rhs) const;
119 
121  inline Size size() const
122  {
123  return spectra_.size();
124  }
125 
127  inline void resize(Size n)
128  {
129  spectra_.resize(n);
130  }
131 
133  inline bool empty() const
134  {
135  return spectra_.empty();
136  }
137 
139  inline void reserve(Size n)
140  {
141  spectra_.reserve(n);
142  }
143 
146  {
147  return spectra_[n];
148  }
149 
151  inline const SpectrumType& operator[](Size n) const
152  {
153  return spectra_[n];
154  }
155 
156  inline Iterator begin()
157  {
158  return spectra_.begin();
159  }
160 
161  inline ConstIterator begin() const
162  {
163  return spectra_.begin();
164  }
165 
166  inline Iterator end()
167  {
168  return spectra_.end();
169  }
170 
171  inline ConstIterator end() const
172  {
173  return spectra_.end();
174  }
176 
177  // Aliases / chromatograms
180 
182 
183 
189  template <class Container>
190  void get2DData(Container& cont) const
191  {
192  for (typename Base::const_iterator spec = spectra_.begin(); spec != spectra_.end(); ++spec)
193  {
194  if (spec->getMSLevel() != 1)
195  {
196  continue;
197  }
198  typename Container::value_type s; // explicit object here, since instantiation within push_back() fails on VS<12
199  for (typename SpectrumType::const_iterator it = spec->begin(); it != spec->end(); ++it)
200  {
201  cont.push_back(s);
202  cont.back().setRT(spec->getRT());
203  cont.back().setMZ(it->getMZ());
204  cont.back().setIntensity(it->getIntensity());
205  }
206  }
207  }
208 
220  template <class Container>
221  void set2DData(const Container& container)
222  {
223  set2DData<false, Container>(container);
224  }
225 
240  template <class Container>
241  void set2DData(const Container& container, const StringList& store_metadata_names)
242  {
243  // clean up the container first
244  clear(true);
245  SpectrumType* spectrum = nullptr;
246  typename PeakType::CoordinateType current_rt = -std::numeric_limits<typename PeakType::CoordinateType>::max();
247  for (typename Container::const_iterator iter = container.begin(); iter != container.end(); ++iter)
248  {
249  // check if the retention time has changed
250  if (current_rt != iter->getRT() || spectrum == nullptr)
251  {
252  // append new spectrum
253  if (current_rt > iter->getRT())
254  {
255  throw Exception::Precondition(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Input container is not sorted!");
256  }
257  current_rt = iter->getRT();
258  spectrum = createSpec_(current_rt, store_metadata_names);
259  }
260 
261  // add either data point or mass traces (depending on template argument value)
262  ContainerAdd_<typename Container::value_type, false>::addData_(spectrum, &(*iter), store_metadata_names);
263  }
264  }
265 
283  template <bool add_mass_traces, class Container>
284  void set2DData(const Container& container)
285  {
286  // clean up the container first
287  clear(true);
288  SpectrumType* spectrum = nullptr;
289  typename PeakType::CoordinateType current_rt = -std::numeric_limits<typename PeakType::CoordinateType>::max();
290  for (typename Container::const_iterator iter = container.begin(); iter != container.end(); ++iter)
291  {
292  // check if the retention time has changed
293  if (current_rt != iter->getRT() || spectrum == nullptr)
294  {
295  // append new spectrum
296  if (current_rt > iter->getRT())
297  {
298  throw Exception::Precondition(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Input container is not sorted!");
299  }
300  current_rt = iter->getRT();
301  spectrum = createSpec_(current_rt);
302  }
303 
304  // add either data point or mass traces (depending on template argument value)
306  }
307  }
308 
310 
311 
313 
314  AreaIterator areaBegin(CoordinateType min_rt, CoordinateType max_rt, CoordinateType min_mz, CoordinateType max_mz, UInt ms_level = 1);
316 
318  AreaIterator areaBegin(const RangeManagerType& range, UInt ms_level = 1);
319 
322 
325 
327  ConstAreaIterator areaBeginConst(const RangeManagerType& range, UInt ms_level = 1) const;
328 
331 
332  // for fast pyOpenMS access to MS1 peak data in format: [rt, [mz, intensity]]
334  std::vector<float>& rt,
335  std::vector<std::vector<float>>& mz,
336  std::vector<std::vector<float>>& intensity) const
337  {
338  float t = -1.0;
339  for (auto it = areaBeginConst(min_rt, max_rt, min_mz, max_mz); it != areaEndConst(); ++it)
340  {
341  if (it.getRT() != t)
342  {
343  t = (float)it.getRT();
344  rt.push_back(t);
345  }
346  mz.back().push_back((float)it->getMZ());
347  intensity.back().push_back(it->getIntensity());
348  }
349  }
350 
351  // for fast pyOpenMS access to MS1 peak data in format: [rt, [mz, intensity, ion mobility]]
353  std::vector<float>& rt,
354  std::vector<std::vector<float>>& mz,
355  std::vector<std::vector<float>>& intensity,
356  std::vector<std::vector<float>>& ion_mobility) const
357  {
358  float t = -1.0;
359  for (auto it = areaBeginConst(min_rt, max_rt, min_mz, max_mz); it != areaEndConst(); ++it)
360  {
361  if (it.getRT() != t)
362  {
363  t = (float)it.getRT();
364  rt.push_back(t);
365  }
366 
367  const MSSpectrum& spectrum = it.getSpectrum();
368  bool has_IM = spectrum.containsIMData();
369  float peak_IM{-1.0f};
370  if (has_IM)
371  {
372  const auto& im_data = spectrum.getIMData();
373  const Size peak_index = it.getPeakIndex().peak;
374  if (spectrum.getFloatDataArrays()[im_data.first].size() == spectrum.size())
375  {
376  peak_IM = spectrum.getFloatDataArrays()[im_data.first][peak_index];
377  }
378  }
379  ion_mobility.back().push_back(peak_IM);
380  mz.back().push_back((float)it->getMZ());
381  intensity.back().push_back(it->getIntensity());
382  }
383  }
384 
385  // for fast pyOpenMS access to MS1 peak data in format: [rt, mz, intensity]
387  CoordinateType min_rt,
388  CoordinateType max_rt,
389  CoordinateType min_mz,
390  CoordinateType max_mz,
391  std::vector<float>& rt,
392  std::vector<float>& mz,
393  std::vector<float>& intensity) const
394  {
395  for (auto it = areaBeginConst(min_rt, max_rt, min_mz, max_mz); it != areaEndConst(); ++it)
396  {
397  rt.push_back((float)it.getRT());
398  mz.push_back((float)it->getMZ());
399  intensity.push_back(it->getIntensity());
400  }
401  }
402 
403  // for fast pyOpenMS access to MS1 peak data in format: [rt, mz, intensity, ion mobility]
405  CoordinateType min_rt,
406  CoordinateType max_rt,
407  CoordinateType min_mz,
408  CoordinateType max_mz,
409  std::vector<float>& rt,
410  std::vector<float>& mz,
411  std::vector<float>& intensity,
412  std::vector<float>& ion_mobility) const
413  {
414  for (auto it = areaBeginConst(min_rt, max_rt, min_mz, max_mz); it != areaEndConst(); ++it)
415  {
416  rt.push_back((float)it.getRT());
417  mz.push_back((float)it->getMZ());
418  intensity.push_back(it->getIntensity());
419 
420  const MSSpectrum& spectrum = it.getSpectrum();
421  bool has_IM = spectrum.containsIMData();
422  float peak_IM = -1.0;
423  if (has_IM)
424  {
425  const auto& im_data = spectrum.getIMData();
426  const Size& peak_index = it.getPeakIndex().peak;
427  if (spectrum.getFloatDataArrays()[im_data.first].size() == spectrum.size())
428  {
429  peak_IM = spectrum.getFloatDataArrays()[im_data.first][peak_index];
430  }
431  }
432  ion_mobility.push_back(peak_IM);
433  }
434  }
435 
444 
453 
460 
467 
468 
477 
487 
494  // Docu in base class
495  void updateRanges() override;
496 
502  void updateRanges(Int ms_level);
503 
506 
509 
512 
515 
517  UInt64 getSize() const;
518 
520  const std::vector<UInt>& getMSLevels() const;
521 
523 
527 
529  void setSqlRunID(UInt64 id);
530 
533 
538  void sortSpectra(bool sort_mz = true);
539 
545  void sortChromatograms(bool sort_rt = true);
546 
552  bool isSorted(bool check_mz = true) const;
553 
555 
557  void reset();
558 
565 
568 
571 
573  void getPrimaryMSRunPath(StringList& toFill) const;
574 
581 
587  int getPrecursorSpectrum(int zero_based_index) const;
588 
590  void swap(MSExperiment& from);
591 
593  void setSpectra(const std::vector<MSSpectrum>& spectra);
594  void setSpectra(std::vector<MSSpectrum>&& spectra);
595 
597  void addSpectrum(const MSSpectrum& spectrum);
598  void addSpectrum(MSSpectrum&& spectrum);
599 
601  const std::vector<MSSpectrum>& getSpectra() const;
602 
604  std::vector<MSSpectrum>& getSpectra();
605 
607  void setChromatograms(const std::vector<MSChromatogram>& chromatograms);
608  void setChromatograms(std::vector<MSChromatogram>&& chromatograms);
609 
611  void addChromatogram(const MSChromatogram& chromatogram);
613 
615  const std::vector<MSChromatogram>& getChromatograms() const;
616 
618  std::vector<MSChromatogram>& getChromatograms();
619 
621 
622  MSChromatogram& getChromatogram(Size id);
624 
627 
630 
634 
645  const MSChromatogram calculateTIC(float rt_bin_size = 0, UInt ms_level = 1) const;
646 
652  void clear(bool clear_meta_data);
653 
655  bool containsScanOfLevel(size_t ms_level) const;
656 
658  bool hasZeroIntensities(size_t ms_level) const;
659 
662 
664  bool isIMFrame() const;
665 
666  protected:
668  std::vector<UInt> ms_levels_;
672  std::vector<MSChromatogram > chromatograms_;
674  std::vector<SpectrumType> spectra_;
675 
676 private:
677 
679  template<typename ContainerValueType, bool addMassTraces>
681  {
682  static void addData_(SpectrumType* spectrum, const ContainerValueType* item);
683  static void addData_(SpectrumType* spectrum, const ContainerValueType* item, const StringList& store_metadata_names);
684  };
685 
686  template<typename ContainerValueType>
687  struct ContainerAdd_<ContainerValueType, false>
688  {
690  static void addData_(SpectrumType* spectrum, const ContainerValueType* item)
691  {
692  // create temporary peak and insert it into spectrum
693  spectrum->insert(spectrum->end(), PeakType());
694  spectrum->back().setIntensity(item->getIntensity());
695  spectrum->back().setPosition(item->getMZ());
696  }
698  static void addData_(SpectrumType* spectrum, const ContainerValueType* item, const StringList& store_metadata_names)
699  {
700  addData_(spectrum, item);
701  for (StringList::const_iterator itm = store_metadata_names.begin(); itm != store_metadata_names.end(); ++itm)
702  {
703  float val = std::numeric_limits<float>::quiet_NaN();
704  if (item->metaValueExists(*itm)) val = item->getMetaValue(*itm);
705  spectrum->getFloatDataArrays()[itm - store_metadata_names.begin()].push_back(val);
706  }
707  }
708  };
709 
710  template<typename ContainerValueType>
711  struct ContainerAdd_<ContainerValueType, true>
712  {
714  static void addData_(SpectrumType* spectrum, const ContainerValueType* item)
715  {
716  if (item->metaValueExists("num_of_masstraces"))
717  {
718  Size mts = item->getMetaValue("num_of_masstraces");
719  int charge = (item->getCharge()==0 ? 1 : item->getCharge()); // set to 1 if charge is 0, otherwise div/0 below
720  for (Size i = 0; i < mts; ++i)
721  {
722  String meta_name = String("masstrace_intensity_") + i;
723  if (!item->metaValueExists(meta_name))
724  {
725  throw Exception::Precondition(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, String("Meta value '") + meta_name + "' expected but not found in container.");
726  }
727  ContainerValueType p;
728  p.setIntensity(item->getMetaValue(meta_name));
729  p.setPosition(item->getMZ() + Constants::C13C12_MASSDIFF_U / charge * i);
731  }
732  }
734  }
735  };
736 
737  /*
738  @brief Append a spectrum to current MSExperiment
739 
740  @param rt RT of new spectrum
741  @return Pointer to newly created spectrum
742  */
744 
745  /*
746  @brief Append a spectrum including floatdata arrays to current MSExperiment
747 
748  @param rt RT of new spectrum
749  @param metadata_names Names of floatdata arrays attached to this spectrum
750  @return Pointer to newly created spectrum
751  */
753 
754  };
755 
757  OPENMS_DLLAPI std::ostream& operator<<(std::ostream& os, const MSExperiment& exp);
758 
759 } // namespace OpenMS
760 
762 
763 
A 1-dimensional raw data point or peak for chromatograms.
Definition: ChromatogramPeak.h:28
Precondition failed exception.
Definition: Exception.h:133
Description of the experimental settings.
Definition: ExperimentalSettings.h:36
Forward iterator for an area of peaks in an experiment.
Definition: AreaIterator.h:36
The representation of a chromatogram.
Definition: MSChromatogram.h:31
In-Memory representation of a mass spectrometry run.
Definition: MSExperiment.h:46
const std::vector< UInt > & getMSLevels() const
returns an array of MS levels
const ExperimentalSettings & getExperimentalSettings() const
returns the meta information of this experiment (const access)
MSExperiment(MSExperiment &&)=default
Move constructor.
ConstIterator IMBegin(CoordinateType im) const
Fast search for spectrum range begin.
std::vector< SpectrumType > spectra_
spectra
Definition: MSExperiment.h:674
const std::vector< MSChromatogram > & getChromatograms() const
returns the chromatogram list
std::vector< SpectrumType > Base
STL base class type.
Definition: MSExperiment.h:71
void setChromatograms(std::vector< MSChromatogram > &&chromatograms)
Base::iterator iterator
Definition: MSExperiment.h:90
bool containsScanOfLevel(size_t ms_level) const
returns true if at least one of the spectra has the specified level
ConstAreaIterator areaBeginConst(CoordinateType min_rt, CoordinateType max_rt, CoordinateType min_mz, CoordinateType max_mz, UInt ms_level=1) const
Returns a non-mutable area iterator for area.
~MSExperiment() override
D'tor.
PeakType::CoordinateType CoordinateType
Coordinate type of peak positions.
Definition: MSExperiment.h:59
void get2DData(Container &cont) const
Reads out a 2D Spectrum.
Definition: MSExperiment.h:190
void swap(MSExperiment &from)
Swaps the content of this map with the content of from.
MSChromatogram ChromatogramType
Chromatogram type.
Definition: MSExperiment.h:69
void addSpectrum(const MSSpectrum &spectrum)
adds a spectrum to the list
PeakType::IntensityType IntensityType
Intensity type of peaks.
Definition: MSExperiment.h:61
Iterator begin()
Definition: MSExperiment.h:156
void set2DData(const Container &container, const StringList &store_metadata_names)
Assignment of a data container with RT and MZ to an MSExperiment.
Definition: MSExperiment.h:241
std::vector< SpectrumType >::iterator Iterator
Mutable iterator.
Definition: MSExperiment.h:77
bool clearMetaDataArrays()
Clears the meta data arrays of all contained spectra (float, integer and string arrays)
SpectrumType * createSpec_(PeakType::CoordinateType rt)
ConstAreaIterator areaBeginConst(const RangeManagerType &range, UInt ms_level=1) const
Returns a non-mutable area iterator for all peaks in range. If a dimension is empty(),...
ConstIterator RTBegin(CoordinateType rt) const
Fast search for spectrum range begin.
Size getNrSpectra() const
get the total number of spectra available
UInt64 getSize() const
returns the total number of peaks
MSExperiment & operator=(MSExperiment &&) &=default
Move assignment operator.
ConstIterator RTEnd(CoordinateType rt) const
Fast search for spectrum range end (returns the past-the-end iterator)
RangeManagerContainer< RangeRT, RangeMZ, RangeIntensity, RangeMobility > RangeManagerContainerType
RangeManager type.
Definition: MSExperiment.h:65
void addChromatogram(MSChromatogram &&chrom)
ExperimentalSettings & getExperimentalSettings()
returns the meta information of this experiment (mutable access)
void reserveSpaceChromatograms(Size s)
void get2DPeakData(CoordinateType min_rt, CoordinateType max_rt, CoordinateType min_mz, CoordinateType max_mz, std::vector< float > &rt, std::vector< std::vector< float >> &mz, std::vector< std::vector< float >> &intensity, std::vector< std::vector< float >> &ion_mobility) const
Definition: MSExperiment.h:352
SpectrumType * createSpec_(PeakType::CoordinateType rt, const StringList &metadata_names)
ChromatogramPeakT ChromatogramPeakType
Chromatogram peak type.
Definition: MSExperiment.h:57
MSSpectrum & getSpectrum(Size id)
returns a single spectrum
void get2DPeakDataIon(CoordinateType min_rt, CoordinateType max_rt, CoordinateType min_mz, CoordinateType max_mz, std::vector< float > &rt, std::vector< float > &mz, std::vector< float > &intensity, std::vector< float > &ion_mobility) const
Definition: MSExperiment.h:404
CoordinateType getMinMZ() const
returns the minimal m/z value
AreaIterator areaBegin(const RangeManagerType &range, UInt ms_level=1)
Returns a area iterator for all peaks in range. If a dimension is empty(), it is ignored (i....
Iterator RTEnd(CoordinateType rt)
Fast search for spectrum range end (returns the past-the-end iterator)
MSExperiment & operator=(const MSExperiment &source)
Assignment operator.
MSSpectrum SpectrumType
Spectrum Type.
Definition: MSExperiment.h:67
bool empty() const
Are there any spectra (does not consider chromatograms)
Definition: MSExperiment.h:133
Size getNrChromatograms() const
get the total number of chromatograms available
ConstIterator end() const
Definition: MSExperiment.h:171
CoordinateType getMaxRT() const
returns the maximal retention time value
void get2DPeakData(CoordinateType min_rt, CoordinateType max_rt, CoordinateType min_mz, CoordinateType max_mz, std::vector< float > &rt, std::vector< std::vector< float >> &mz, std::vector< std::vector< float >> &intensity) const
Definition: MSExperiment.h:333
Base::value_type value_type
Definition: MSExperiment.h:89
MSExperiment()
Constructor.
bool operator!=(const MSExperiment &rhs) const
Equality operator.
CoordinateType getMaxMZ() const
returns the maximal m/z value
Peak1D PeakT
Definition: MSExperiment.h:49
ConstAreaIterator areaEndConst() const
Returns an non-mutable invalid area iterator marking the end of an area.
void set2DData(const Container &container)
Assignment of a data container with RT and MZ to an MSExperiment.
Definition: MSExperiment.h:221
void setSpectra(std::vector< MSSpectrum > &&spectra)
void getPrimaryMSRunPath(StringList &toFill) const
get the file path to the first MS run
std::vector< UInt > ms_levels_
MS levels of the data.
Definition: MSExperiment.h:668
void resize(Size n)
Resize to n spectra.
Definition: MSExperiment.h:127
std::vector< MSChromatogram > & getChromatograms()
returns the chromatogram list (mutable)
void setSpectra(const std::vector< MSSpectrum > &spectra)
sets the spectrum list
void updateRanges(Int ms_level)
Updates the m/z, intensity, retention time and MS level ranges of all spectra with a certain ms level...
void get2DPeakData(CoordinateType min_rt, CoordinateType max_rt, CoordinateType min_mz, CoordinateType max_mz, std::vector< float > &rt, std::vector< float > &mz, std::vector< float > &intensity) const
Definition: MSExperiment.h:386
void sortChromatograms(bool sort_rt=true)
Sorts the data points of the chromatograms by m/z.
Iterator RTBegin(CoordinateType rt)
Fast search for spectrum range begin.
Internal::AreaIterator< const PeakT, const PeakT &, const PeakT *, ConstIterator, SpectrumType::ConstIterator > ConstAreaIterator
Immutable area iterator type (for traversal of a rectangular subset of the peaks)
Definition: MSExperiment.h:83
void setChromatograms(const std::vector< MSChromatogram > &chromatograms)
sets the chromatogram list
Internal::AreaIterator< PeakT, PeakT &, PeakT *, Iterator, SpectrumType::Iterator > AreaIterator
Mutable area iterator type (for traversal of a rectangular subset of the peaks)
Definition: MSExperiment.h:81
CoordinateType getMinRT() const
returns the minimal retention time value
const SpectrumType & operator[](Size n) const
Random access to n'th spectrum.
Definition: MSExperiment.h:151
const MSChromatogram calculateTIC(float rt_bin_size=0, UInt ms_level=1) const
Computes the total ion chromatogram (TIC) for a given MS level (use ms_level = 0 for all levels).
const std::vector< MSSpectrum > & getSpectra() const
returns the spectrum list
Iterator end()
Definition: MSExperiment.h:166
UInt64 total_size_
Number of all data points.
Definition: MSExperiment.h:670
bool isSorted(bool check_mz=true) const
Checks if all spectra are sorted with respect to ascending RT.
MSExperiment(const MSExperiment &source)
Copy constructor.
RangeManager< RangeRT, RangeMZ, RangeIntensity, RangeMobility > RangeManagerType
RangeManager type.
Definition: MSExperiment.h:63
std::vector< MSSpectrum > & getSpectra()
returns the spectrum list (mutable)
void set2DData(const Container &container)
Assignment of a data container with RT and MZ to an MSExperiment.
Definition: MSExperiment.h:284
ChromatogramPeak ChromatogramPeakT
Definition: MSExperiment.h:50
void sortSpectra(bool sort_mz=true)
Sorts the data points by retention time.
Size size() const
The number of spectra.
Definition: MSExperiment.h:121
void reset()
Clear all internal data (spectra, ranges, metadata)
ConstIterator begin() const
Definition: MSExperiment.h:161
void addSpectrum(MSSpectrum &&spectrum)
void reserveSpaceSpectra(Size s)
bool hasZeroIntensities(size_t ms_level) const
returns true if any MS spectra of trthe specified level contain at least one peak with intensity of 0...
bool operator==(const MSExperiment &rhs) const
Equality operator.
ConstIterator IMEnd(CoordinateType im) const
Fast search for spectrum range end (returns the past-the-end iterator)
ConstIterator getPrecursorSpectrum(ConstIterator iterator) const
Returns the precursor spectrum of the scan pointed to by iterator.
void reserve(Size n)
Reserve space for n spectra.
Definition: MSExperiment.h:139
Base::const_iterator const_iterator
Definition: MSExperiment.h:91
void updateRanges() override
void setSqlRunID(UInt64 id)
sets the run-ID which is used when storing an sqMass file
MSExperiment & operator=(const ExperimentalSettings &source)
Assignment operator.
UInt64 getSqlRunID() const
void addChromatogram(const MSChromatogram &chromatogram)
adds a chromatogram to the list
std::vector< SpectrumType >::const_iterator ConstIterator
Non-mutable iterator.
Definition: MSExperiment.h:79
bool hasPeptideIdentifications() const
do any of the spectra have a PeptideID?
void clear(bool clear_meta_data)
Clears all data and meta data.
SpectrumType & operator[](Size n)
Random access to n'th spectrum.
Definition: MSExperiment.h:145
int getPrecursorSpectrum(int zero_based_index) const
Returns the index of the precursor spectrum for spectrum at index zero_based_index.
std::vector< MSChromatogram > chromatograms_
chromatograms
Definition: MSExperiment.h:672
AreaIterator areaEnd()
Returns an invalid area iterator marking the end of an area.
bool isIMFrame() const
Are all MSSpectra in this experiment part of an IM Frame? I.e. they all have the same RT,...
The representation of a 1D spectrum.
Definition: MSSpectrum.h:44
bool containsIMData() const
std::pair< Size, DriftTimeUnit > getIMData() const
Get the Ion mobility data array's index and its associated unit.
const FloatDataArrays & getFloatDataArrays() const
Returns a const reference to the float meta data arrays.
A 1-dimensional raw data point or peak.
Definition: Peak1D.h:28
double CoordinateType
Coordinate type.
Definition: Peak1D.h:40
float IntensityType
Intensity type.
Definition: Peak1D.h:36
Definition: RangeManager.h:872
A more convenient string class.
Definition: String.h:34
OPENMS_UINT64_TYPE UInt64
Unsigned integer type (64bit)
Definition: Types.h:51
int Int
Signed integer type.
Definition: Types.h:76
unsigned int UInt
Unsigned integer type.
Definition: Types.h:68
size_t Size
Size type e.g. used as variable which can hold result of size()
Definition: Types.h:101
std::vector< String > StringList
Vector of String.
Definition: ListUtils.h:44
const double C13C12_MASSDIFF_U
Definition: Constants.h:95
Main OpenMS namespace.
Definition: FeatureDeconvolution.h:22
Peak2D PeakType
Definition: MassTrace.h:21
std::ostream & operator<<(std::ostream &os, const AccurateMassSearchResult &amsr)
static void addData_(SpectrumType *spectrum, const ContainerValueType *item)
general method for adding data points
Definition: MSExperiment.h:690
static void addData_(SpectrumType *spectrum, const ContainerValueType *item, const StringList &store_metadata_names)
general method for adding data points, including metadata arrays (populated from metainfointerface)
Definition: MSExperiment.h:698
static void addData_(SpectrumType *spectrum, const ContainerValueType *item)
specialization for adding feature mass traces (does not support metadata_names currently)
Definition: MSExperiment.h:714
Helper class to add either general data points in set2DData or use mass traces from meta values.
Definition: MSExperiment.h:681
static void addData_(SpectrumType *spectrum, const ContainerValueType *item)
static void addData_(SpectrumType *spectrum, const ContainerValueType *item, const StringList &store_metadata_names)