OpenMS  3.0.0
PeptideHit.h
Go to the documentation of this file.
1 // --------------------------------------------------------------------------
2 // OpenMS -- Open-Source Mass Spectrometry
3 // --------------------------------------------------------------------------
4 // Copyright The OpenMS Team -- Eberhard Karls University Tuebingen,
5 // ETH Zurich, and Freie Universitaet Berlin 2002-2022.
6 //
7 // This software is released under a three-clause BSD license:
8 // * Redistributions of source code must retain the above copyright
9 // notice, this list of conditions and the following disclaimer.
10 // * Redistributions in binary form must reproduce the above copyright
11 // notice, this list of conditions and the following disclaimer in the
12 // documentation and/or other materials provided with the distribution.
13 // * Neither the name of any author or any participating institution
14 // may be used to endorse or promote products derived from this software
15 // without specific prior written permission.
16 // For a full list of authors, refer to the file AUTHORS.
17 // --------------------------------------------------------------------------
18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
19 // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 // ARE DISCLAIMED. IN NO EVENT SHALL ANY OF THE AUTHORS OR THE CONTRIBUTING
22 // INSTITUTIONS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
23 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
24 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
25 // OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
26 // WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
27 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
28 // ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 //
30 // --------------------------------------------------------------------------
31 // $Maintainer: Timo Sachsenberg $
32 // $Authors: $
33 // --------------------------------------------------------------------------
34 
35 #pragma once
36 
37 #include <iosfwd>
38 #include <vector>
39 
40 #include <OpenMS/CONCEPT/Types.h>
45 
46 namespace OpenMS
47 {
55  class OPENMS_DLLAPI PeptideHit :
56  public MetaInfoInterface
57  {
58 public:
59 
84  {
85  String annotation = ""; // e.g. [alpha|ci$y3-H2O-NH3]
86  int charge = 0;
87  double mz = -1.;
88  double intensity = 0.;
89 
90  bool operator<(const PeptideHit::PeakAnnotation& other) const
91  {
92  // sensible to sort first by m/z and charge
93  return std::tie(mz, charge, annotation, intensity) < std::tie(other.mz, other.charge, other.annotation, other.intensity);
94  }
95 
96  bool operator==(const PeptideHit::PeakAnnotation& other) const
97  {
98  if (charge != other.charge || mz != other.mz ||
99  intensity != other.intensity || annotation != other.annotation) return false;
100  return true;
101  }
102 
103  static void writePeakAnnotationsString_(String& annotation_string, std::vector<PeptideHit::PeakAnnotation> annotations)
104  {
105  if (annotations.empty()) { return; }
106 
107  // sort by mz, charge, ...
108  stable_sort(annotations.begin(), annotations.end());
109 
110  String val;
111  for (auto& a : annotations)
112  {
113  annotation_string += String(a.mz) + "," + String(a.intensity) + "," + String(a.charge) + "," + String(a.annotation).quote();
114  if (&a != &annotations.back()) { annotation_string += "|"; }
115  }
116  }
117 
118  };
119 
120 public:
121 
123 
124  class OPENMS_DLLAPI ScoreMore
126  {
127 public:
128  template <typename Arg>
129  bool operator()(const Arg& a, const Arg& b)
130  {
131  return a.getScore() > b.getScore();
132  }
133 
134  };
135 
137  class OPENMS_DLLAPI ScoreLess
138  {
139 public:
140  template <typename Arg>
141  bool operator()(const Arg& a, const Arg& b)
142  {
143  return a.getScore() < b.getScore();
144  }
145 
146  };
147 
149  class OPENMS_DLLAPI RankLess
150  {
151 public:
152  template <typename Arg>
153  bool operator()(const Arg& a, const Arg& b)
154  {
155  return a.getRank() < b.getRank();
156  }
157 
158  };
160 
161 
163  class OPENMS_DLLAPI SequenceLessComparator
164  {
165  template <typename Arg>
166  bool operator()(const Arg& a, const Arg& b)
167  {
168  if (a.getSequence().toString() < b.getSequence().toString()) return true;
169  return false;
170  }
171  };
173 
175  class OPENMS_DLLAPI PepXMLAnalysisResult
176  {
177 public:
180  double main_score;
181  std::map<String, double> sub_scores;
182 
183  bool operator==(const PepXMLAnalysisResult& rhs) const
184  {
185  return score_type == rhs.score_type
186  && higher_is_better == rhs.higher_is_better
187  && main_score == rhs.main_score
188  && sub_scores == rhs.sub_scores;
189  }
190  };
191 
195  PeptideHit();
198  PeptideHit(double score,
199  UInt rank,
200  Int charge,
201  const AASequence& sequence);
203  PeptideHit(double score,
204  UInt rank,
205  Int charge,
206  AASequence&& sequence);
208  PeptideHit(const PeptideHit& source);
210  PeptideHit(PeptideHit&&) noexcept;
212  virtual ~PeptideHit();
213 
215  PeptideHit& operator=(const PeptideHit& source);
217  PeptideHit& operator=(PeptideHit&&) noexcept;
219 
221  bool operator==(const PeptideHit& rhs) const;
222 
224  bool operator!=(const PeptideHit& rhs) const;
225 
229  const AASequence& getSequence() const;
231 
233  void setSequence(const AASequence& sequence);
234 
236  void setSequence(AASequence&& sequence);
237 
239  Int getCharge() const;
240 
242  void setCharge(Int charge);
243 
245  const std::vector<PeptideEvidence>& getPeptideEvidences() const;
246 
248  void setPeptideEvidences(const std::vector<PeptideEvidence>& peptide_evidences);
249 
250  void setPeptideEvidences(std::vector<PeptideEvidence>&& peptide_evidences);
251 
253  void addPeptideEvidence(const PeptideEvidence& peptide_evidence);
254 
256  double getScore() const;
257 
259  void setScore(double score);
260 
262  void setAnalysisResults(std::vector<PepXMLAnalysisResult> aresult);
263 
265  void addAnalysisResults(PepXMLAnalysisResult aresult);
266 
268  const std::vector<PepXMLAnalysisResult>& getAnalysisResults() const;
269 
271  UInt getRank() const;
272 
274  void setRank(UInt newrank);
275 
277  std::vector<PeptideHit::PeakAnnotation>& getPeakAnnotations();
278  const std::vector<PeptideHit::PeakAnnotation>& getPeakAnnotations() const;
279 
280 
282  void setPeakAnnotations(std::vector<PeptideHit::PeakAnnotation> frag_annotations);
283 
285 
287  std::set<String> extractProteinAccessionsSet() const;
288 
289 protected:
290  AASequence sequence_;
291 
293  double score_;
294 
296  std::vector<PepXMLAnalysisResult>* analysis_results_;
297 
299  UInt rank_;
300 
302  Int charge_;
303 
305  std::vector<PeptideEvidence> peptide_evidences_;
306 
308  std::vector<PeptideHit::PeakAnnotation> fragment_annotations_;
309  };
310 
312  OPENMS_DLLAPI std::ostream& operator<< (std::ostream& stream, const PeptideHit& hit);
313 } // namespace OpenMS
OpenMS::PeptideHit::ScoreMore::operator()
bool operator()(const Arg &a, const Arg &b)
Definition: PeptideHit.h:129
OpenMS::PeptideHit::SequenceLessComparator
Lesser predicate for (modified) sequence of hits.
Definition: PeptideHit.h:163
Types.h
OpenMS::PeptideHit::PeakAnnotation::writePeakAnnotationsString_
static void writePeakAnnotationsString_(String &annotation_string, std::vector< PeptideHit::PeakAnnotation > annotations)
Definition: PeptideHit.h:103
OpenMS::PeptideHit::PepXMLAnalysisResult::score_type
String score_type
Definition: PeptideHit.h:178
OpenMS::PeptideHit::PepXMLAnalysisResult
Analysis Result (containing search engine / prophet results)
Definition: PeptideHit.h:175
OpenMS::String
A more convenient string class.
Definition: String.h:58
PeptideEvidence.h
OpenMS::PeptideHit::PeakAnnotation::operator==
bool operator==(const PeptideHit::PeakAnnotation &other) const
Definition: PeptideHit.h:96
OpenMS::PeptideHit::PeakAnnotation::operator<
bool operator<(const PeptideHit::PeakAnnotation &other) const
Definition: PeptideHit.h:90
OpenMS::Int
int Int
Signed integer type.
Definition: Types.h:102
OpenMS
Main OpenMS namespace.
Definition: FeatureDeconvolution.h:47
OpenMS::PeptideHit::PeakAnnotation::charge
int charge
Definition: PeptideHit.h:86
OpenMS::PeptideHit::RankLess::operator()
bool operator()(const Arg &a, const Arg &b)
Definition: PeptideHit.h:153
OpenMS::PeptideHit::PeakAnnotation::annotation
String annotation
Definition: PeptideHit.h:85
OpenMS::MetaInfoInterface
Interface for classes that can store arbitrary meta information (Type-Name-Value tuples).
Definition: MetaInfoInterface.h:60
OpenMS::PeptideHit::PepXMLAnalysisResult::operator==
bool operator==(const PepXMLAnalysisResult &rhs) const
additional scores attached to the original, aggregated score
Definition: PeptideHit.h:183
OpenMS::PeptideEvidence
Representation of a peptide evidence.
Definition: PeptideEvidence.h:50
OpenMS::PeptideHit::RankLess
Lesser predicate for scores of hits.
Definition: PeptideHit.h:149
OpenMS::PeptideHit::SequenceLessComparator::operator()
bool operator()(const Arg &a, const Arg &b)
Definition: PeptideHit.h:166
OpenMS::PeptideHit::PeakAnnotation::mz
double mz
Definition: PeptideHit.h:87
OpenMS::PeptideHit::PepXMLAnalysisResult::higher_is_better
bool higher_is_better
e.g. peptideprophet / interprophet
Definition: PeptideHit.h:179
OpenMS::PeptideHit::PeakAnnotation::intensity
double intensity
Definition: PeptideHit.h:88
OpenMS::PeptideHit::ScoreLess
Lesser predicate for scores of hits.
Definition: PeptideHit.h:137
OpenMS::UInt
unsigned int UInt
Unsigned integer type.
Definition: Types.h:94
OpenMS::String::quote
String & quote(char q='"', QuotingMethod method = ESCAPE)
Wraps the string in quotation marks.
OpenMS::PeptideHit::PepXMLAnalysisResult::main_score
double main_score
is higher score better ?
Definition: PeptideHit.h:180
AASequence.h
MetaInfoInterface.h
String.h
OpenMS::AASequence
Representation of a peptide/protein sequence.
Definition: AASequence.h:111
OpenMS::PeptideHit::PeakAnnotation
Contains annotations of a peak.
Definition: PeptideHit.h:83
OpenMS::PeptideHit::PepXMLAnalysisResult::sub_scores
std::map< String, double > sub_scores
posterior probability for example
Definition: PeptideHit.h:181
OpenMS::PeptideHit::ScoreLess::operator()
bool operator()(const Arg &a, const Arg &b)
Definition: PeptideHit.h:141
OpenMS::PeptideHit
Representation of a peptide hit.
Definition: PeptideHit.h:55