MassTrace.h

Go to the documentation of this file.

// --------------------------------------------------------------------------
//                   OpenMS -- Open-Source Mass Spectrometry
// --------------------------------------------------------------------------
// Copyright The OpenMS Team -- Eberhard Karls University Tuebingen,
// ETH Zurich, and Freie Universitaet Berlin 2002-2017.
//
// This software is released under a three-clause BSD license:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name of any author or any participating institution
//    may be used to endorse or promote products derived from this software
//    without specific prior written permission.
// For a full list of authors, refer to the file AUTHORS.
// --------------------------------------------------------------------------
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL ANY OF THE AUTHORS OR THE CONTRIBUTING
// INSTITUTIONS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// --------------------------------------------------------------------------
// $Maintainer: Timo Sachsenberg $
// $Authors: Erhan Kenar, Holger Franken, Chris Bielow $
// --------------------------------------------------------------------------

#ifndef OPENMS_KERNEL_MASSTRACE_H
#define OPENMS_KERNEL_MASSTRACE_H

#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,  //< quantify by area
      MT_QUANT_MEDIAN,    //< quantify by median of intensities
      SIZE_OF_MT_QUANTMETHOD
    };
    static const std::string names_of_quantmethod[SIZE_OF_MT_QUANTMETHOD];

    static MT_QUANTMETHOD getQuantMethod(const String& val);


    MassTrace();

    MassTrace(const std::list<PeakType>& trace_peaks);

    MassTrace(const std::vector<PeakType>& trace_peaks);

    ~MassTrace();

    MassTrace(const MassTrace &);

    MassTrace & operator=(const MassTrace &);

    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;

    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;

private:

    double computeMedianIntensity_() const;

    std::vector<PeakType> trace_peaks_;

    double centroid_mz_;

    double centroid_sd_;

    double centroid_rt_;

    String label_;

    std::vector<double> smoothed_intensities_;

    double fwhm_; //< FWHM of RT peak
    Size fwhm_start_idx_; //< index into 'trace_peaks_' vector (inclusive)
    Size fwhm_end_idx_; //< index into 'trace_peaks_' vector (inclusive)

    MT_QUANTMETHOD quant_method_;
    
  };

}

#endif // OPENMS_KERNEL_MASSTRACE_H