Home  · Classes  · Annotated Classes  · Modules  · Members  · Namespaces  · Related Pages
Residue.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-2015.
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: Andreas Bertsch $
32 // $Authors: Andreas Bertsch $
33 // --------------------------------------------------------------------------
34 //
35 
36 #ifndef OPENMS_CHEMISTRY_RESIDUE_H
37 #define OPENMS_CHEMISTRY_RESIDUE_H
38 
40 #include <OpenMS/CONCEPT/Types.h>
42 
43 #include <iosfwd>
44 #include <set>
45 #include <vector>
46 
47 namespace OpenMS
48 {
49 
62  class OPENMS_DLLAPI Residue
63  {
64 public:
65 
69  // Internal
70  inline static const EmpiricalFormula & getInternalToFull()
71  {
72  static const EmpiricalFormula internal_to_full = EmpiricalFormula("H2O");
73  return internal_to_full;
74  }
75 
76  inline static double getInternalToFullAverageWeight()
77  {
78  static const double internal_to_full_average_weight = getInternalToFull().getAverageWeight();
79  return internal_to_full_average_weight;
80  }
81 
82  inline static double getInternalToFullMonoWeight()
83  {
84  static const double internal_to_full_mono_weight = getInternalToFull().getMonoWeight();
85  return internal_to_full_mono_weight;
86  }
87 
88  // N-terminal
89  inline static const EmpiricalFormula & getNTerminalToFull()
90  {
91  static const EmpiricalFormula Nterminal_to_full = EmpiricalFormula("HO");
92  return Nterminal_to_full;
93  }
94 
95  inline static double getNTerminalToFullAverageWeight()
96  {
97  static const double Nterminal_to_full_average_weight = getNTerminalToFull().getAverageWeight();
98  return Nterminal_to_full_average_weight;
99  }
100 
101  inline static double getNTerminalToFullMonoWeight()
102  {
103  static const double Nterminal_to_full_mono_weight = getNTerminalToFull().getMonoWeight();
104  return Nterminal_to_full_mono_weight;
105  }
106 
107  // C-terminal
108  inline static const EmpiricalFormula & getCTerminalToFull()
109  {
110  static const EmpiricalFormula Cterminal_to_full = EmpiricalFormula("H");
111  return Cterminal_to_full;
112  }
113 
114  inline static double getCTerminalToFullAverageWeight()
115  {
116  static const double Cterminal_to_full_average_weight = getCTerminalToFull().getAverageWeight();
117  return Cterminal_to_full_average_weight;
118  }
119 
120  inline static double getCTerminalToFullMonoWeight()
121  {
122  static const double Cterminal_to_full_mono_weight = getCTerminalToFull().getMonoWeight();
123  return Cterminal_to_full_mono_weight;
124  }
125 
126  // b ion
127  inline static const EmpiricalFormula & getBIonToFull()
128  {
129  static const EmpiricalFormula b_ion_to_full = EmpiricalFormula("HO");
130  return b_ion_to_full;
131  }
132 
133  inline static double getBIonToFullAverageWeight()
134  {
135  static const double b_ion_to_full_average_weight = getBIonToFull().getAverageWeight();
136  return b_ion_to_full_average_weight;
137  }
138 
139  inline static double getBIonToFullMonoWeight()
140  {
141  static const double b_ion_to_full_mono_weight = getBIonToFull().getMonoWeight();
142  return b_ion_to_full_mono_weight;
143  }
144 
145  // a ion
146  inline static const EmpiricalFormula & getAIonToFull()
147  {
148  static const EmpiricalFormula a_ion_to_full = EmpiricalFormula("HCO2");
149  return a_ion_to_full;
150  }
151 
152  inline static double getAIonToFullAverageWeight()
153  {
154  static const double a_ion_to_full_average_weight = getAIonToFull().getAverageWeight();
155  return a_ion_to_full_average_weight;
156  }
157 
158  inline static double getAIonToFullMonoWeight()
159  {
160  static const double a_ion_to_full_mono_weight = getAIonToFull().getMonoWeight();
161  return a_ion_to_full_mono_weight;
162  }
163 
164  // y ion
165  inline static const EmpiricalFormula & getYIonToFull()
166  {
167  static const EmpiricalFormula y_ion_to_full = EmpiricalFormula("");
168  return y_ion_to_full;
169  }
170 
171  inline static double getYIonToFullAverageWeight()
172  {
173  static const double y_ion_to_full_average_weight = getYIonToFull().getAverageWeight();
174  return y_ion_to_full_average_weight;
175  }
176 
177  inline static double getYIonToFullMonoWeight()
178  {
179  static const double y_ion_to_full_mono_weight = getYIonToFull().getMonoWeight();
180  return y_ion_to_full_mono_weight;
181  }
182 
183  // c ion
184  inline static const EmpiricalFormula & getCIonToFull()
185  {
186  static const EmpiricalFormula c_ion_to_full = EmpiricalFormula("H-1");
187  return c_ion_to_full;
188  }
189 
190  inline static double getCIonToFullAverageWeight()
191  {
192  static const double c_ion_to_full_average_weight = getCIonToFull().getAverageWeight();
193  return c_ion_to_full_average_weight;
194  }
195 
196  inline static double getCIonToFullMonoWeight()
197  {
198  static const double c_ion_to_full_mono_weight = getCIonToFull().getMonoWeight();
199  return c_ion_to_full_mono_weight;
200  }
201 
202  // c-1 ion
203  inline static const EmpiricalFormula & getCIonMinusOneToFull()
204  {
205  static const EmpiricalFormula c_ion_to_full = EmpiricalFormula("H-2");
206  return c_ion_to_full;
207  }
208 
209  inline static double getCIonMinusOneToFullAverageWeight()
210  {
211  static const double c_ion_to_full_average_weight = getCIonMinusOneToFull().getAverageWeight();
212  return c_ion_to_full_average_weight;
213  }
214 
215  inline static double getCIonMinusOneToFullMonoWeight()
216  {
217  static const double c_ion_to_full_mono_weight = getCIonMinusOneToFull().getMonoWeight();
218  return c_ion_to_full_mono_weight;
219  }
220 
221  // c+1 ion
222  inline static const EmpiricalFormula & getCIonPlusOneToFull()
223  {
224  static const EmpiricalFormula c_ion_to_full = EmpiricalFormula("");
225  return c_ion_to_full;
226  }
227 
228  inline static double getCIonPlusOneToFullAverageWeight()
229  {
230  static const double c_ion_to_full_average_weight = getCIonPlusOneToFull().getAverageWeight();
231  return c_ion_to_full_average_weight;
232  }
233 
234  inline static double getCIonPlusOneToFullMonoWeight()
235  {
236  static const double c_ion_to_full_mono_weight = getCIonPlusOneToFull().getMonoWeight();
237  return c_ion_to_full_mono_weight;
238  }
239 
240  // c+2 ion
241  inline static const EmpiricalFormula & getCIonPlusTwoToFull()
242  {
243  static const EmpiricalFormula c_ion_to_full = EmpiricalFormula("H2");
244  return c_ion_to_full;
245  }
246 
247  inline static double getCIonPlusTwoToFullAverageWeight()
248  {
249  static const double c_ion_to_full_average_weight = getCIonPlusTwoToFull().getAverageWeight();
250  return c_ion_to_full_average_weight;
251  }
252 
253  inline static double getCIonPlusTwoToFullMonoWeight()
254  {
255  static const double c_ion_to_full_mono_weight = getCIonPlusTwoToFull().getMonoWeight();
256  return c_ion_to_full_mono_weight;
257  }
258 
259  // x ion
260  inline static const EmpiricalFormula & getXIonToFull()
261  {
262  static const EmpiricalFormula x_ion_to_full = EmpiricalFormula("HCO");
263  return x_ion_to_full;
264  }
265 
266  inline static double getXIonToFullAverageWeight()
267  {
268  static const double x_ion_to_full_average_weight = getXIonToFull().getAverageWeight();
269  return x_ion_to_full_average_weight;
270  }
271 
272  inline static double getXIonToFullMonoWeight()
273  {
274  static const double x_ion_to_full_mono_weight = getXIonToFull().getMonoWeight();
275  return x_ion_to_full_mono_weight;
276  }
277 
278  // z ion
279  inline static const EmpiricalFormula & getZIonToFull()
280  {
281  static const EmpiricalFormula z_ion_to_full = EmpiricalFormula("NH2");
282  return z_ion_to_full;
283  }
284 
285  inline static double getZIonToFullAverageWeight()
286  {
287  static const double z_ion_to_full_average_weight = getZIonToFull().getAverageWeight();
288  return z_ion_to_full_average_weight;
289  }
290 
291  inline static double getZIonToFullMonoWeight()
292  {
293  static const double z_ion_to_full_mono_weight = getZIonToFull().getMonoWeight();
294  return z_ion_to_full_mono_weight;
295  }
296 
297  // z-1 ion
298  inline static const EmpiricalFormula & getZIonMinusOneToFull()
299  {
300  static const EmpiricalFormula z_ion_to_full = EmpiricalFormula("N2");
301  return z_ion_to_full;
302  }
303 
304  inline static double getZIonMinusOneToFullAverageWeight()
305  {
306  static const double z_ion_to_full_average_weight = getZIonMinusOneToFull().getAverageWeight();
307  return z_ion_to_full_average_weight;
308  }
309 
310  inline static double getZIonMinusOneToFullMonoWeight()
311  {
312  static const double z_ion_to_full_mono_weight = getZIonMinusOneToFull().getMonoWeight();
313  return z_ion_to_full_mono_weight;
314  }
315 
316  // z+1 ion
317  inline static const EmpiricalFormula & getZIonPlusOneToFull()
318  {
319  static const EmpiricalFormula z_ion_to_full = EmpiricalFormula("NH3");
320  return z_ion_to_full;
321  }
322 
323  inline static double getZIonPlusOneToFullAverageWeight()
324  {
325  static const double z_ion_to_full_average_weight = getZIonPlusOneToFull().getAverageWeight();
326  return z_ion_to_full_average_weight;
327  }
328 
329  inline static double getZIonPlusOneToFullMonoWeight()
330  {
331  static const double z_ion_to_full_mono_weight = getZIonPlusOneToFull().getMonoWeight();
332  return z_ion_to_full_mono_weight;
333  }
334 
335  // z+2 ion
336  inline static const EmpiricalFormula & getZIonPlusTwoToFull()
337  {
338  static const EmpiricalFormula z_ion_to_full = EmpiricalFormula("NH4");
339  return z_ion_to_full;
340  }
341 
342  inline static double getZIonPlusTwoToFullAverageWeight()
343  {
344  static const double z_ion_to_full_average_weight = getZIonPlusTwoToFull().getAverageWeight();
345  return z_ion_to_full_average_weight;
346  }
347 
348  inline static double getZIonPlusTwoToFullMonoWeight()
349  {
350  static const double z_ion_to_full_mono_weight = getZIonPlusTwoToFull().getMonoWeight();
351  return z_ion_to_full_mono_weight;
352  }
353 
355 
360  {
361  Full = 0, // with N-terminus and C-terminus
362  Internal, // internal, without any termini
363  NTerminal, // only N-terminus
364  CTerminal, // only C-terminus
365  AIon, // N-terminus up to the C-alpha/carbonyl carbon bond
366  BIon, // N-terminus up to the peptide bond
367  CIonMinusOne, // N-terminus up to the amide/C-alpha bond
368  CIon, // N-terminus up to the amide/C-alpha bond
369  CIonPlusOne, // N-terminus up to the amide/C-alpha bond
370  CIonPlusTwo, // N-terminus up to the amide/C-alpha bond
371  XIon, // amide/C-alpha bond up to the C-terminus
372  YIon, // peptide bond up to the C-terminus
373  ZIonMinusOne, // C-alpha/carbonyl carbon bond
374  ZIon, // C-alpha/carbonyl carbon bond
375  ZIonPlusOne, // C-alpha/carbonyl carbon bond
376  ZIonPlusTwo, // C-alpha/carbonyl carbon bond
377  SizeOfResidueType
378 
380  };
382 
384  static String getResidueTypeName(const ResidueType res_type);
385 
386 
390  Residue();
392 
394  Residue(const Residue & residue);
395 
397  Residue(const String & name,
398  const String & three_letter_code,
399  const String & one_letter_code,
400  const EmpiricalFormula & formula);
401 
403  virtual ~Residue();
405 
409  Residue & operator=(const Residue & residue);
412 
416  void setName(const String & name);
418 
420  const String & getName() const;
421 
423  void setShortName(const String & short_name);
424 
426  const String & getShortName() const;
427 
429  void setSynonyms(const std::set<String> & synonyms);
430 
432  void addSynonym(const String & synonym);
433 
435  const std::set<String> & getSynonyms() const;
436 
438  void setThreeLetterCode(const String & three_letter_code);
439 
441  const String & getThreeLetterCode() const;
442 
444  void setOneLetterCode(const String & one_letter_code);
445 
447  const String & getOneLetterCode() const;
448 
450  void addLossFormula(const EmpiricalFormula &);
451 
453  void setLossFormulas(const std::vector<EmpiricalFormula> &);
454 
456  void addNTermLossFormula(const EmpiricalFormula &);
457 
459  void setNTermLossFormulas(const std::vector<EmpiricalFormula> &);
460 
462  const std::vector<EmpiricalFormula> & getLossFormulas() const;
463 
465  const std::vector<EmpiricalFormula> & getNTermLossFormulas() const;
466 
468  void setLossNames(const std::vector<String> & name);
469 
471  void setNTermLossNames(const std::vector<String> & name);
472 
474  void addLossName(const String & name);
475 
477  void addNTermLossName(const String & name);
478 
480  const std::vector<String> & getLossNames() const;
481 
483  const std::vector<String> & getNTermLossNames() const;
484 
486  void setFormula(const EmpiricalFormula & formula);
487 
489  EmpiricalFormula getFormula(ResidueType res_type = Full) const;
490 
492  void setAverageWeight(double weight);
493 
495  double getAverageWeight(ResidueType res_type = Full) const;
496 
498  void setMonoWeight(double weight);
499 
501  double getMonoWeight(ResidueType res_type = Full) const;
502 
504  void setModification(const String & name);
505 
507  const String & getModification() const;
508 
510  void setLowMassIons(const std::vector<EmpiricalFormula> & low_mass_ions);
511 
513  const std::vector<EmpiricalFormula> & getLowMassIons() const;
514 
516  void setResidueSets(const std::set<String> & residues_sets);
517 
519  void addResidueSet(const String & residue_sets);
520 
522  const std::set<String> & getResidueSets() const;
524 
528  bool hasNeutralLoss() const;
530 
532  bool hasNTermNeutralLosses() const;
533 
535  bool operator==(const Residue & residue) const;
536 
538  bool operator!=(const Residue & residue) const;
539 
541  bool operator==(char one_letter_code) const;
542 
544  bool operator!=(char one_letter_code) const;
545 
547  double getPka() const;
548 
550  double getPkb() const;
551 
553  double getPkc() const;
554 
556  double getPiValue() const;
557 
559  void setPka(double value);
560 
562  void setPkb(double value);
563 
565  void setPkc(double value);
566 
568  double getSideChainBasicity() const;
569 
571  void setSideChainBasicity(double gb_sc);
572 
574  double getBackboneBasicityLeft() const;
575 
577  void setBackboneBasicityLeft(double gb_bb_l);
578 
580  double getBackboneBasicityRight() const;
581 
583  void setBackboneBasicityRight(double gb_bb_r);
584 
586  bool isModified() const;
587 
589  bool isInResidueSet(const String & residue_set);
591 
593  friend OPENMS_DLLAPI std::ostream & operator<<(std::ostream & os, const Residue & residue);
594 
595 protected:
596 
597  // basic
599 
601 
602  std::set<String> synonyms_;
603 
605 
607 
609 
611 
613 
614  double mono_weight_;
615 
616  // modification
618 
620 
622 
623  // loss
624  std::vector<String> loss_names_;
625 
626  std::vector<EmpiricalFormula> loss_formulas_;
627 
628  std::vector<String> NTerm_loss_names_;
629 
630  std::vector<EmpiricalFormula> NTerm_loss_formulas_;
631 
633 
635 
636  // low mass markers like immonium ions
637  std::vector<EmpiricalFormula> low_mass_ions_;
638 
639  // pka values
640  double pka_;
641 
642  // pkb values
643  double pkb_;
644 
645  // pkc values
646  double pkc_;
647 
648  double gb_sc_;
649 
650  double gb_bb_l_;
651 
652  double gb_bb_r_;
653 
654  // residue sets this amino acid is contained in
655  std::set<String> residue_sets_;
656 
657  };
658 
659  OPENMS_DLLAPI std::ostream & operator<<(std::ostream & os, const Residue & residue);
660 
661 }
662 
663 #endif
Definition: Residue.h:365
static const EmpiricalFormula & getZIonPlusTwoToFull()
Definition: Residue.h:336
static const EmpiricalFormula & getBIonToFull()
Definition: Residue.h:127
Definition: Residue.h:372
static double getBIonToFullMonoWeight()
Definition: Residue.h:139
static double getYIonToFullMonoWeight()
Definition: Residue.h:177
static double getCIonToFullMonoWeight()
Definition: Residue.h:196
std::vector< String > loss_names_
Definition: Residue.h:624
A more convenient string class.
Definition: String.h:57
std::vector< String > NTerm_loss_names_
Definition: Residue.h:628
double pkc_
Definition: Residue.h:646
Definition: Residue.h:362
static double getYIonToFullAverageWeight()
Definition: Residue.h:171
Definition: Residue.h:363
static double getCIonPlusTwoToFullMonoWeight()
Definition: Residue.h:253
double gb_bb_r_
Definition: Residue.h:652
static const EmpiricalFormula & getInternalToFull()
Definition: Residue.h:70
static double getCIonPlusOneToFullMonoWeight()
Definition: Residue.h:234
static const EmpiricalFormula & getYIonToFull()
Definition: Residue.h:165
Definition: Residue.h:364
static double getNTerminalToFullMonoWeight()
Definition: Residue.h:101
double pka_
Definition: Residue.h:640
static const EmpiricalFormula & getCIonPlusOneToFull()
Definition: Residue.h:222
double gb_sc_
Definition: Residue.h:648
static const EmpiricalFormula & getCIonToFull()
Definition: Residue.h:184
static const EmpiricalFormula & getZIonMinusOneToFull()
Definition: Residue.h:298
static double getCIonMinusOneToFullMonoWeight()
Definition: Residue.h:215
Representation of a residue.
Definition: Residue.h:62
std::vector< EmpiricalFormula > loss_formulas_
Definition: Residue.h:626
double gb_bb_l_
Definition: Residue.h:650
static double getCIonToFullAverageWeight()
Definition: Residue.h:190
static double getCTerminalToFullMonoWeight()
Definition: Residue.h:120
double loss_mono_weight_
Definition: Residue.h:634
static double getZIonPlusOneToFullMonoWeight()
Definition: Residue.h:329
static double getZIonToFullAverageWeight()
Definition: Residue.h:285
std::vector< EmpiricalFormula > low_mass_ions_
Definition: Residue.h:637
static double getCIonPlusOneToFullAverageWeight()
Definition: Residue.h:228
Definition: Residue.h:376
static double getZIonToFullMonoWeight()
Definition: Residue.h:291
Representation of an empirical formula.
Definition: EmpiricalFormula.h:79
Definition: Residue.h:374
Definition: Residue.h:370
static double getXIonToFullMonoWeight()
Definition: Residue.h:272
void setModification(int location, int max_size, String modification, OpenMS::AASequence &aas)
helper function that sets a modification on a AASequence object
static const EmpiricalFormula & getZIonToFull()
Definition: Residue.h:279
static double getCIonPlusTwoToFullAverageWeight()
Definition: Residue.h:247
static double getZIonPlusTwoToFullAverageWeight()
Definition: Residue.h:342
static const EmpiricalFormula & getZIonPlusOneToFull()
Definition: Residue.h:317
static const EmpiricalFormula & getAIonToFull()
Definition: Residue.h:146
static const EmpiricalFormula & getCIonMinusOneToFull()
Definition: Residue.h:203
static double getZIonMinusOneToFullMonoWeight()
Definition: Residue.h:310
static double getXIonToFullAverageWeight()
Definition: Residue.h:266
std::ostream & operator<<(std::ostream &os, const AccurateMassSearchResult &amsr)
static const EmpiricalFormula & getCIonPlusTwoToFull()
Definition: Residue.h:241
double average_weight_
Definition: Residue.h:612
String short_name_
Definition: Residue.h:600
Definition: Residue.h:371
Definition: Residue.h:375
static const EmpiricalFormula & getCTerminalToFull()
Definition: Residue.h:108
EmpiricalFormula internal_formula_
Definition: Residue.h:610
double mono_weight_
Definition: Residue.h:614
static double getZIonPlusTwoToFullMonoWeight()
Definition: Residue.h:348
static double getCIonMinusOneToFullAverageWeight()
Definition: Residue.h:209
static double getAIonToFullAverageWeight()
Definition: Residue.h:152
static double getAIonToFullMonoWeight()
Definition: Residue.h:158
String name_
Definition: Residue.h:598
static double getZIonMinusOneToFullAverageWeight()
Definition: Residue.h:304
String three_letter_code_
Definition: Residue.h:604
ResidueType
Definition: Residue.h:359
static double getBIonToFullAverageWeight()
Definition: Residue.h:133
double pkb_
Definition: Residue.h:643
bool is_modified_
Definition: Residue.h:617
static double getZIonPlusOneToFullAverageWeight()
Definition: Residue.h:323
Definition: Residue.h:366
Definition: Residue.h:367
static const EmpiricalFormula & getXIonToFull()
Definition: Residue.h:260
std::set< String > synonyms_
Definition: Residue.h:602
String pre_mod_name_
Definition: Residue.h:619
EmpiricalFormula formula_
Definition: Residue.h:608
double loss_average_weight_
Definition: Residue.h:632
String modification_
Definition: Residue.h:621
static double getNTerminalToFullAverageWeight()
Definition: Residue.h:95
static const EmpiricalFormula & getNTerminalToFull()
Definition: Residue.h:89
static double getInternalToFullMonoWeight()
Definition: Residue.h:82
static double getCTerminalToFullAverageWeight()
Definition: Residue.h:114
static double getInternalToFullAverageWeight()
Definition: Residue.h:76
Definition: Residue.h:373
std::set< String > residue_sets_
Definition: Residue.h:655
Definition: Residue.h:369
std::vector< EmpiricalFormula > NTerm_loss_formulas_
Definition: Residue.h:630
String one_letter_code_
Definition: Residue.h:606
Definition: Residue.h:368

OpenMS / TOPP release 2.0.0 Documentation generated on Wed Mar 30 2016 16:18:41 using doxygen 1.8.5