OpenMS
MassTrace.h
Go to the documentation of this file.
1 // Copyright (c) 2002-present, 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: Erhan Kenar, Holger Franken, Chris Bielow $
7 // --------------------------------------------------------------------------
8 
9 #pragma once
10 
11 #include <OpenMS/KERNEL/Peak2D.h>
13 
14 
15 #include <vector>
16 #include <list>
17 #include <map>
18 
19 namespace OpenMS
20 {
21  typedef Peak2D PeakType;
22  class string;
23 
35  class OPENMS_DLLAPI MassTrace
36  {
37 public:
38 
39  // must match to names_of_quantmethod[]
41  MT_QUANT_AREA = 0,
44  SIZE_OF_MT_QUANTMETHOD
45  };
46  static const std::string names_of_quantmethod[SIZE_OF_MT_QUANTMETHOD];
47 
49  static MT_QUANTMETHOD getQuantMethod(const String& val);
50 
54 
56  MassTrace() = default;
57 
60  MassTrace(const std::list<PeakType>& trace_peaks);
61 
63  MassTrace(const std::vector<PeakType>& trace_peaks);
64 
66  ~MassTrace() = default;
67 
69  MassTrace(const MassTrace &) = default;
70 
72  MassTrace & operator=(const MassTrace &) = default;
73 
75  PeakType& operator[](const Size & mt_idx);
76  const PeakType& operator[](const Size & mt_idx) const;
78 
83  typedef std::vector<PeakType>::iterator iterator;
84  typedef std::vector<PeakType>::const_iterator const_iterator;
85  typedef std::vector<PeakType>::reverse_iterator reverse_iterator;
86  typedef std::vector<PeakType>::const_reverse_iterator const_reverse_iterator;
87 
89  {
90  return trace_peaks_.begin();
91  }
92 
94  {
95  return trace_peaks_.end();
96  }
97 
99  {
100  return trace_peaks_.begin();
101  }
102 
104  {
105  return trace_peaks_.end();
106  }
107 
109  {
110  return trace_peaks_.rbegin();
111  }
112 
114  {
115  return trace_peaks_.rend();
116  }
117 
119  {
120  return trace_peaks_.rbegin();
121  }
122 
124  {
125  return trace_peaks_.rend();
126  }
128 
133 
135  Size getSize() const
136  {
137  return trace_peaks_.size();
138  }
139 
141  String getLabel() const
142  {
143  return label_;
144  }
145 
147  void setLabel(const String & label)
148  {
149  label_ = label;
150  }
151 
153  double getCentroidMZ() const
154  {
155  return centroid_mz_;
156  }
157 
159  double getCentroidRT() const
160  {
161  return centroid_rt_;
162  }
163 
164  double getCentroidSD() const
165  {
166  return centroid_sd_;
167  }
168 
169  void setCentroidSD(const double & tmp_sd)
170  {
171  centroid_sd_ = tmp_sd;
172  }
173 
174  double getFWHM() const
175  {
176  return fwhm_;
177  }
178 
180  double getTraceLength() const
181  {
182  double length(0.0);
183 
184  if (trace_peaks_.size() > 1)
185  {
186  length = std::fabs(trace_peaks_.rbegin()->getRT() - trace_peaks_.begin()->getRT());
187  }
188 
189  return length;
190  }
191 
192  std::pair<Size, Size> getFWHMborders() const
193  {
194  return std::make_pair(fwhm_start_idx_, fwhm_end_idx_);
195  }
196 
198  const std::vector<double>& getSmoothedIntensities() const
199  {
200  return smoothed_intensities_;
201  }
202 
204  void setSmoothedIntensities(const std::vector<double> & db_vec)
205  {
206  if (trace_peaks_.size() != db_vec.size())
207  {
208  throw Exception::InvalidValue(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION,
209  "Number of smoothed intensities deviates from mass trace size! Aborting...", String(db_vec.size()));
210  }
211 
212  smoothed_intensities_ = db_vec;
213  }
214 
216  double getAverageMS1CycleTime() const
217  {
218  if (trace_peaks_.size() <= 1) return 0.0;
219 
220  return (trace_peaks_.rbegin()->getRT() - trace_peaks_.begin()->getRT()) / (trace_peaks_.size() - 1);
221  }
223 
227 
229  double computeSmoothedPeakArea() const;
230 
232  double computePeakArea() const;
233 
235  Size findMaxByIntPeak(bool use_smoothed_ints = false) const;
236 
240  double estimateFWHM(bool use_smoothed_ints = false);
241 
244 
247 
249  double computeFwhmAreaSmooth() const;
250  double computeFwhmArea() const;
251  // double computeFwhmAreaSmoothRobust() const;
252  // double computeFwhmAreaRobust() const;
253 
254  double getIntensity(bool smoothed) const;
255  double getMaxIntensity(bool smoothed) const;
256 
260 
264 
266 
269 
271 
274 
277 
279  void updateMeanMZ();
280 
283 
291 
293  double fwhm_mz_avg = 0;
294 
295 private:
296 
298  double computeMedianIntensity_() const;
299 
303  double linearInterpolationAtY_(double xA, double xB, double yA, double yB, double y_eval) const;
304 
306  std::vector<PeakType> trace_peaks_;
307 
309  double centroid_mz_ = 0.0;
310 
312  double centroid_sd_ = 0.0;
313 
315  double centroid_rt_ = 0.0;
316 
319 
321  std::vector<double> smoothed_intensities_;
322 
323  double fwhm_ = 0.0;
324  Size fwhm_start_idx_ = 0;
325  Size fwhm_end_idx_ = 0;
326 
328  MT_QUANTMETHOD quant_method_ = MT_QUANT_AREA;
329 
330  };
331 
332 }
333 
Definition: ConvexHull2D.h:47
Invalid value exception.
Definition: Exception.h:305
A container type that gathers peaks similar in m/z and moving along retention time.
Definition: MassTrace.h:36
void setSmoothedIntensities(const std::vector< double > &db_vec)
Set smoothed intensities (smoothing is done externally, e.g. by LowessSmoothing).
Definition: MassTrace.h:204
double computePeakArea() const
Sum intensities of all peaks in the mass trace.
void updateMedianMZ()
Compute & update centroid m/z as median of m/z values.
String getLabel() const
Gets label of mass trace.
Definition: MassTrace.h:141
const_reverse_iterator rend() const
Definition: MassTrace.h:123
void updateMedianRT()
Compute & update centroid RT as median position of intensities.
double getCentroidMZ() const
Returns the centroid m/z.
Definition: MassTrace.h:153
void setLabel(const String &label)
Sets label of mass trace.
Definition: MassTrace.h:147
std::vector< PeakType >::const_reverse_iterator const_reverse_iterator
Definition: MassTrace.h:86
const_iterator begin() const
Definition: MassTrace.h:98
void setQuantMethod(MT_QUANTMETHOD method)
determine if area or median is used for quantification
MT_QUANTMETHOD getQuantMethod() const
check if area or median is used for quantification
std::pair< Size, Size > getFWHMborders() const
Definition: MassTrace.h:192
Size getSize() const
Returns the number of peaks contained in the mass trace.
Definition: MassTrace.h:135
Size findMaxByIntPeak(bool use_smoothed_ints=false) const
Return the index of the mass trace's highest peak within the MassTrace container (based either on raw...
double getTraceLength() const
Returns the length of the trace (as difference in RT)
Definition: MassTrace.h:180
double getFWHM() const
Definition: MassTrace.h:174
double estimateFWHM(bool use_smoothed_ints=false)
static MT_QUANTMETHOD getQuantMethod(const String &val)
converts a string to enum value; returns 'SIZE_OF_MT_QUANTMETHOD' upon error
double computeMedianIntensity_() const
median of trace intensities
MassTrace()=default
Default constructor.
PeakType & operator[](const Size &mt_idx)
Random access operator.
std::vector< PeakType >::const_iterator const_iterator
Definition: MassTrace.h:84
double getIntensity(bool smoothed) const
reverse_iterator rend()
Definition: MassTrace.h:113
MassTrace(const std::vector< PeakType > &trace_peaks)
Detailed constructor for vector.
double computeFwhmAreaSmooth() const
Compute chromatographic peak area within the FWHM range.
double linearInterpolationAtY_(double xA, double xB, double yA, double yB, double y_eval) const
std::vector< PeakType >::reverse_iterator reverse_iterator
Definition: MassTrace.h:85
MassTrace(const MassTrace &)=default
Copy constructor.
std::vector< double > smoothed_intensities_
Container for smoothed intensities. Smoothing must be done externally.
Definition: MassTrace.h:321
double computeSmoothedPeakArea() const
Sum all non-negative (smoothed!) intensities in the mass trace.
String label_
Trace label.
Definition: MassTrace.h:318
double getCentroidRT() const
Returns the centroid RT.
Definition: MassTrace.h:159
double getCentroidSD() const
Definition: MassTrace.h:164
const std::vector< double > & getSmoothedIntensities() const
Gets smoothed intensities (empty if no smoothing was explicitly done beforehand!).
Definition: MassTrace.h:198
void updateSmoothedWeightedMeanRT()
double computeFwhmArea() const
void updateMeanMZ()
Compute & update centroid m/z as mean of m/z values.
void updateSmoothedMaxRT()
std::vector< PeakType >::iterator iterator
Definition: MassTrace.h:83
~MassTrace()=default
Destructor.
double getAverageMS1CycleTime() const
Get average scan time of mass trace.
Definition: MassTrace.h:216
ConvexHull2D getConvexhull() const
Return the mass trace's convex hull.
void updateWeightedMeanRT()
Compute & update centroid RT as a intensity-weighted mean of RTs.
iterator end()
Definition: MassTrace.h:93
const_iterator end() const
Definition: MassTrace.h:103
reverse_iterator rbegin()
Definition: MassTrace.h:108
const PeakType & operator[](const Size &mt_idx) const
void updateWeightedMZsd()
Compute & update m/z standard deviation of mass trace as weighted mean of m/z values.
MassTrace(const std::list< PeakType > &trace_peaks)
void setCentroidSD(const double &tmp_sd)
Definition: MassTrace.h:169
iterator begin()
Definition: MassTrace.h:88
MT_QUANTMETHOD
Definition: MassTrace.h:40
@ MT_QUANT_MEDIAN
quantify by median of intensities
Definition: MassTrace.h:42
@ MT_QUANT_HEIGHT
quantify by peak height
Definition: MassTrace.h:43
std::vector< PeakType > trace_peaks_
Actual MassTrace container for doing centroid calculation, peak width estimation etc.
Definition: MassTrace.h:306
const_reverse_iterator rbegin() const
Definition: MassTrace.h:118
void updateWeightedMeanMZ()
Compute & update centroid m/z as weighted mean of m/z values.
double getMaxIntensity(bool smoothed) const
MassTrace & operator=(const MassTrace &)=default
Assignment operator.
A 2-dimensional raw data point or peak.
Definition: Peak2D.h:29
A more convenient string class.
Definition: String.h:34
size_t Size
Size type e.g. used as variable which can hold result of size()
Definition: Types.h:97
Main OpenMS namespace.
Definition: openswathalgo/include/OpenMS/OPENSWATHALGO/DATAACCESS/ISpectrumAccess.h:19
Peak2D PeakType
Definition: MassTrace.h:21