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-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: $
// --------------------------------------------------------------------------

#pragma once

#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;
    double mz;
    double intensity;

    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;
    }
};

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;
      }

      PepXMLAnalysisResult& operator=(const PepXMLAnalysisResult& source)
      {
        if (this == &source) return *this;
        score_type = source.score_type;
        higher_is_better = source.higher_is_better;
        main_score = source.main_score;
        sub_scores = source.sub_scores;
        return *this;
      }

    };

    PeptideHit();

    PeptideHit(double score,
               UInt rank,
               Int charge,
               const AASequence& sequence);

    PeptideHit(const PeptideHit& source);

    virtual ~PeptideHit();

    PeptideHit& operator=(const PeptideHit& source);

    bool operator==(const PeptideHit& rhs) const;

    bool operator!=(const PeptideHit& rhs) const;

    const AASequence& getSequence() const;

    void setSequence(const AASequence& sequence);

    Int getCharge() const;

    void setCharge(Int charge);

    const std::vector<PeptideEvidence>& getPeptideEvidences() const;

    void setPeptideEvidences(const 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_;
  };

} // namespace OpenMS