PeptideHit.h

Go to the documentation of this file.

// Copyright (c) 2002-present, OpenMS Inc. -- EKU Tuebingen, ETH Zurich, and FU Berlin
// SPDX-License-Identifier: BSD-3-Clause
//
// --------------------------------------------------------------------------
// $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
      return std::tie(mz, charge, annotation, intensity) < std::tie(other.mz, other.charge, other.annotation, other.intensity);
    }
 
    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; 
      bool higher_is_better{}; 
      double main_score{}; 
      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;
 
    AASequence& getSequence();
 
    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(const PepXMLAnalysisResult& aresult);
 
    const std::vector<PepXMLAnalysisResult>& getAnalysisResults() const;
 
    UInt getRank() const;
 
    void setRank(UInt newrank);
 
    std::vector<PeptideHit::PeakAnnotation>& getPeakAnnotations();
    const 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