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 <functional>
 
#include <OpenMS/CONCEPT/Types.h>
#include <OpenMS/CONCEPT/Constants.h>
#include <OpenMS/CONCEPT/HashUtils.h>
#include <OpenMS/DATASTRUCTURES/String.h>
#include <OpenMS/METADATA/MetaInfoInterface.h>
#include <OpenMS/CHEMISTRY/AASequence.h>
#include <OpenMS/METADATA/PeptideEvidence.h>
 
namespace OpenMS
{
  class PeptideHit;
  using SpectrumMatch = PeptideHit; // better name that might become the default in future version
 
  class OPENMS_DLLAPI PeptideHit :
    public MetaInfoInterface
  {
public:
    enum class TargetDecoyType
    {
      TARGET,       
      DECOY,        
      TARGET_DECOY, 
      UNKNOWN       
    };
 
  struct OPENMS_DLLAPI 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;
 
    bool operator==(const PeptideHit::PeakAnnotation& other) const;
 
    static void writePeakAnnotationsString_(String& annotation_string, std::vector<PeptideHit::PeakAnnotation> annotations);
 
  };
 
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 SequenceChargeHash
    {
    public:
      std::size_t operator()(const PeptideHit& hit) const noexcept
      {
        std::size_t seed = std::hash<AASequence>{}(hit.getSequence());
        OpenMS::hash_combine(seed, OpenMS::hash_int(hit.getCharge()));
        return seed;
      }
    };
 
    class OPENMS_DLLAPI SequenceChargeEqual
    {
    public:
      bool operator()(const PeptideHit& a, const PeptideHit& b) const noexcept
      {
        return a.getSequence() == b.getSequence() && a.getCharge() == b.getCharge();
      }
    };
 
 
    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(const std::vector<PepXMLAnalysisResult>& aresult);
 
    void addAnalysisResults(const PepXMLAnalysisResult& aresult);
 
    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);
 
    bool isDecoy() const;
 
    void setTargetDecoyType(TargetDecoyType type);
 
    TargetDecoyType getTargetDecoyType() const;
 
 
    std::set<String> extractProteinAccessionsSet() const;
 
protected:
    AASequence sequence_;
 
    double score_{};
 
    Int charge_{};
 
    std::vector<PeptideEvidence> peptide_evidences_;
 
    std::vector<PeptideHit::PeakAnnotation> fragment_annotations_;
 
private:
    size_t getNumberOfAnalysisResultsFromMetaValues_() const;
 
    std::vector<PepXMLAnalysisResult> extractAnalysisResultsFromMetaValues_() const;
  };
 
  OPENMS_DLLAPI std::ostream& operator<< (std::ostream& stream, const PeptideHit& hit);
} // namespace OpenMS
 
// Hash function specialization for PeptideHit::PeakAnnotation
namespace std
{
  template<>
  struct hash<OpenMS::PeptideHit::PeakAnnotation>
  {
    std::size_t operator()(const OpenMS::PeptideHit::PeakAnnotation& pa) const noexcept
    {
      std::size_t seed = OpenMS::fnv1a_hash_string(pa.annotation);
      OpenMS::hash_combine(seed, OpenMS::hash_int(pa.charge));
      OpenMS::hash_combine(seed, OpenMS::hash_float(pa.mz));
      OpenMS::hash_combine(seed, OpenMS::hash_float(pa.intensity));
      return seed;
    }
  };
} // namespace std
 
// Hash function specialization for PeptideHit
namespace std
{
  template<>
  struct hash<OpenMS::PeptideHit>
  {
    std::size_t operator()(const OpenMS::PeptideHit& hit) const noexcept
    {
      // Start with MetaInfoInterface hash (includes rank which is stored as meta value)
      std::size_t seed = std::hash<OpenMS::MetaInfoInterface>{}(hit);
 
      // Hash sequence
      OpenMS::hash_combine(seed, std::hash<OpenMS::AASequence>{}(hit.getSequence()));
 
      // Hash score
      OpenMS::hash_combine(seed, OpenMS::hash_float(hit.getScore()));
 
      // Note: rank is NOT hashed separately - it's included via MetaInfoInterface above
      // (rank is stored as meta value "rank" when non-zero)
 
      // Hash charge
      OpenMS::hash_combine(seed, OpenMS::hash_int(hit.getCharge()));
 
      // Hash peptide evidences
      for (const auto& pe : hit.getPeptideEvidences())
      {
        OpenMS::hash_combine(seed, std::hash<OpenMS::PeptideEvidence>{}(pe));
      }
 
      // Hash fragment annotations
      for (const auto& fa : hit.getPeakAnnotations())
      {
        OpenMS::hash_combine(seed, std::hash<OpenMS::PeptideHit::PeakAnnotation>{}(fa));
      }
 
      return seed;
    }
  };
} // namespace std