Home  · Classes  · Annotated Classes  · Modules  · Members  · Namespaces  · Related Pages
AAIndex.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-2017.
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 #ifndef OPENMS_CHEMISTRY_AAINDEX_H
36 #define OPENMS_CHEMISTRY_AAINDEX_H
37 
38 #include <OpenMS/CONCEPT/Exception.h>
39 #include <OpenMS/CONCEPT/Constants.h>
40 
41 #include <cmath>
42 
43 namespace OpenMS
44 {
70  class OPENMS_DLLAPI AAIndex
71  {
72 public:
73 
75  static double aliphatic(char aa)
76  {
77  if (aa == 'A' || aa == 'G' || aa == 'F' || aa == 'I' || aa == 'M' || aa == 'L' || aa == 'P' || aa == 'V')
78  {
79  return 1.0;
80  }
81  else
82  {
83  return 0.0;
84  }
85  }
86 
88  static double acidic(char aa)
89  {
90  if (aa == 'D' || aa == 'E')
91  {
92  return 1.0;
93  }
94  else
95  {
96  return 0.0;
97  }
98  }
99 
101  static double basic(char aa)
102  {
103  if (aa == 'K' || aa == 'R' || aa == 'H' || aa == 'W')
104  {
105  return 1.0;
106  }
107  else
108  {
109  return 0.0;
110  }
111  }
112 
114  static double polar(char aa)
115  {
116  if (aa == 'S' || aa == 'T' || aa == 'Y' || aa == 'H' || aa == 'C' || aa == 'N' || aa == 'Q' || aa == 'W')
117  {
118  return 1.0;
119  }
120  else
121  {
122  return 0.0;
123  }
124  }
125 
126  //I A/L R/K N/M D/F C/P Q/S E/T G/W H/Y I/V
127  //49.1 133. -3.6 0. 0. 20. 0. 64.6 75.7 18.9
128  //15.6 0. 6.8 54.7 43.8 44.4 31.0 70.5 0. 29.5
139  static double getKHAG800101(char aa)
140  {
141  switch (aa)
142  {
143  case 'A':
144  return 49.1;
145 
146  case 'R':
147  return 133.;
148 
149  case 'N':
150  return -3.6;
151 
152  case 'D':
153  return 0.;
154 
155  case 'C':
156  return 0.;
157 
158  case 'Q':
159  return 20.;
160 
161  case 'E':
162  return 0.;
163 
164  case 'G':
165  return 64.6;
166 
167  case 'H':
168  return 75.7;
169 
170  case 'I':
171  return 18.9;
172 
173  case 'L':
174  return 15.6;
175 
176  case 'K':
177  return 0.;
178 
179  case 'M':
180  return 6.8;
181 
182  case 'F':
183  return 54.7;
184 
185  case 'P':
186  return 43.8;
187 
188  case 'S':
189  return 44.4;
190 
191  case 'T':
192  return 31.0;
193 
194  case 'W':
195  return 70.5;
196 
197  case 'Y':
198  return 0.;
199 
200  case 'V':
201  return 29.5;
202 
203  default:
204  throw Exception::InvalidValue(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Unknown amino acid one-letter-code", String(aa));
205  }
206  }
207 
208  //I A/L R/K N/M D/F C/P Q/S E/T G/W H/Y I/V
209  //0.159 0.194 0.385 0.283 0.187 0.236 0.206 0.049 0.233 0.581
210  //0.083 0.159 0.198 0.682 0.366 0.150 0.074 0.463 0.737 0.301
211 
223  static double getVASM830103(char aa)
224  {
225  switch (aa)
226  {
227  case 'A':
228  return 0.159;
229 
230  case 'R':
231  return 0.194;
232 
233  case 'N':
234  return 0.385;
235 
236  case 'D':
237  return 0.283;
238 
239  case 'C':
240  return 0.187;
241 
242  case 'Q':
243  return 0.236;
244 
245  case 'E':
246  return 0.206;
247 
248  case 'G':
249  return 0.049;
250 
251  case 'H':
252  return 0.233;
253 
254  case 'I':
255  return 0.581;
256 
257  case 'L':
258  return 0.083;
259 
260  case 'K':
261  return 0.159;
262 
263  case 'M':
264  return 0.198;
265 
266  case 'F':
267  return 0.682;
268 
269  case 'P':
270  return 0.366;
271 
272  case 'S':
273  return 0.150;
274 
275  case 'T':
276  return 0.074;
277 
278  case 'W':
279  return 0.463;
280 
281  case 'Y':
282  return 0.737;
283 
284  case 'V':
285  return 0.301;
286 
287  default:
288  throw Exception::InvalidValue(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Unknown amino acid one-letter-code", String(aa));
289  }
290  }
291 
292  //NADH010105 0.958 NADH010104 0.914 NADH010103 0.881<br>
293  //ZHOH040103 0.819 NADH010107 0.811 BAEK050101 0.809<br>
294  //NADH010102 0.808 PONP800103 0.803 VINM940103 -0.813<br>
295  //KRIW710101 -0.846 KRIW790101 -0.861
296  //I A/L R/K N/M D/F C/P Q/S E/T G/W H/Y I/V
297  //5 -57 -77 45 224 -67 -8 -47 -50 83
298  //82 -38 83 117 -103 -41 79 130 27 117
299 
310  static double getNADH010106(char aa)
311  {
312  switch (aa)
313  {
314  case 'A':
315  return 5;
316 
317  case 'R':
318  return -57;
319 
320  case 'N':
321  return -77;
322 
323  case 'D':
324  return 45;
325 
326  case 'C':
327  return 224;
328 
329  case 'Q':
330  return -67;
331 
332  case 'E':
333  return -8;
334 
335  case 'G':
336  return -47;
337 
338  case 'H':
339  return -50;
340 
341  case 'I':
342  return 83;
343 
344  case 'L':
345  return 82;
346 
347  case 'K':
348  return -38;
349 
350  case 'M':
351  return 83;
352 
353  case 'F':
354  return 117;
355 
356  case 'P':
357  return -103;
358 
359  case 'S':
360  return -41;
361 
362  case 'T':
363  return 79;
364 
365  case 'W':
366  return 130;
367 
368  case 'Y':
369  return 27;
370 
371  case 'V':
372  return 117;
373 
374  default:
375  throw Exception::InvalidValue(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Unknown amino acid one-letter-code", String(aa));
376  }
377  }
378 
379  //NADH010106 0.811
380  //I A/L R/K N/M D/F C/P Q/S E/T G/W H/Y I/V
381  //-2 -41 -97 248 329 -37 117 -66 -70 28
382  //36 115 62 120 -132 -52 174 179 -7 114
383 
394  static double getNADH010107(char aa)
395  {
396  switch (aa)
397  {
398  case 'A':
399  return -2;
400 
401  case 'R':
402  return -41;
403 
404  case 'N':
405  return -97;
406 
407  case 'D':
408  return 248;
409 
410  case 'C':
411  return 329;
412 
413  case 'Q':
414  return -37;
415 
416  case 'E':
417  return 117;
418 
419  case 'G':
420  return -66;
421 
422  case 'H':
423  return -70;
424 
425  case 'I':
426  return 28;
427 
428  case 'L':
429  return 36;
430 
431  case 'K':
432  return 115;
433 
434  case 'M':
435  return 62;
436 
437  case 'F':
438  return 120;
439 
440  case 'P':
441  return -132;
442 
443  case 'S':
444  return -52;
445 
446  case 'T':
447  return 174;
448 
449  case 'W':
450  return 179;
451 
452  case 'Y':
453  return -7;
454 
455  case 'V':
456  return 114;
457 
458  default:
459  throw Exception::InvalidValue(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Unknown amino acid one-letter-code", String(aa));
460  }
461  }
462 
463  //WILM950101 0.838 MEEJ810102 0.809
464  //I A/L R/K N/M D/F C/P Q/S E/T G/W H/Y I/V
465  //2.62 1.26 -1.27 -2.84 0.73 -1.69 -0.45 -1.15 -0.74 4.38
466  //6.57 -2.78 -3.12 9.14 -0.12 -1.39 1.81 5.91 1.39 2.30
467 
479  static double getWILM950102(char aa)
480  {
481  switch (aa)
482  {
483  case 'A':
484  return 2.62;
485 
486  case 'R':
487  return 1.26;
488 
489  case 'N':
490  return -1.27;
491 
492  case 'D':
493  return -2.84;
494 
495  case 'C':
496  return 0.73;
497 
498  case 'Q':
499  return -1.69;
500 
501  case 'E':
502  return -0.45;
503 
504  case 'G':
505  return -1.15;
506 
507  case 'H':
508  return -0.74;
509 
510  case 'I':
511  return 4.38;
512 
513  case 'L':
514  return 6.57;
515 
516  case 'K':
517  return -2.78;
518 
519  case 'M':
520  return -3.12;
521 
522  case 'F':
523  return 9.14;
524 
525  case 'P':
526  return -0.12;
527 
528  case 'S':
529  return -1.39;
530 
531  case 'T':
532  return 1.81;
533 
534  case 'W':
535  return 5.91;
536 
537  case 'Y':
538  return 1.39;
539 
540  case 'V':
541  return 2.30;
542 
543  default:
544  throw Exception::InvalidValue(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Unknown amino acid one-letter-code", String(aa));
545  }
546  }
547 
548  //I A/L R/K N/M D/F C/P Q/S E/T G/W H/Y I/V
549  //0.0 1.1 -2.0 -2.6 5.4 2.4 3.1 -3.4 0.8 -0.1
550  //-3.7 -3.1 -2.1 0.7 7.4 1.3 0.0 -3.4 4.8 2.7
551 
562  static double getROBB760107(char aa)
563  {
564  switch (aa)
565  {
566  case 'A':
567  return 0.0;
568 
569  case 'R':
570  return 1.1;
571 
572  case 'N':
573  return -2.0;
574 
575  case 'D':
576  return -2.6;
577 
578  case 'C':
579  return 5.4;
580 
581  case 'Q':
582  return 2.4;
583 
584  case 'E':
585  return 3.1;
586 
587  case 'G':
588  return -3.4;
589 
590  case 'H':
591  return 0.8;
592 
593  case 'I':
594  return -0.1;
595 
596  case 'L':
597  return -3.7;
598 
599  case 'K':
600  return -3.1;
601 
602  case 'M':
603  return -2.1;
604 
605  case 'F':
606  return 0.7;
607 
608  case 'P':
609  return 7.4;
610 
611  case 'S':
612  return 1.3;
613 
614  case 'T':
615  return 0.0;
616 
617  case 'W':
618  return -3.4;
619 
620  case 'Y':
621  return 4.8;
622 
623  case 'V':
624  return 2.7;
625 
626  default:
627  throw Exception::InvalidValue(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Unknown amino acid one-letter-code", String(aa));
628  }
629  }
630 
631  //I A/L R/K N/M D/F C/P Q/S E/T G/W H/Y I/V
632  //-2.49 2.55 2.27 8.86 -3.13 1.79 4.04 -0.56 4.22 -10.87
633  //-7.16 -9.97 -4.96 -6.64 5.19 -1.60 -4.75 -17.84 9.25 -3.97
634 
646  static double getOOBM850104(char aa)
647  {
648  switch (aa)
649  {
650  case 'A':
651  return -2.49;
652 
653  case 'R':
654  return 2.55;
655 
656  case 'N':
657  return 2.27;
658 
659  case 'D':
660  return 8.86;
661 
662  case 'C':
663  return -3.13;
664 
665  case 'Q':
666  return 1.79;
667 
668  case 'E':
669  return 4.04;
670 
671  case 'G':
672  return -0.56;
673 
674  case 'H':
675  return 4.22;
676 
677  case 'I':
678  return -10.87;
679 
680  case 'L':
681  return -7.16;
682 
683  case 'K':
684  return -9.97;
685 
686  case 'M':
687  return -4.96;
688 
689  case 'F':
690  return -6.64;
691 
692  case 'P':
693  return 5.19;
694 
695  case 'S':
696  return -1.60;
697 
698  case 'T':
699  return -4.75;
700 
701  case 'W':
702  return -17.84;
703 
704  case 'Y':
705  return 9.25;
706 
707  case 'V':
708  return -3.97;
709 
710  default:
711  throw Exception::InvalidValue(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Unknown amino acid one-letter-code", String(aa));
712  }
713  }
714 
715  //ZIMJ680104 0.813
716  //I A/L R/K N/M D/F C/P Q/S E/T G/W H/Y I/V
717  //0. 1. 0. 0. 0. 0. 0. 0. 1. 0.
718  //0. 1. 0. 0. 0. 0. 0. 0. 0. 0.
719 
731  static double getFAUJ880111(char aa)
732  {
733  switch (aa)
734  {
735  case 'A':
736  return 0.;
737 
738  case 'R':
739  return 1.;
740 
741  case 'N':
742  return 0.;
743 
744  case 'D':
745  return 0.;
746 
747  case 'C':
748  return 0.;
749 
750  case 'Q':
751  return 0.;
752 
753  case 'E':
754  return 0.;
755 
756  case 'G':
757  return 0.;
758 
759  case 'H':
760  return 1.;
761 
762  case 'I':
763  return 0.;
764 
765  case 'L':
766  return 0.;
767 
768  case 'K':
769  return 1.;
770 
771  case 'M':
772  return 0.;
773 
774  case 'F':
775  return 0.;
776 
777  case 'P':
778  return 0.;
779 
780  case 'S':
781  return 0.;
782 
783  case 'T':
784  return 0.;
785 
786  case 'W':
787  return 0.;
788 
789  case 'Y':
790  return 0.;
791 
792  case 'V':
793  return 0.;
794 
795  default:
796  throw Exception::InvalidValue(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Unknown amino acid one-letter-code", String(aa));
797  }
798  }
799 
800  //SUEM840101 0.883 AURR980114 0.875 AURR980113 0.849<br>
801  //PTIO830101 0.826 KANM800103 0.823 QIAN880107 0.814<br>
802  //QIAN880106 0.810 MAXF760101 0.810 AURR980109 0.802
803  //I A/L R/K N/M D/F C/P Q/S E/T G/W H/Y I/V
804  //1.08 1.05 0.85 0.85 0.95 0.95 1.15 0.55 1.00 1.05
805  //1.25 1.15 1.15 1.10 0.71 0.75 0.75 1.10 1.10 0.95
806 
818  static double getFINA770101(char aa)
819  {
820  switch (aa)
821  {
822  case 'A':
823  return 1.08;
824 
825  case 'R':
826  return 1.05;
827 
828  case 'N':
829  return 0.85;
830 
831  case 'D':
832  return 0.85;
833 
834  case 'C':
835  return 0.95;
836 
837  case 'Q':
838  return 0.95;
839 
840  case 'E':
841  return 1.15;
842 
843  case 'G':
844  return 0.55;
845 
846  case 'H':
847  return 1.00;
848 
849  case 'I':
850  return 1.05;
851 
852  case 'L':
853  return 1.25;
854 
855  case 'K':
856  return 1.15;
857 
858  case 'M':
859  return 1.15;
860 
861  case 'F':
862  return 1.10;
863 
864  case 'P':
865  return 0.71;
866 
867  case 'S':
868  return 0.75;
869 
870  case 'T':
871  return 0.75;
872 
873  case 'W':
874  return 1.10;
875 
876  case 'Y':
877  return 1.10;
878 
879  case 'V':
880  return 0.95;
881 
882  default:
883  throw Exception::InvalidValue(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Unknown amino acid one-letter-code", String(aa));
884  }
885  }
886 
887  //ARGP820103 0.961 KYTJ820101 0.803 JURD980101 0.802
888  //I A/L R/K N/M D/F C/P Q/S E/T G/W H/Y I/V
889  //1.18 0.20 0.23 0.05 1.89 0.72 0.11 0.49 0.31 1.45
890  //3.23 0.06 2.67 1.96 0.76 0.97 0.84 0.77 0.39 1.08
891 
902  static double getARGP820102(char aa)
903  {
904  switch (aa)
905  {
906  case 'A':
907  return 1.18;
908 
909  case 'R':
910  return 0.20;
911 
912  case 'N':
913  return 0.23;
914 
915  case 'D':
916  return 0.05;
917 
918  case 'C':
919  return 1.89;
920 
921  case 'Q':
922  return 0.72;
923 
924  case 'E':
925  return 0.11;
926 
927  case 'G':
928  return 0.49;
929 
930  case 'H':
931  return 0.31;
932 
933  case 'I':
934  return 1.45;
935 
936  case 'L':
937  return 3.23;
938 
939  case 'K':
940  return 0.06;
941 
942  case 'M':
943  return 2.67;
944 
945  case 'F':
946  return 1.96;
947 
948  case 'P':
949  return 0.76;
950 
951  case 'S':
952  return 0.97;
953 
954  case 'T':
955  return 0.84;
956 
957  case 'W':
958  return 0.77;
959 
960  case 'Y':
961  return 0.39;
962 
963  case 'V':
964  return 1.08;
965 
966  default:
967  throw Exception::InvalidValue(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Unknown amino acid one-letter-code", String(aa));
968  }
969  }
970 
981  static double calculateGB(const AASequence& seq, double T = 500.0)
982  {
983 
984  double R = Constants::GAS_CONSTANT / 1000.0; // ideal gas constant in kj/(K*mol)
985 
986  char left = '>';
987  char right;
988 
989  double k_app = 0.0; // apparent proton association constant
990 
991  // energy level E at each protonation site i is -GB(i)
992  // fractional proton population of a microstate k is
993  // P_k = exp (- E_k/(RT)) / ( sum_i exp (- E_i/(RT)))
994  // the apparent proton association constant k_app:
995  // k_app = sum_i GB(i)/(RT)
996  // then the apparent GB is GB_app^ion = R * T * ln(k_app)
997  for (Size i = 0; i <= seq.size(); i++)
998  {
999  // aa left to current one
1000  if (i > 0)
1001  {
1002  Residue leftchar = seq[i - 1];
1003  left = leftchar.getOneLetterCode()[0];
1004  }
1005 
1006  // aa right to current one
1007  if (i == seq.size())
1008  {
1009  right = '<';
1010  }
1011  else
1012  {
1013  Residue rightchar = seq[i];
1014  right = rightchar.getOneLetterCode()[0];
1015  }
1016  double contrib = exp((GBleft_(left) + GBdeltaright_(right)) / (R * T));
1017  if (i > 0 && i < seq.size())
1018  {
1019  contrib += exp(GBsidechain_(right) / (R * T));
1020  }
1021  k_app += contrib;
1022  }
1023  // calculate apparent GB
1024  return R * T * log(k_app) / log(2.0);
1025  }
1026 
1027 protected:
1028 
1036  static double GBsidechain_(char aa)
1037  {
1038  switch (aa)
1039  {
1040  case 'A':
1041  return 0.0;
1042 
1043  case 'C':
1044  return 0.0;
1045 
1046  case 'D':
1047  return 784.0;
1048 
1049  case 'E':
1050  return 790.0;
1051 
1052  case 'F':
1053  return 0.0;
1054 
1055  case 'G':
1056  return 0.0;
1057 
1058  case 'H':
1059  return 927.84;
1060 
1061  case 'I':
1062  return 0.0;
1063 
1064  case 'K':
1065  return 926.74;
1066 
1067  case 'L':
1068  return 0.0;
1069 
1070  case 'M':
1071  return 830.0;
1072 
1073  case 'N':
1074  return 864.94;
1075 
1076  case 'P':
1077  return 0.0;
1078 
1079  case 'Q':
1080  return 865.25;
1081 
1082  case 'R':
1083  return 1000.0;
1084 
1085  case 'S':
1086  return 775.0;
1087 
1088  case 'T':
1089  return 780.0;
1090 
1091  case 'V':
1092  return 0.0;
1093 
1094  case 'W':
1095  return 909.53;
1096 
1097  case 'Y':
1098  return 790.0;
1099 
1100  default:
1101  throw Exception::InvalidValue(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Unknown amino acid one-letter-code", String(aa));
1102  }
1103  }
1104 
1112  static double GBleft_(char aa)
1113  {
1114  switch (aa)
1115  {
1116  case 'A':
1117  return 881.82;
1118 
1119  case 'C':
1120  return 881.15;
1121 
1122  case 'D':
1123  return 880.02;
1124 
1125  case 'E':
1126  return 880.10;
1127 
1128  case 'F':
1129  return 881.08;
1130 
1131  case 'G':
1132  return 881.17;
1133 
1134  case 'H':
1135  return 881.27;
1136 
1137  case 'I':
1138  return 880.99;
1139 
1140  case 'K':
1141  return 880.06;
1142 
1143  case 'L':
1144  return 881.88;
1145 
1146  case 'M':
1147  return 881.38;
1148 
1149  case 'N':
1150  return 881.18;
1151 
1152  case 'P':
1153  return 881.25;
1154 
1155  case 'Q':
1156  return 881.50;
1157 
1158  case 'R':
1159  return 882.98;
1160 
1161  case 'S':
1162  return 881.08;
1163 
1164  case 'T':
1165  return 881.14;
1166 
1167  case 'V':
1168  return 881.17;
1169 
1170  case 'W':
1171  return 881.31;
1172 
1173  case 'Y':
1174  return 881.20;
1175 
1176  case '>': //NH2
1177  return 916.84;
1178 
1179  default:
1180  throw Exception::InvalidValue(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Unknown amino acid one-letter-code", String(aa));
1181 
1182  }
1183  }
1184 
1192  static double GBdeltaright_(char aa)
1193  {
1194  switch (aa)
1195  {
1196  case 'A':
1197  return 0.0;
1198 
1199  case 'C':
1200  return -0.69;
1201 
1202  case 'D':
1203  return -0.63;
1204 
1205  case 'E':
1206  return -0.39;
1207 
1208  case 'F':
1209  return 0.03;
1210 
1211  case 'G':
1212  return 0.92;
1213 
1214  case 'H':
1215  return -0.19;
1216 
1217  case 'I':
1218  return -1.17;
1219 
1220  case 'K':
1221  return -0.71;
1222 
1223  case 'L':
1224  return -0.09;
1225 
1226  case 'M':
1227  return 0.30;
1228 
1229  case 'N':
1230  return 1.56;
1231 
1232  case 'P':
1233  return 11.75;
1234 
1235  case 'Q':
1236  return 4.10;
1237 
1238  case 'R':
1239  return 6.28;
1240 
1241  case 'S':
1242  return 0.98;
1243 
1244  case 'T':
1245  return 1.21;
1246 
1247  case 'V':
1248  return -0.90;
1249 
1250  case 'W':
1251  return 0.10;
1252 
1253  case 'Y':
1254  return -0.38;
1255 
1256  case '<': //COOH
1257  return -95.82;
1258 
1259  default:
1260  throw Exception::InvalidValue(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Unknown amino acid one-letter-code", String(aa));
1261  }
1262  }
1263 
1264 private:
1265 
1267  AAIndex();
1268  };
1269 
1270 }
1271 #endif
OpenMS::AAIndex::GBleft_
static double GBleft_(char aa)
Calculates part of the gas-phase basicity.
Definition: AAIndex.h:1112
OpenMS::String
A more convenient string class.
Definition: String.h:57
OpenMS::AAIndex::getFINA770101
static double getFINA770101(char aa)
Helix-coil equilibrium constant (Finkelstein-Ptitsyn, 1977)
Definition: AAIndex.h:818
OpenMS::AAIndex::getVASM830103
static double getVASM830103(char aa)
Relative population of conformational state E (Vasquez et al., 1983)
Definition: AAIndex.h:223
OpenMS::AAIndex::getWILM950102
static double getWILM950102(char aa)
Hydrophobicity coefficient in RP-HPLC, C8 with 0.1TFA/MeCN/H2O (Wilce et al. 1995) ...
Definition: AAIndex.h:479
OpenMS::AAIndex::polar
static double polar(char aa)
Returns if the residue is polar (1.0 or 0.0)
Definition: AAIndex.h:114
OpenMS::AAIndex::getROBB760107
static double getROBB760107(char aa)
Information measure for extended without H-bond (Robson-Suzuki, 1976)
Definition: AAIndex.h:562
OpenMS::AASequence
Representation of a peptide/protein sequence.
Definition: AASequence.h:108
OpenMS
Main OpenMS namespace.
Definition: FeatureDeconvolution.h:47
OpenMS::Constants::R
const double R
OpenMS::AAIndex::calculateGB
static double calculateGB(const AASequence &seq, double T=500.0)
Calculates an estimated gas-phase basicity for an amino acid sequence at a given temperature.
Definition: AAIndex.h:981
OpenMS::Residue
Representation of a residue.
Definition: Residue.h:62
OpenMS::AAIndex::GBsidechain_
static double GBsidechain_(char aa)
Calculates part of the gas-phase basicity.
Definition: AAIndex.h:1036
OpenMS::AAIndex::getNADH010106
static double getNADH010106(char aa)
Hydropathy scale based on self-information values in the two-state model (36% accessibility) (Naderi-...
Definition: AAIndex.h:310
OpenMS::AAIndex::basic
static double basic(char aa)
Returns if the residue is basic (1.0 or 0.0)
Definition: AAIndex.h:101
OpenMS::AAIndex::getFAUJ880111
static double getFAUJ880111(char aa)
Positive charge (Fauchere et al., 1988)
Definition: AAIndex.h:731
OpenMS::AAIndex::GBdeltaright_
static double GBdeltaright_(char aa)
Calculates part of the gas-phase basicity.
Definition: AAIndex.h:1192
OpenMS::Residue::getOneLetterCode
const String & getOneLetterCode() const
returns the name as one letter code (String of size 1)
OpenMS::AAIndex::aliphatic
static double aliphatic(char aa)
Returns if the residue is aliphatic (1.0 or 0.0)
Definition: AAIndex.h:75
OpenMS::AAIndex::getNADH010107
static double getNADH010107(char aa)
Hydropathy scale based on self-information values in the two-state model (50% accessibility) (Naderi-...
Definition: AAIndex.h:394
OpenMS::AAIndex::acidic
static double acidic(char aa)
Returns if the residue is acidic (1.0 or 0.0)
Definition: AAIndex.h:88
OpenMS::AAIndex::getOOBM850104
static double getOOBM850104(char aa)
Optimized average non-bonded energy per atom (Oobatake et al., 1985)
Definition: AAIndex.h:646
OpenMS::Exception::InvalidValue
Invalid value exception.
Definition: Exception.h:336
OpenMS::Size
size_t Size
Size type e.g. used as variable which can hold result of size()
Definition: Types.h:128
OpenMS::AAIndex::getKHAG800101
static double getKHAG800101(char aa)
The Kerr-constant increments (Khanarian-Moore, 1980)
Definition: AAIndex.h:139
OpenMS::AAIndex::getARGP820102
static double getARGP820102(char aa)
Signal sequence helical potential (Argos et al., 1982)
Definition: AAIndex.h:902
OpenMS::Constants::GAS_CONSTANT
const double GAS_CONSTANT
OpenMS::AASequence::size
Size size() const
returns the number of residues
OpenMS::AAIndex
Representation of selected AAIndex properties.
Definition: AAIndex.h:70
OpenMS / TOPP release 2.3.0 Documentation generated on Tue Jan 9 2018 18:21:59 using doxygen 1.8.13