Home  · Classes  · Annotated Classes  · Modules  · Members  · Namespaces  · Related Pages
FeatureFinderAlgorithmMRM.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-2013.
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: Andreas Bertsch $
32 // $Authors: Andreas Bertsch $
33 // --------------------------------------------------------------------------
34 
35 #ifndef OPENMS_TRANSFORMATIONS_FEATUREFINDER_FEATUREFINDERALGORITHMMRM_H
36 #define OPENMS_TRANSFORMATIONS_FEATUREFINDER_FEATUREFINDERALGORITHMMRM_H
37 
48 
49 #include <boost/math/special_functions/fpclassify.hpp>
50 
51 #include <fstream>
52 #include <limits>
53 
54 namespace OpenMS
55 {
72  template <class PeakType, class FeatureType>
74  public FeatureFinderAlgorithm<PeakType, FeatureType>,
75  public FeatureFinderDefs
76  {
77 public:
79 
84 
90 
91 public:
92 
93  enum
94  {
97  };
98 
99 
102  FeatureFinderAlgorithm<PeakType, FeatureType>()
103  {
104  defaults_.setValue("min_rt_distance", 10.0, "Minimal distance of MRM features in seconds.");
105  defaults_.setMinFloat("min_rt_distance", 0.0);
106  defaults_.setValue("min_num_peaks_per_feature", 5, "Minimal number of peaks which are needed for a single feature", StringList::create("advanced"));
107  defaults_.setMinInt("min_num_peaks_per_feature", 1);
108  defaults_.setValue("min_signal_to_noise_ratio", 2.0, "Minimal S/N ratio a peak must have to be taken into account. Set to zero if the MRM-traces contains mostly signals, and no noise.");
109  defaults_.setMinFloat("min_signal_to_noise_ratio", 0);
110  defaults_.setValue("write_debug_files", "false", "If set to true, for each feature a plot will be created, in the subdirectory 'debug'", StringList::create("advanced"));
111  defaults_.setValidStrings("write_debug_files", StringList::create("true,false"));
112 
113  defaults_.setValue("resample_traces", "false", "If set to true, each trace, which is in this case a part of the MRM monitoring trace with signal is resampled, using the minimal distance of two data points in RT dimension", StringList::create("advanced"));
114  defaults_.setValidStrings("resample_traces", StringList::create("true,false"));
115 
116  defaults_.setValue("write_debuginfo", "false", "If set to true, debug messages are written, the output can be somewhat lengthy.", StringList::create("advanced"));
117  defaults_.setValidStrings("write_debuginfo", StringList::create("true,false"));
118 
119  this->defaultsToParam_();
120  }
121 
123  virtual void run()
124  {
125  //-------------------------------------------------------------------------
126  //General initialization
127  //-------------------------------------------------------------------------
128 
130 
132  LinearResampler resampler;
133 
134  // Split the whole map into traces (== MRM transitions)
135  ff_->startProgress(0, traces.size(), "Finding features in traces.");
136  Size counter(0);
137  //typename Map<Size, Map<Size, std::vector<std::pair<DoubleReal, PeakType> > > >::const_iterator it1 = traces.begin();
138  //typename Map<Size, std::vector<std::pair<DoubleReal, PeakType> > >::const_iterator it2;
139  DoubleReal min_rt_distance(param_.getValue("min_rt_distance"));
140  DoubleReal min_signal_to_noise_ratio(param_.getValue("min_signal_to_noise_ratio"));
141  Size min_num_peaks_per_feature(param_.getValue("min_num_peaks_per_feature"));
142  Size feature_id(0);
143  bool write_debuginfo(param_.getValue("write_debuginfo").toBool());
144  bool write_debug_files(param_.getValue("write_debug_files").toBool());
145  bool resample_traces(param_.getValue("resample_traces").toBool());
146 
147  if (write_debuginfo)
148  {
149  std::cerr << "Starting feature finding #chromatograms=" << map_->getChromatograms().size() << ", #spectra=" << map_->size() << std::endl;
150  }
151 
152  typename std::vector<MSChromatogram<ChromatogramPeak> >::const_iterator first_it = map_->getChromatograms().begin();
153  for (; first_it != map_->getChromatograms().end(); ++first_it)
154  {
155  // throw the peaks into a "spectrum" where the m/z values are RTs in reality (more a chromatogram)
156  RichPeakSpectrum chromatogram;
157  //typename std::vector<std::pair<DoubleReal, PeakType> >::const_iterator it3 = it2->second.begin();
158  for (MSChromatogram<ChromatogramPeak>::const_iterator it = first_it->begin(); it != first_it->end(); ++it)
159  {
160  RichPeak1D peak;
161  peak.setMZ(it->getRT());
162  peak.setIntensity(it->getIntensity());
163  chromatogram.push_back(peak);
164  }
165 
166  // TODO
167  // find presection of separated RTs of peaks;
168  // resampling to min distance?
169  // for each of the section, try to estimate S/N
170  // find core regions and fit them
171  //
172 
173  if (resample_traces)
174  {
175  // resample the chromatogram, first find minimal distance and use this as resampling distance
176  DoubleReal min_distance(std::numeric_limits<DoubleReal>::max()), old_rt(0);
177  for (RichPeakSpectrum::ConstIterator it = chromatogram.begin(); it != chromatogram.end(); ++it)
178  {
179  if (write_debuginfo)
180  {
181  std::cerr << "CHROMATOGRAM: " << it->getMZ() << " " << it->getIntensity() << std::endl;
182  }
183  DoubleReal rt_diff = it->getMZ() - old_rt;
184  if (rt_diff < min_distance && rt_diff > 0)
185  {
186  min_distance = rt_diff;
187  }
188  old_rt = it->getMZ();
189  }
190 
191  if (write_debuginfo)
192  {
193  std::cerr << "Min_distance=" << min_distance << std::endl;
194  }
195  if (min_distance > 50 || chromatogram.size() < min_num_peaks_per_feature)
196  {
197  continue;
198  }
199  Param resampler_param(resampler.getParameters());
200  resampler_param.setValue("spacing", min_distance);
201  resampler.setParameters(resampler_param);
202  resampler.raster(chromatogram);
203  }
204 
205  // now smooth the data
206  GaussFilter filter;
207  Param filter_param(filter.getParameters());
208  filter.setParameters(filter_param);
209 
210  // calculate signal to noise levels
211  RichPeakSpectrum sn_chrom;
212  Param sne_param(sne.getParameters());
213  // set window length to whole range, we expect only at most one signal
214  if (write_debuginfo)
215  {
216  std::cerr << "win_len m/z: " << (chromatogram.end() - 1)->getMZ() << " " << chromatogram.begin()->getMZ() << std::endl;
217  }
218  sne_param.setValue("win_len", (chromatogram.end() - 1)->getMZ() - chromatogram.begin()->getMZ());
219 
220  if ((DoubleReal)sne_param.getValue("win_len") < 10e-4)
221  {
222  continue;
223  }
224  sne.setParameters(sne_param);
225  sne.init(chromatogram.begin(), chromatogram.end());
226 
227  if (write_debuginfo)
228  {
229  std::cerr << first_it->getPrecursor().getMZ() << " " << first_it->getProduct().getMZ() << " ";
230  }
231  for (RichPeakSpectrum::Iterator sit = chromatogram.begin(); sit != chromatogram.end(); ++sit)
232  {
233  DoubleReal sn(sne.getSignalToNoise(sit));
234  sit->setMetaValue("SN", sn);
235  if (write_debuginfo)
236  {
237  std::cerr << sit->getMZ() << " " << sit->getIntensity() << " " << sn << std::endl;
238  }
239  if (min_signal_to_noise_ratio == 0 || sn > min_signal_to_noise_ratio)
240  {
241  sn_chrom.push_back(*sit);
242  }
243  }
244 
245  // now find sections in the chromatogram which have high s/n value
246  DoubleReal last_rt(0), this_rt(0);
247  std::vector<std::vector<DPosition<2> > > sections;
248  for (RichPeakSpectrum::Iterator sit = sn_chrom.begin(); sit != sn_chrom.end(); ++sit)
249  {
250  if (write_debuginfo)
251  {
252  std::cerr << "SECTIONS: " << sit->getMZ() << " " << sit->getIntensity() << std::endl;
253  }
254  this_rt = sit->getMZ();
255  if (sections.empty() || (this_rt - last_rt) > min_rt_distance)
256  {
257  if (write_debuginfo)
258  {
259  std::cerr << "Starting new section, sections.size()=" << sections.size() << ", rt_diff=" << this_rt - last_rt << std::endl;
260  }
261  // new section
262  std::vector<DPosition<2> > section;
263  section.push_back(DPosition<2>(this_rt, sit->getIntensity()));
264  sections.push_back(section);
265  }
266  else
267  {
268  sections.back().push_back(DPosition<2>(this_rt, sit->getIntensity()));
269  }
270  last_rt = this_rt;
271  }
272 
273  // for each of the sections identify local maxima which can be used for extension
274  // if needed split the sections into smaller sections
275  for (Size i = 0; i != sections.size(); ++i)
276  {
277  if (sections[i].size() < min_num_peaks_per_feature)
278  {
279  continue;
280  }
281 
282  std::vector<DoubleReal> deltas(2, 0.0);
283  DoubleReal last_int(sections[i][0].getY());
284  for (Size j = 1; j < sections[i].size(); ++j)
285  {
286  deltas.push_back((sections[i][j].getY() - last_int) / last_int);
287  last_int = sections[i][j].getY();
288  if (write_debuginfo)
289  {
290  DoubleReal average_delta = std::accumulate(deltas.begin(), deltas.end(), 0.0) / (DoubleReal)3.0;
291  std::cerr << "AverageDelta: " << average_delta << " (" << sections[i][j].getX() << ", " << sections[i][j].getY() << ")" << std::endl;
292  }
293  }
294  }
295 
296 
297  // for each section estimate the rt min/max and add up the intensities
298  for (Size i = 0; i != sections.size(); ++i)
299  {
300  if (sections[i].size() > min_num_peaks_per_feature)
301  {
302  // first smooth the data to prevent outliers from destroying the fit
303  PeakSpectrum filter_spec;
304  for (Size j = 0; j != sections[i].size(); ++j)
305  {
306  Peak1D p;
307  p.setMZ(sections[i][j].getX());
308  p.setIntensity(sections[i][j].getY());
309  filter_spec.push_back(p);
310  }
311 
312  // add two peaks at the beginning and at the end for better fit
313  // therefore calculate average distance first
314  std::vector<DoubleReal> distances;
315  for (Size j = 1; j < filter_spec.size(); ++j)
316  {
317  distances.push_back(filter_spec[j].getMZ() - filter_spec[j - 1].getMZ());
318  }
319  DoubleReal dist_average = std::accumulate(distances.begin(), distances.end(), 0.0) / (DoubleReal)distances.size();
320 
321  // append peaks
322  Peak1D new_peak;
323  new_peak.setIntensity(0);
324  new_peak.setMZ(filter_spec.back().getMZ() + dist_average);
325  filter_spec.push_back(new_peak);
326  new_peak.setMZ(filter_spec.back().getMZ() + dist_average);
327  filter_spec.push_back(new_peak);
328  new_peak.setMZ(filter_spec.back().getMZ() + dist_average);
329  filter_spec.push_back(new_peak);
330 
331  // prepend peaks
332  new_peak.setMZ(filter_spec.front().getMZ() - dist_average);
333  filter_spec.insert(filter_spec.begin(), new_peak);
334  new_peak.setMZ(filter_spec.front().getMZ() - dist_average);
335  filter_spec.insert(filter_spec.begin(), new_peak);
336  new_peak.setMZ(filter_spec.front().getMZ() - dist_average);
337  filter_spec.insert(filter_spec.begin(), new_peak);
338 
339  filter_param.setValue("gaussian_width", 4 * dist_average);
340  filter.setParameters(filter_param);
341 
342  // smooth the data
343  filter.filter(filter_spec);
344 
345  // transform the data for fitting and fit RT profile
346  std::vector<PeakType> data_to_fit;
347  for (Size j = 0; j != filter_spec.size(); ++j)
348  {
349  PeakType p;
350  p.setPosition(filter_spec[j].getMZ());
351  p.setIntensity(filter_spec[j].getIntensity());
352  data_to_fit.push_back(p);
353  }
354  InterpolationModel * model_rt = 0;
355  DoubleReal quality = fitRT_(data_to_fit, model_rt);
356 
357  Feature f;
358  f.setQuality(0, quality);
359  f.setOverallQuality(quality);
360 
361  ConvexHull2D::PointArrayType hull_points(sections[i].size());
362  DoubleReal intensity_sum(0.0), rt_sum(0.0);
363  for (Size j = 0; j < sections[i].size(); ++j)
364  {
365  hull_points[j][0] = sections[i][j].getX();
366  hull_points[j][1] = first_it->getProduct().getMZ();
367 
368  rt_sum += sections[i][j].getX();
369  intensity_sum += sections[i][j].getY();
370  }
371 
372  // create the feature according to fit
373  f.setRT((DoubleReal)model_rt->getParameters().getValue("emg:retention"));
374  f.setMZ((DoubleReal)first_it->getProduct().getMZ());
375  f.setIntensity(intensity_sum);
376  ConvexHull2D hull;
377  hull.addPoints(hull_points);
378  f.getConvexHulls().push_back(hull);
379  f.setMetaValue("MZ", (DoubleReal)first_it->getPrecursor().getMZ());
380 
381 
382  // add the model to the feature
383  ProductModel<2> prod_model;
384  prod_model.setModel(RT, model_rt);
386 
387 
388  feature_id++;
389 
390  // writes a feature plot using gnuplot (should be installed on computer)
391  if (write_debug_files)
392  {
393  String base_name = "debug/" + String((DoubleReal)f.getMetaValue("MZ")) + "_id" + String(feature_id) + "_RT" + String(f.getRT()) + "_Q3" + String(f.getMZ());
394  std::ofstream data_out(String(base_name + "_data.dat").c_str());
395  for (Size j = 0; j < sections[i].size(); ++j)
396  {
397  // RT intensity
398  DoubleReal rt = sections[i][j].getX();
399  DoubleReal intensity = sections[i][j].getY();
400  data_out << rt << " " << intensity << std::endl;
401  }
402  data_out.close();
403 
404  std::ofstream smoothed_data_out(String(base_name + "_smoothed_data.dat").c_str());
405  for (Size j = 0; j < filter_spec.size(); ++j)
406  {
407  smoothed_data_out << filter_spec[j].getMZ() + 0.5 << " " << filter_spec[j].getIntensity() << std::endl;
408  }
409  smoothed_data_out.close();
410 
411  std::ofstream fit_out(String(base_name + "_rt_fit.dat").c_str());
412  EmgModel emg_model;
413  emg_model.setParameters(model_rt->getParameters());
414  emg_model.setSamples();
415  DoubleReal bb_min((DoubleReal)emg_model.getParameters().getValue("bounding_box:min"));
416  DoubleReal bb_max((DoubleReal)emg_model.getParameters().getValue("bounding_box:max"));
417  DoubleReal int_step((DoubleReal)emg_model.getParameters().getValue("interpolation_step"));
418  for (DoubleReal pos = bb_min; pos < bb_max; pos += int_step)
419  {
420  // RT intensity
421  fit_out << pos << " " << emg_model.getIntensity(pos) << std::endl;
422  }
423  fit_out.close();
424 
425  std::ofstream gnuplot_out(String(base_name + "_gnuplot.gpl").c_str());
426  gnuplot_out << "set terminal png" << std::endl;
427  gnuplot_out << "set output \"" << base_name << ".png\"" << std::endl;
428  gnuplot_out << "plot '" << base_name << "_data.dat' w i, '" << base_name << "_smoothed_data.dat' w i, '" << base_name << "_rt_fit.dat' w lp title 'quality=" << f.getOverallQuality() << "'" << std::endl;
429  gnuplot_out.close();
430  String gnuplot_call = "gnuplot " + base_name + "_gnuplot.gpl";
431  int error = system(gnuplot_call.c_str());
432  if (error != 0)
433  {
434  std::cerr << "An error occurred during the gnuplot execution" << std::endl;
435  }
436  }
437 
438  features_->push_back(f);
439  }
440  }
441 
442  ff_->setProgress(++counter);
443  }
444  }
445 
447  {
448  return new FeatureFinderAlgorithmMRM();
449  }
450 
451  static const String getProductName()
452  {
453  return "mrm";
454  }
455 
456 protected:
457 
458  DoubleReal fitRT_(std::vector<PeakType> & rt_input_data, InterpolationModel * & model) const
459  {
460  DoubleReal quality;
461  Param param;
462  EmgFitter1D fitter;
463 
464  /*
465 param.setValue( "tolerance_stdev_bounding_box", tolerance_stdev_box_);
466 param.setValue( "statistics:mean", rt_stat_.mean() );
467 param.setValue( "statistics:variance", rt_stat_.variance() );
468 param.setValue( "interpolation_step", interpolation_step_rt_ );
469 param.setValue( "max_iteration", max_iteration_);
470 param.setValue( "deltaAbsError", deltaAbsError_);
471 param.setValue( "deltaRelError", deltaRelError_);
472  */
473 
474  // Set parameter for fitter
475  fitter.setParameters(param);
476 
477  // Construct model for rt
478  quality = fitter.fit1d(rt_input_data, model);
479 
480  // Check quality
481  if (boost::math::isnan(quality)) quality = -1.0;
482 
483  return quality;
484  }
485 
486  //Docu in base class
487  virtual void updateMembers_()
488  {
489  }
490 
491  };
492 
493 } // namespace OpenMS
494 
495 #endif // OPENMS_TRANSFORMATIONS_FEATUREFINDER_FEATUREFINDERALGORITHMMRM_H
const DataValue & getMetaValue(const String &name) const
returns the value corresponding to a string
virtual double getSignalToNoise(const PeakIterator &data_point)
Definition: SignalToNoiseEstimator.h:130
ProductModel & setModel(UInt dim, BaseModel< 1 > *dist)
set model dist for dimension dim
Definition: ProductModel.h:184
void setMetaValue(const String &name, const DataValue &value)
sets the DataValue corresponding to a name
Exponentially modified gaussian distribution model for elution profiles.
Definition: EmgModel.h:50
FeatureMapType * features_
Output data pointer.
Definition: FeatureFinderAlgorithm.h:144
Param defaults_
Container for default parameters. This member should be filled in the constructor of derived classes!...
Definition: DefaultParamHandler.h:155
void setValue(const String &key, const DataValue &value, const String &description="", const StringList &tags=StringList())
Sets a value.
A more convenient string class.
Definition: String.h:56
Linear Resampling of raw data.
Definition: LinearResampler.h:61
FeatureFinder * ff_
Pointer to the calling FeatureFinder that is used to access the feature flags.
Definition: FeatureFinderAlgorithm.h:147
A 2-dimensional raw data point or peak.
Definition: Peak2D.h:55
FeatureFinderAlgorithm for MRM experiments.
Definition: FeatureFinderAlgorithmMRM.h:73
Size size() const
Definition: MSExperiment.h:117
void setMZ(CoordinateType coordinate)
Mutable access to the m/z coordinate (index 1)
Definition: Peak2D.h:197
QualityType getOverallQuality() const
Non-mutable access to the overall quality.
Param param_
Container for current parameters.
Definition: DefaultParamHandler.h:148
The representation of a chromatogram.
Definition: MSChromatogram.h:53
const MapType * map_
Input data pointer.
Definition: FeatureFinderAlgorithm.h:141
FeatureFinderAlgorithm< PeakType, FeatureType >::MapType MapType
Definition: FeatureFinderAlgorithmMRM.h:80
Retention time dimension id (0 if used as a const int)
Definition: Peak2D.h:76
std::vector< PointType > PointArrayType
Definition: ConvexHull2D.h:79
Abstract base class for FeatureFinder algorithms.
Definition: FeatureFinderAlgorithm.h:74
ContainerType::const_iterator ConstIterator
Non-mutable iterator.
Definition: MSSpectrum.h:125
MapType::SpectrumType SpectrumType
Definition: FeatureFinderAlgorithmMRM.h:81
Exponentially modified gaussian distribution fitter (1-dim.) using Levenberg-Marquardt algorithm (GSL...
Definition: EmgFitter1D.h:47
Mass-to-charge dimension id (1 if used as a const int)
Definition: Peak2D.h:77
QualityType fit1d(const RawDataArrayType &range, InterpolationModel *&model)
return interpolation model
void setModelDescription(const ModelDescription< 2 > &q)
Set the model description.
CoordinateType getRT() const
Returns the RT coordinate (index 0)
Definition: Peak2D.h:203
The class template is only implemented for D=2 because we use Peak2D here.
Definition: ProductModel.h:65
void setMZ(CoordinateType mz)
Mutable access to m/z.
Definition: Peak1D.h:114
void setIntensity(IntensityType intensity)
Mutable access to the data point intensity (height)
Definition: Peak1D.h:105
A 1-dimensional raw data point or peak mith meta information.
Definition: RichPeak1D.h:52
ContainerType::iterator Iterator
Mutable iterator.
Definition: MSSpectrum.h:123
void setParameters(const Param &param)
Sets the parameters.
A 2-dimensional hull representation in [counter]clockwise direction - depending on axis labelling...
Definition: ConvexHull2D.h:75
The purpose of this struct is to provide definitions of classes and typedefs which are used throughou...
Definition: FeatureFinderDefs.h:51
DoubleReal fitRT_(std::vector< PeakType > &rt_input_data, InterpolationModel *&model) const
Definition: FeatureFinderAlgorithmMRM.h:458
void setIntensity(IntensityType intensity)
Non-mutable access to the data point intensity (height)
Definition: Peak2D.h:167
std::vector< FloatDataArray > FloatDataArrays
Float data array vector type.
Definition: MSSpectrum.h:113
Definition: FeatureFinderAlgorithmMRM.h:95
Abstract class for 1D-models that are approximated using linear interpolation.
Definition: InterpolationModel.h:55
Estimates the signal/noise (S/N) ratio of each data point in a scan based on an iterative scheme whic...
Definition: SignalToNoiseEstimatorMeanIterative.h:69
virtual void init(const PeakIterator &it_begin, const PeakIterator &it_end)
Set the start and endpoint of the raw data interval, for which signal to noise ratios will be estimat...
Definition: SignalToNoiseEstimator.h:111
const DataValue & getValue(const String &key) const
Returns a value of a parameter.
void setRT(CoordinateType coordinate)
Mutable access to the RT coordinate (index 0)
Definition: Peak2D.h:209
IntensityType getIntensity(const PositionType &pos) const
access model predicted intensity at position pos
Definition: InterpolationModel.h:102
const std::vector< ConvexHull2D > & getConvexHulls() const
Non-mutable access to the convex hulls.
void setQuality(Size index, QualityType q)
Set the quality in dimension c.
SpectrumType::FloatDataArrays FloatDataArrays
Definition: FeatureFinderAlgorithmMRM.h:82
A 1-dimensional raw data point or peak.
Definition: Peak1D.h:55
FeatureFinderAlgorithmMRM()
default constructor
Definition: FeatureFinderAlgorithmMRM.h:101
static StringList create(const String &list, const char splitter= ',')
Returns a list that is created by splitting the given (comma-separated) string (String are not trimme...
void setPosition(const PositionType &position)
Mutable access to the position.
Definition: Peak2D.h:185
virtual void updateMembers_()
This method is used to update extra member variables at the end of the setParameters() method...
Definition: FeatureFinderAlgorithmMRM.h:487
An LC-MS feature.
Definition: Feature.h:66
virtual void run()
Main method for actual FeatureFinder.
Definition: FeatureFinderAlgorithmMRM.h:123
void setValidStrings(const String &key, const std::vector< String > &strings)
Sets the valid strings for the parameter key.
Management and storage of parameters / INI files.
Definition: Param.h:69
CoordinateType getMZ() const
Returns the m/z coordinate (index 1)
Definition: Peak2D.h:191
Representation of a mass spectrometry experiment.
Definition: MSExperiment.h:68
This class represents a Gaussian lowpass-filter which works on uniform as well as on non-uniform prof...
Definition: GaussFilter.h:73
void setOverallQuality(QualityType q)
Set the overall quality.
void setMinInt(const String &key, Int min)
Sets the minimum value for the integer or integer list parameter key.
void raster(MSSpectrum< PeakType > &spectrum)
Applies the resampling algorithm to an MSSpectrum.
Definition: LinearResampler.h:85
size_t Size
Size type e.g. used as variable which can hold result of size()
Definition: Types.h:144
void startProgress(SignedSize begin, SignedSize end, const String &label) const
Initializes the progress display.
bool toBool() const
Conversion to bool.
void setProgress(SignedSize value) const
Sets the current progress.
void addPoints(const PointArrayType &points)
Definition: FeatureFinderAlgorithmMRM.h:96
static const String getProductName()
Definition: FeatureFinderAlgorithmMRM.h:451
Map class based on the STL map (containing serveral convenience functions)
Definition: Map.h:50
static FeatureFinderAlgorithm< PeakType, FeatureType > * create()
Definition: FeatureFinderAlgorithmMRM.h:446
void setMinFloat(const String &key, DoubleReal min)
Sets the minimum value for the floating point or floating point list parameter key.
void filter(MSSpectrum< PeakType > &spectrum)
Smoothes an MSSpectrum containing profile data.
Definition: GaussFilter.h:92
const Param & getParameters() const
Non-mutable access to the parameters.
void setSamples()
set sample/supporting points of interpolation
const std::vector< MSChromatogram< ChromatogramPeakType > > & getChromatograms() const
returns the chromatogram list
Definition: MSExperiment.h:768
void defaultsToParam_()
Updates the parameters after the defaults have been set in the constructor.
double DoubleReal
Double-precision real type.
Definition: Types.h:118

OpenMS / TOPP release 1.11.1 Documentation generated on Thu Nov 14 2013 11:19:13 using doxygen 1.8.5