OpenMS
MassTrace.h
Go to the documentation of this file.
1 // --------------------------------------------------------------------------
2 // OpenMS -- Open-Source Mass Spectrometry
3 // --------------------------------------------------------------------------
4 // Copyright The OpenMS Team -- Eberhard Karls University Tuebingen,
5 // ETH Zurich, and Freie Universitaet Berlin 2002-2023.
6 //
7 // This software is released under a three-clause BSD license:
8 // * Redistributions of source code must retain the above copyright
9 // notice, this list of conditions and the following disclaimer.
10 // * Redistributions in binary form must reproduce the above copyright
11 // notice, this list of conditions and the following disclaimer in the
12 // documentation and/or other materials provided with the distribution.
13 // * Neither the name of any author or any participating institution
14 // may be used to endorse or promote products derived from this software
15 // without specific prior written permission.
16 // For a full list of authors, refer to the file AUTHORS.
17 // --------------------------------------------------------------------------
18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
19 // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 // ARE DISCLAIMED. IN NO EVENT SHALL ANY OF THE AUTHORS OR THE CONTRIBUTING
22 // INSTITUTIONS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
23 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
24 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
25 // OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
26 // WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
27 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
28 // ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 //
30 // --------------------------------------------------------------------------
31 // $Maintainer: Timo Sachsenberg $
32 // $Authors: Erhan Kenar, Holger Franken, Chris Bielow $
33 // --------------------------------------------------------------------------
34 
35 #pragma once
36 
37 #include <OpenMS/KERNEL/Peak2D.h>
39 
40 
41 #include <vector>
42 #include <list>
43 #include <map>
44 
45 namespace OpenMS
46 {
47  typedef Peak2D PeakType;
48  class string;
49 
61  class OPENMS_DLLAPI MassTrace
62  {
63 public:
64 
65  // must match to names_of_quantmethod[]
67  MT_QUANT_AREA = 0,
70  SIZE_OF_MT_QUANTMETHOD
71  };
72  static const std::string names_of_quantmethod[SIZE_OF_MT_QUANTMETHOD];
73 
75  static MT_QUANTMETHOD getQuantMethod(const String& val);
76 
80 
82  MassTrace() = default;
83 
86  MassTrace(const std::list<PeakType>& trace_peaks);
87 
89  MassTrace(const std::vector<PeakType>& trace_peaks);
90 
92  ~MassTrace() = default;
93 
95  MassTrace(const MassTrace &) = default;
96 
98  MassTrace & operator=(const MassTrace &) = default;
99 
101  PeakType& operator[](const Size & mt_idx);
102  const PeakType& operator[](const Size & mt_idx) const;
104 
109  typedef std::vector<PeakType>::iterator iterator;
110  typedef std::vector<PeakType>::const_iterator const_iterator;
111  typedef std::vector<PeakType>::reverse_iterator reverse_iterator;
112  typedef std::vector<PeakType>::const_reverse_iterator const_reverse_iterator;
113 
115  {
116  return trace_peaks_.begin();
117  }
118 
120  {
121  return trace_peaks_.end();
122  }
123 
125  {
126  return trace_peaks_.begin();
127  }
128 
130  {
131  return trace_peaks_.end();
132  }
133 
135  {
136  return trace_peaks_.rbegin();
137  }
138 
140  {
141  return trace_peaks_.rend();
142  }
143 
145  {
146  return trace_peaks_.rbegin();
147  }
148 
150  {
151  return trace_peaks_.rend();
152  }
154 
159 
161  Size getSize() const
162  {
163  return trace_peaks_.size();
164  }
165 
167  String getLabel() const
168  {
169  return label_;
170  }
171 
173  void setLabel(const String & label)
174  {
175  label_ = label;
176  }
177 
179  double getCentroidMZ() const
180  {
181  return centroid_mz_;
182  }
183 
185  double getCentroidRT() const
186  {
187  return centroid_rt_;
188  }
189 
190  double getCentroidSD() const
191  {
192  return centroid_sd_;
193  }
194 
195  void setCentroidSD(const double & tmp_sd)
196  {
197  centroid_sd_ = tmp_sd;
198  }
199 
200  double getFWHM() const
201  {
202  return fwhm_;
203  }
204 
206  double getTraceLength() const
207  {
208  double length(0.0);
209 
210  if (trace_peaks_.size() > 1)
211  {
212  length = std::fabs(trace_peaks_.rbegin()->getRT() - trace_peaks_.begin()->getRT());
213  }
214 
215  return length;
216  }
217 
218  std::pair<Size, Size> getFWHMborders() const
219  {
220  return std::make_pair(fwhm_start_idx_, fwhm_end_idx_);
221  }
222 
224  const std::vector<double>& getSmoothedIntensities() const
225  {
226  return smoothed_intensities_;
227  }
228 
230  void setSmoothedIntensities(const std::vector<double> & db_vec)
231  {
232  if (trace_peaks_.size() != db_vec.size())
233  {
234  throw Exception::InvalidValue(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION,
235  "Number of smoothed intensities deviates from mass trace size! Aborting...", String(db_vec.size()));
236  }
237 
238  smoothed_intensities_ = db_vec;
239  }
240 
242  double getAverageMS1CycleTime() const
243  {
244  if (trace_peaks_.size() <= 1) return 0.0;
245 
246  return (trace_peaks_.rbegin()->getRT() - trace_peaks_.begin()->getRT()) / (trace_peaks_.size() - 1);
247  }
249 
253 
255  double computeSmoothedPeakArea() const;
256 
258  double computePeakArea() const;
259 
261  Size findMaxByIntPeak(bool use_smoothed_ints = false) const;
262 
266  double estimateFWHM(bool use_smoothed_ints = false);
267 
270 
273 
275  double computeFwhmAreaSmooth() const;
276  double computeFwhmArea() const;
277  // double computeFwhmAreaSmoothRobust() const;
278  // double computeFwhmAreaRobust() const;
279 
280  double getIntensity(bool smoothed) const;
281  double getMaxIntensity(bool smoothed) const;
282 
286 
290 
292 
295 
297 
300 
303 
305  void updateMeanMZ();
306 
309 
317 
319  double fwhm_mz_avg = 0;
320 
321 private:
322 
324  double computeMedianIntensity_() const;
325 
329  double linearInterpolationAtY_(double xA, double xB, double yA, double yB, double y_eval) const;
330 
332  std::vector<PeakType> trace_peaks_;
333 
335  double centroid_mz_ = 0.0;
336 
338  double centroid_sd_ = 0.0;
339 
341  double centroid_rt_ = 0.0;
342 
345 
347  std::vector<double> smoothed_intensities_;
348 
349  double fwhm_ = 0.0;
350  Size fwhm_start_idx_ = 0;
351  Size fwhm_end_idx_ = 0;
352 
354  MT_QUANTMETHOD quant_method_ = MT_QUANT_AREA;
355 
356  };
357 
358 }
359 
A 2-dimensional hull representation in [counter]clockwise direction - depending on axis labelling.
Definition: ConvexHull2D.h:73
Invalid value exception.
Definition: Exception.h:329
A container type that gathers peaks similar in m/z and moving along retention time.
Definition: MassTrace.h:62
void setSmoothedIntensities(const std::vector< double > &db_vec)
Set smoothed intensities (smoothing is done externally, e.g. by LowessSmoothing).
Definition: MassTrace.h:230
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:167
const_reverse_iterator rend() const
Definition: MassTrace.h:149
void updateMedianRT()
Compute & update centroid RT as median position of intensities.
double getCentroidMZ() const
Returns the centroid m/z.
Definition: MassTrace.h:179
void setLabel(const String &label)
Sets label of mass trace.
Definition: MassTrace.h:173
std::vector< PeakType >::const_reverse_iterator const_reverse_iterator
Definition: MassTrace.h:112
const_iterator begin() const
Definition: MassTrace.h:124
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:218
Size getSize() const
Returns the number of peaks contained in the mass trace.
Definition: MassTrace.h:161
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:206
double getFWHM() const
Definition: MassTrace.h:200
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:110
double getIntensity(bool smoothed) const
reverse_iterator rend()
Definition: MassTrace.h:139
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:111
MassTrace(const MassTrace &)=default
Copy constructor.
std::vector< double > smoothed_intensities_
Container for smoothed intensities. Smoothing must be done externally.
Definition: MassTrace.h:347
double computeSmoothedPeakArea() const
Sum all non-negative (smoothed!) intensities in the mass trace.
String label_
Trace label.
Definition: MassTrace.h:344
double getCentroidRT() const
Returns the centroid RT.
Definition: MassTrace.h:185
double getCentroidSD() const
Definition: MassTrace.h:190
const std::vector< double > & getSmoothedIntensities() const
Gets smoothed intensities (empty if no smoothing was explicitly done beforehand!).
Definition: MassTrace.h:224
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:109
~MassTrace()=default
Destructor.
double getAverageMS1CycleTime() const
Get average scan time of mass trace.
Definition: MassTrace.h:242
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:119
const_iterator end() const
Definition: MassTrace.h:129
reverse_iterator rbegin()
Definition: MassTrace.h:134
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:195
iterator begin()
Definition: MassTrace.h:114
MT_QUANTMETHOD
Definition: MassTrace.h:66
@ MT_QUANT_MEDIAN
quantify by median of intensities
Definition: MassTrace.h:68
@ MT_QUANT_HEIGHT
quantify by peak height
Definition: MassTrace.h:69
std::vector< PeakType > trace_peaks_
Actual MassTrace container for doing centroid calculation, peak width estimation etc.
Definition: MassTrace.h:332
const_reverse_iterator rbegin() const
Definition: MassTrace.h:144
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:55
A more convenient string class.
Definition: String.h:60
size_t Size
Size type e.g. used as variable which can hold result of size()
Definition: Types.h:127
Main OpenMS namespace.
Definition: FeatureDeconvolution.h:48
Peak2D PeakType
Definition: MassTrace.h:47