MassTrace.h

Go to the documentation of this file.

// Copyright (c) 2002-present, The OpenMS Team -- EKU Tuebingen, ETH Zurich, and FU Berlin
// SPDX-License-Identifier: BSD-3-Clause
//
// --------------------------------------------------------------------------
// $Maintainer: Timo Sachsenberg $
// $Authors: Erhan Kenar, Holger Franken, Chris Bielow $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/KERNEL/Peak2D.h>
#include <OpenMS/KERNEL/FeatureMap.h>
 
 
#include <vector>
#include <list>
#include <map>
 
namespace OpenMS
{
  typedef Peak2D PeakType;
  class string;
 
  class OPENMS_DLLAPI MassTrace
  {
public:
 
    // must match to names_of_quantmethod[]
    enum MT_QUANTMETHOD {
      MT_QUANT_AREA = 0,  
      MT_QUANT_MEDIAN,    
      MT_QUANT_HEIGHT,    
      SIZE_OF_MT_QUANTMETHOD
    };
    static const std::string names_of_quantmethod[SIZE_OF_MT_QUANTMETHOD];
 
    static MT_QUANTMETHOD getQuantMethod(const String& val);
 
 
    MassTrace() = default;
 
    MassTrace(const std::list<PeakType>& trace_peaks);
 
    MassTrace(const std::vector<PeakType>& trace_peaks);
 
    ~MassTrace() = default;
 
    MassTrace(const MassTrace &) = default;
 
    MassTrace & operator=(const MassTrace &) = default;
 
    PeakType& operator[](const Size & mt_idx);
    const PeakType& operator[](const Size & mt_idx) const;
 
    typedef std::vector<PeakType>::iterator iterator;
    typedef std::vector<PeakType>::const_iterator const_iterator;
    typedef std::vector<PeakType>::reverse_iterator reverse_iterator;
    typedef std::vector<PeakType>::const_reverse_iterator const_reverse_iterator;
 
    iterator begin()
    {
      return trace_peaks_.begin();
    }
 
    iterator end()
    {
      return trace_peaks_.end();
    }
 
    const_iterator begin() const
    {
      return trace_peaks_.begin();
    }
 
    const_iterator end() const
    {
      return trace_peaks_.end();
    }
 
    reverse_iterator rbegin()
    {
      return trace_peaks_.rbegin();
    }
 
    reverse_iterator rend()
    {
      return trace_peaks_.rend();
    }
 
    const_reverse_iterator rbegin() const
    {
      return trace_peaks_.rbegin();
    }
 
    const_reverse_iterator rend() const
    {
      return trace_peaks_.rend();
    }
 
 
    Size getSize() const
    {
      return trace_peaks_.size();
    }
 
    String getLabel() const
    {
      return label_;
    }
 
    void setLabel(const String & label)
    {
      label_ = label;
    }
 
    double getCentroidMZ() const
    {
      return centroid_mz_;
    }
 
    double getCentroidRT() const
    {
      return centroid_rt_;
    }
 
    double getCentroidSD() const
    {
      return centroid_sd_;
    }
 
    void setCentroidSD(const double & tmp_sd)
    {
      centroid_sd_ = tmp_sd;
    }
 
    double getFWHM() const
    {
        return fwhm_;
    }
 
    double getTraceLength() const
    {
        double length(0.0);
 
        if (trace_peaks_.size() > 1)
        {
            length = std::fabs(trace_peaks_.rbegin()->getRT() - trace_peaks_.begin()->getRT());
        }
 
        return length;
    }
 
    std::pair<Size, Size> getFWHMborders() const
    {
      return std::make_pair(fwhm_start_idx_, fwhm_end_idx_);
    }
 
    const std::vector<double>& getSmoothedIntensities() const
    {
      return smoothed_intensities_;
    }
 
    void setSmoothedIntensities(const std::vector<double> & db_vec)
    {
      if (trace_peaks_.size() != db_vec.size())
      {
        throw Exception::InvalidValue(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION,
            "Number of smoothed intensities deviates from mass trace size! Aborting...", String(db_vec.size()));
      }
 
      smoothed_intensities_ = db_vec;
    }
 
    double getAverageMS1CycleTime() const
    {
      if (trace_peaks_.size() <= 1) return 0.0;
 
      return (trace_peaks_.rbegin()->getRT() - trace_peaks_.begin()->getRT()) / (trace_peaks_.size() - 1);
    }
 
 
    double computeSmoothedPeakArea() const;
 
    double computePeakArea() const;
 
    double computeIntensitySum() const;
 
    Size findMaxByIntPeak(bool use_smoothed_ints = false) const;
 
    double estimateFWHM(bool use_smoothed_ints = false);
 
    void setQuantMethod(MT_QUANTMETHOD method);
 
    MT_QUANTMETHOD getQuantMethod() const;
 
    double computeFwhmAreaSmooth() const;
    double computeFwhmArea() const;
    // double computeFwhmAreaSmoothRobust() const;
    // double computeFwhmAreaRobust() const;
 
    double getIntensity(bool smoothed) const;
    double getMaxIntensity(bool smoothed) const;
 
    ConvexHull2D getConvexhull() const;
 
 
    void updateSmoothedMaxRT();
 
    void updateWeightedMeanRT();
 
    void updateSmoothedWeightedMeanRT();
 
    void updateMedianRT();
 
    void updateMedianMZ();
 
    void updateMeanMZ();
 
    void updateWeightedMeanMZ();
 
    void updateWeightedMZsd();
 
    double fwhm_mz_avg = 0;
 
private:
 
    double computeMedianIntensity_() const;
 
    double linearInterpolationAtY_(double xA, double xB, double yA, double yB, double y_eval) const;
 
    std::vector<PeakType> trace_peaks_;
 
    double centroid_mz_ = 0.0;
 
    double centroid_sd_ = 0.0;
 
    double centroid_rt_ = 0.0;
 
    String label_;
 
    std::vector<double> smoothed_intensities_;
 
    double fwhm_ = 0.0; 
    Size fwhm_start_idx_ = 0; 
    Size fwhm_end_idx_ = 0; 
 
    MT_QUANTMETHOD quant_method_ = MT_QUANT_AREA;
    
  };
 
}