PeptideHit.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-2020.
//
// 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: $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <iosfwd>
#include <vector>
 
#include <OpenMS/CONCEPT/Types.h>
#include <OpenMS/DATASTRUCTURES/String.h>
#include <OpenMS/METADATA/MetaInfoInterface.h>
#include <OpenMS/CHEMISTRY/AASequence.h>
#include <OpenMS/METADATA/PeptideEvidence.h>
 
namespace OpenMS
{
  class OPENMS_DLLAPI PeptideHit :
    public MetaInfoInterface
  {
public:
 
  struct PeakAnnotation
  {
    String annotation = "";  // e.g. [alpha|ci$y3-H2O-NH3]
    int charge = 0;
    double mz = -1.;
    double intensity = 0.;
 
    bool operator<(const PeptideHit::PeakAnnotation& other) const
    {
      // sensible to sort first by m/z and charge
      if (mz < other.mz)
      {
        return true;
      }
      else if (mz > other.mz)
      {
        return false;
      }
 
      if (charge < other.charge)
      {
        return true;
      }
      else if (charge > other.charge)
      {
        return false;
      }
 
      if (annotation < other.annotation)
      {
        return true;
      }
      else if (annotation > other.annotation)
      {
        return false;
      }
 
      if (intensity < other.intensity)
      {
        return true;
      }
      else if (intensity > other.intensity)
      {
        return false;
      }
 
      return false;
    }
 
    bool operator==(const PeptideHit::PeakAnnotation& other) const
    {
      if (charge != other.charge || mz != other.mz ||
          intensity != other.intensity || annotation != other.annotation) return false;
      return true;
    }
 
    static void writePeakAnnotationsString_(String& annotation_string, std::vector<PeptideHit::PeakAnnotation> annotations)
    {
      if (annotations.empty()) { return; }
 
      // sort by mz, charge, ...
      stable_sort(annotations.begin(), annotations.end());
 
      String val;
      for (auto& a : annotations)
      {
        annotation_string += String(a.mz) + "," + String(a.intensity) + "," + String(a.charge) + "," + String(a.annotation).quote();
        if (&a != &annotations.back()) { annotation_string += "|"; }
      }
    }
 
  };
 
public:
 
 
    class OPENMS_DLLAPI ScoreMore
    {
public:
      template <typename Arg>
      bool operator()(const Arg& a, const Arg& b)
      {
        return a.getScore() > b.getScore();
      }
 
    };
 
    class OPENMS_DLLAPI ScoreLess
    {
public:
      template <typename Arg>
      bool operator()(const Arg& a, const Arg& b)
      {
        return a.getScore() < b.getScore();
      }
 
    };
 
    class OPENMS_DLLAPI RankLess
    {
public:
      template <typename Arg>
      bool operator()(const Arg& a, const Arg& b)
      {
        return a.getRank() < b.getRank();
      }
 
    };
 
 
    class OPENMS_DLLAPI SequenceLessComparator
    {
      template <typename Arg>
      bool operator()(const Arg& a, const Arg& b)
      {
        if (a.getSequence().toString() < b.getSequence().toString()) return true;
        return false;
      }
    };
 
    class OPENMS_DLLAPI PepXMLAnalysisResult
    {
public:
      String score_type; // e.g. peptideprophet / interprophet
      bool higher_is_better; // is higher score better ?
      double main_score; // posterior probability for example
      std::map<String, double> sub_scores; 
 
      bool operator==(const PepXMLAnalysisResult& rhs) const
      {
        return score_type == rhs.score_type
          && higher_is_better == rhs.higher_is_better
          && main_score == rhs.main_score
          && sub_scores == rhs.sub_scores;
      }
    };
 
    PeptideHit();
    PeptideHit(double score,
               UInt rank,
               Int charge,
               const AASequence& sequence);
    PeptideHit(double score,
               UInt rank,
               Int charge,
               AASequence&& sequence);
    PeptideHit(const PeptideHit& source);
    PeptideHit(PeptideHit&&) noexcept;
    virtual ~PeptideHit();
 
    PeptideHit& operator=(const PeptideHit& source);
    PeptideHit& operator=(PeptideHit&&) noexcept;
 
    bool operator==(const PeptideHit& rhs) const;
 
    bool operator!=(const PeptideHit& rhs) const;
 
    const AASequence& getSequence() const;
 
    void setSequence(const AASequence& sequence);
 
    void setSequence(AASequence&& sequence);
 
    Int getCharge() const;
 
    void setCharge(Int charge);
 
    const std::vector<PeptideEvidence>& getPeptideEvidences() const;
 
    void setPeptideEvidences(const std::vector<PeptideEvidence>& peptide_evidences);
 
    void setPeptideEvidences(std::vector<PeptideEvidence>&& peptide_evidences);
 
    void addPeptideEvidence(const PeptideEvidence& peptide_evidence);
 
    double getScore() const;
 
    void setScore(double score);
 
    void setAnalysisResults(std::vector<PepXMLAnalysisResult> aresult);
 
    void addAnalysisResults(PepXMLAnalysisResult aresult);
 
    const std::vector<PepXMLAnalysisResult>& getAnalysisResults() const;
 
    UInt getRank() const;
 
    void setRank(UInt newrank);
 
    std::vector<PeptideHit::PeakAnnotation> getPeakAnnotations() const;
 
    void setPeakAnnotations(std::vector<PeptideHit::PeakAnnotation> frag_annotations);
 
 
    std::set<String> extractProteinAccessionsSet() const;
 
protected:
    AASequence sequence_;
 
    double score_;
 
    std::vector<PepXMLAnalysisResult>* analysis_results_;
 
    UInt rank_;
 
    Int charge_;
 
    std::vector<PeptideEvidence> peptide_evidences_;
 
    std::vector<PeptideHit::PeakAnnotation> fragment_annotations_;
  };
 
  OPENMS_DLLAPI std::ostream& operator<< (std::ostream& stream, const PeptideHit& hit);
} // namespace OpenMS