DeconvolvedSpectrum.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: Kyowon Jeong, Jihyung Kim $
// $Authors: Kyowon Jeong, Jihyung Kim $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/ANALYSIS/TOPDOWN/FLASHHelperClasses.h>
#include <OpenMS/ANALYSIS/TOPDOWN/PeakGroup.h>
#include <OpenMS/KERNEL/MSSpectrum.h>
#include <iomanip>
 
namespace OpenMS
{
  class PeakGroup;
 
  class OPENMS_DLLAPI DeconvolvedSpectrum
  {
  public:
    typedef FLASHHelperClasses::LogMzPeak LogMzPeak;
 
    DeconvolvedSpectrum() = default;
 
    explicit DeconvolvedSpectrum(int scan_number);
 
    ~DeconvolvedSpectrum() = default;
 
    DeconvolvedSpectrum(const DeconvolvedSpectrum&) = default;
 
    DeconvolvedSpectrum(DeconvolvedSpectrum&& other) noexcept = default;
 
    DeconvolvedSpectrum& operator=(const DeconvolvedSpectrum& deconvolved_spectrum) = default;
 
    MSSpectrum toSpectrum(int to_charge, double tol = 10.0, bool retain_undeconvolved = false);
 
    const MSSpectrum& getOriginalSpectrum() const;
 
    const PeakGroup& getPrecursorPeakGroup() const;
 
    int getPrecursorCharge() const;
 
    const Precursor& getPrecursor() const;
 
    double getCV() const;
 
    double getCurrentMaxMass(double max_mass) const;
 
    double getCurrentMinMass(double min_mass) const;
 
    int getCurrentMaxAbsCharge(int max_abs_charge) const;
 
    int getScanNumber() const;
 
    int getPrecursorScanNumber() const;
 
    const Precursor::ActivationMethod& getActivationMethod() const;
 
    FLASHHelperClasses::IsobaricQuantities getQuantities() const;
 
    void setQuantities(const FLASHHelperClasses::IsobaricQuantities& quantities);
 
    void setPrecursor(const Precursor& precursor);
 
    void setPrecursorIntensity(float i);
 
    void setPrecursorScanNumber(int scan_number);
 
    void setActivationMethod(const Precursor::ActivationMethod& method);
 
    void setPrecursorPeakGroup(const PeakGroup& pg);
 
    void setOriginalSpectrum(const MSSpectrum& spec);
 
    void setPeakGroups(std::vector<PeakGroup>& x);
 
    //std::vector<PeakGroup> getNonOverlappingPeakGroups() const;
 
    std::vector<PeakGroup>::const_iterator begin() const noexcept;
    std::vector<PeakGroup>::const_iterator end() const noexcept;
 
    std::vector<PeakGroup>::iterator begin() noexcept;
    std::vector<PeakGroup>::iterator end() noexcept;
 
    const PeakGroup& operator[](Size i) const;
    PeakGroup& operator[](Size i);
    void push_back(const PeakGroup& pg);
    void emplace_back(const PeakGroup& pg);
    void pop_back();
    PeakGroup& back();
    Size size() const noexcept;
    void clear();
    void reserve(Size n);
    bool empty() const;
    bool isDecoy() const;
 
    void sort();
    void sortByQscore();
 
    bool operator<(const DeconvolvedSpectrum& a) const;
 
    bool operator>(const DeconvolvedSpectrum& a) const;
 
    bool operator==(const DeconvolvedSpectrum& a) const;
 
  private:
    std::vector<PeakGroup> peak_groups_;
    MSSpectrum spec_;
    PeakGroup precursor_peak_group_;
    Precursor precursor_peak_;
    Precursor::ActivationMethod activation_method_ = Precursor::ActivationMethod::CID;
    int scan_number_ = 0, precursor_scan_number_ = 0;
    double cv_ = 1e5;
    FLASHHelperClasses::IsobaricQuantities quantities_;
  };
} // namespace OpenMS