OpenMS
AAIndex.h
Go to the documentation of this file.
1 // Copyright (c) 2002-2023, The OpenMS Team -- EKU Tuebingen, ETH Zurich, and FU Berlin
2 // SPDX-License-Identifier: BSD-3-Clause
3 //
4 // --------------------------------------------------------------------------
5 // $Maintainer: Timo Sachsenberg $
6 // $Authors: $
7 // --------------------------------------------------------------------------
8 
9 #pragma once
10 
11 #include <OpenMS/CONCEPT/Exception.h>
12 #include <OpenMS/CONCEPT/Constants.h>
13 
14 #include <cmath>
15 
16 namespace OpenMS
17 {
43  class OPENMS_DLLAPI AAIndex
44  {
45 public:
46 
48  static double aliphatic(char aa)
49  {
50  if (aa == 'A' || aa == 'G' || aa == 'F' || aa == 'I' || aa == 'M' || aa == 'L' || aa == 'P' || aa == 'V')
51  {
52  return 1.0;
53  }
54  else
55  {
56  return 0.0;
57  }
58  }
59 
61  static double acidic(char aa)
62  {
63  if (aa == 'D' || aa == 'E')
64  {
65  return 1.0;
66  }
67  else
68  {
69  return 0.0;
70  }
71  }
72 
74  static double basic(char aa)
75  {
76  if (aa == 'K' || aa == 'R' || aa == 'H' || aa == 'W')
77  {
78  return 1.0;
79  }
80  else
81  {
82  return 0.0;
83  }
84  }
85 
87  static double polar(char aa)
88  {
89  if (aa == 'S' || aa == 'T' || aa == 'Y' || aa == 'H' || aa == 'C' || aa == 'N' || aa == 'Q' || aa == 'W')
90  {
91  return 1.0;
92  }
93  else
94  {
95  return 0.0;
96  }
97  }
98 
99  //I A/L R/K N/M D/F C/P Q/S E/T G/W H/Y I/V
100  //49.1 133. -3.6 0. 0. 20. 0. 64.6 75.7 18.9
101  //15.6 0. 6.8 54.7 43.8 44.4 31.0 70.5 0. 29.5
112  static double getKHAG800101(char aa)
113  {
114  switch (aa)
115  {
116  case 'A':
117  return 49.1;
118 
119  case 'R':
120  return 133.;
121 
122  case 'N':
123  return -3.6;
124 
125  case 'D':
126  return 0.;
127 
128  case 'C':
129  return 0.;
130 
131  case 'Q':
132  return 20.;
133 
134  case 'E':
135  return 0.;
136 
137  case 'G':
138  return 64.6;
139 
140  case 'H':
141  return 75.7;
142 
143  case 'I':
144  return 18.9;
145 
146  case 'L':
147  return 15.6;
148 
149  case 'K':
150  return 0.;
151 
152  case 'M':
153  return 6.8;
154 
155  case 'F':
156  return 54.7;
157 
158  case 'P':
159  return 43.8;
160 
161  case 'S':
162  return 44.4;
163 
164  case 'T':
165  return 31.0;
166 
167  case 'W':
168  return 70.5;
169 
170  case 'Y':
171  return 0.;
172 
173  case 'V':
174  return 29.5;
175 
176  default:
177  throw Exception::InvalidValue(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Unknown amino acid one-letter-code", String(aa));
178  }
179  }
180 
181  //I A/L R/K N/M D/F C/P Q/S E/T G/W H/Y I/V
182  //0.159 0.194 0.385 0.283 0.187 0.236 0.206 0.049 0.233 0.581
183  //0.083 0.159 0.198 0.682 0.366 0.150 0.074 0.463 0.737 0.301
184 
196  static double getVASM830103(char aa)
197  {
198  switch (aa)
199  {
200  case 'A':
201  return 0.159;
202 
203  case 'R':
204  return 0.194;
205 
206  case 'N':
207  return 0.385;
208 
209  case 'D':
210  return 0.283;
211 
212  case 'C':
213  return 0.187;
214 
215  case 'Q':
216  return 0.236;
217 
218  case 'E':
219  return 0.206;
220 
221  case 'G':
222  return 0.049;
223 
224  case 'H':
225  return 0.233;
226 
227  case 'I':
228  return 0.581;
229 
230  case 'L':
231  return 0.083;
232 
233  case 'K':
234  return 0.159;
235 
236  case 'M':
237  return 0.198;
238 
239  case 'F':
240  return 0.682;
241 
242  case 'P':
243  return 0.366;
244 
245  case 'S':
246  return 0.150;
247 
248  case 'T':
249  return 0.074;
250 
251  case 'W':
252  return 0.463;
253 
254  case 'Y':
255  return 0.737;
256 
257  case 'V':
258  return 0.301;
259 
260  default:
261  throw Exception::InvalidValue(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Unknown amino acid one-letter-code", String(aa));
262  }
263  }
264 
265  //NADH010105 0.958 NADH010104 0.914 NADH010103 0.881<br>
266  //ZHOH040103 0.819 NADH010107 0.811 BAEK050101 0.809<br>
267  //NADH010102 0.808 PONP800103 0.803 VINM940103 -0.813<br>
268  //KRIW710101 -0.846 KRIW790101 -0.861
269  //I A/L R/K N/M D/F C/P Q/S E/T G/W H/Y I/V
270  //5 -57 -77 45 224 -67 -8 -47 -50 83
271  //82 -38 83 117 -103 -41 79 130 27 117
272 
283  static double getNADH010106(char aa)
284  {
285  switch (aa)
286  {
287  case 'A':
288  return 5;
289 
290  case 'R':
291  return -57;
292 
293  case 'N':
294  return -77;
295 
296  case 'D':
297  return 45;
298 
299  case 'C':
300  return 224;
301 
302  case 'Q':
303  return -67;
304 
305  case 'E':
306  return -8;
307 
308  case 'G':
309  return -47;
310 
311  case 'H':
312  return -50;
313 
314  case 'I':
315  return 83;
316 
317  case 'L':
318  return 82;
319 
320  case 'K':
321  return -38;
322 
323  case 'M':
324  return 83;
325 
326  case 'F':
327  return 117;
328 
329  case 'P':
330  return -103;
331 
332  case 'S':
333  return -41;
334 
335  case 'T':
336  return 79;
337 
338  case 'W':
339  return 130;
340 
341  case 'Y':
342  return 27;
343 
344  case 'V':
345  return 117;
346 
347  default:
348  throw Exception::InvalidValue(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Unknown amino acid one-letter-code", String(aa));
349  }
350  }
351 
352  //NADH010106 0.811
353  //I A/L R/K N/M D/F C/P Q/S E/T G/W H/Y I/V
354  //-2 -41 -97 248 329 -37 117 -66 -70 28
355  //36 115 62 120 -132 -52 174 179 -7 114
356 
367  static double getNADH010107(char aa)
368  {
369  switch (aa)
370  {
371  case 'A':
372  return -2;
373 
374  case 'R':
375  return -41;
376 
377  case 'N':
378  return -97;
379 
380  case 'D':
381  return 248;
382 
383  case 'C':
384  return 329;
385 
386  case 'Q':
387  return -37;
388 
389  case 'E':
390  return 117;
391 
392  case 'G':
393  return -66;
394 
395  case 'H':
396  return -70;
397 
398  case 'I':
399  return 28;
400 
401  case 'L':
402  return 36;
403 
404  case 'K':
405  return 115;
406 
407  case 'M':
408  return 62;
409 
410  case 'F':
411  return 120;
412 
413  case 'P':
414  return -132;
415 
416  case 'S':
417  return -52;
418 
419  case 'T':
420  return 174;
421 
422  case 'W':
423  return 179;
424 
425  case 'Y':
426  return -7;
427 
428  case 'V':
429  return 114;
430 
431  default:
432  throw Exception::InvalidValue(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Unknown amino acid one-letter-code", String(aa));
433  }
434  }
435 
436  //WILM950101 0.838 MEEJ810102 0.809
437  //I A/L R/K N/M D/F C/P Q/S E/T G/W H/Y I/V
438  //2.62 1.26 -1.27 -2.84 0.73 -1.69 -0.45 -1.15 -0.74 4.38
439  //6.57 -2.78 -3.12 9.14 -0.12 -1.39 1.81 5.91 1.39 2.30
440 
452  static double getWILM950102(char aa)
453  {
454  switch (aa)
455  {
456  case 'A':
457  return 2.62;
458 
459  case 'R':
460  return 1.26;
461 
462  case 'N':
463  return -1.27;
464 
465  case 'D':
466  return -2.84;
467 
468  case 'C':
469  return 0.73;
470 
471  case 'Q':
472  return -1.69;
473 
474  case 'E':
475  return -0.45;
476 
477  case 'G':
478  return -1.15;
479 
480  case 'H':
481  return -0.74;
482 
483  case 'I':
484  return 4.38;
485 
486  case 'L':
487  return 6.57;
488 
489  case 'K':
490  return -2.78;
491 
492  case 'M':
493  return -3.12;
494 
495  case 'F':
496  return 9.14;
497 
498  case 'P':
499  return -0.12;
500 
501  case 'S':
502  return -1.39;
503 
504  case 'T':
505  return 1.81;
506 
507  case 'W':
508  return 5.91;
509 
510  case 'Y':
511  return 1.39;
512 
513  case 'V':
514  return 2.30;
515 
516  default:
517  throw Exception::InvalidValue(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Unknown amino acid one-letter-code", String(aa));
518  }
519  }
520 
521  //I A/L R/K N/M D/F C/P Q/S E/T G/W H/Y I/V
522  //0.0 1.1 -2.0 -2.6 5.4 2.4 3.1 -3.4 0.8 -0.1
523  //-3.7 -3.1 -2.1 0.7 7.4 1.3 0.0 -3.4 4.8 2.7
524 
535  static double getROBB760107(char aa)
536  {
537  switch (aa)
538  {
539  case 'A':
540  return 0.0;
541 
542  case 'R':
543  return 1.1;
544 
545  case 'N':
546  return -2.0;
547 
548  case 'D':
549  return -2.6;
550 
551  case 'C':
552  return 5.4;
553 
554  case 'Q':
555  return 2.4;
556 
557  case 'E':
558  return 3.1;
559 
560  case 'G':
561  return -3.4;
562 
563  case 'H':
564  return 0.8;
565 
566  case 'I':
567  return -0.1;
568 
569  case 'L':
570  return -3.7;
571 
572  case 'K':
573  return -3.1;
574 
575  case 'M':
576  return -2.1;
577 
578  case 'F':
579  return 0.7;
580 
581  case 'P':
582  return 7.4;
583 
584  case 'S':
585  return 1.3;
586 
587  case 'T':
588  return 0.0;
589 
590  case 'W':
591  return -3.4;
592 
593  case 'Y':
594  return 4.8;
595 
596  case 'V':
597  return 2.7;
598 
599  default:
600  throw Exception::InvalidValue(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Unknown amino acid one-letter-code", String(aa));
601  }
602  }
603 
604  //I A/L R/K N/M D/F C/P Q/S E/T G/W H/Y I/V
605  //-2.49 2.55 2.27 8.86 -3.13 1.79 4.04 -0.56 4.22 -10.87
606  //-7.16 -9.97 -4.96 -6.64 5.19 -1.60 -4.75 -17.84 9.25 -3.97
607 
619  static double getOOBM850104(char aa)
620  {
621  switch (aa)
622  {
623  case 'A':
624  return -2.49;
625 
626  case 'R':
627  return 2.55;
628 
629  case 'N':
630  return 2.27;
631 
632  case 'D':
633  return 8.86;
634 
635  case 'C':
636  return -3.13;
637 
638  case 'Q':
639  return 1.79;
640 
641  case 'E':
642  return 4.04;
643 
644  case 'G':
645  return -0.56;
646 
647  case 'H':
648  return 4.22;
649 
650  case 'I':
651  return -10.87;
652 
653  case 'L':
654  return -7.16;
655 
656  case 'K':
657  return -9.97;
658 
659  case 'M':
660  return -4.96;
661 
662  case 'F':
663  return -6.64;
664 
665  case 'P':
666  return 5.19;
667 
668  case 'S':
669  return -1.60;
670 
671  case 'T':
672  return -4.75;
673 
674  case 'W':
675  return -17.84;
676 
677  case 'Y':
678  return 9.25;
679 
680  case 'V':
681  return -3.97;
682 
683  default:
684  throw Exception::InvalidValue(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Unknown amino acid one-letter-code", String(aa));
685  }
686  }
687 
688  //ZIMJ680104 0.813
689  //I A/L R/K N/M D/F C/P Q/S E/T G/W H/Y I/V
690  //0. 1. 0. 0. 0. 0. 0. 0. 1. 0.
691  //0. 1. 0. 0. 0. 0. 0. 0. 0. 0.
692 
704  static double getFAUJ880111(char aa)
705  {
706  switch (aa)
707  {
708  case 'A':
709  return 0.;
710 
711  case 'R':
712  return 1.;
713 
714  case 'N':
715  return 0.;
716 
717  case 'D':
718  return 0.;
719 
720  case 'C':
721  return 0.;
722 
723  case 'Q':
724  return 0.;
725 
726  case 'E':
727  return 0.;
728 
729  case 'G':
730  return 0.;
731 
732  case 'H':
733  return 1.;
734 
735  case 'I':
736  return 0.;
737 
738  case 'L':
739  return 0.;
740 
741  case 'K':
742  return 1.;
743 
744  case 'M':
745  return 0.;
746 
747  case 'F':
748  return 0.;
749 
750  case 'P':
751  return 0.;
752 
753  case 'S':
754  return 0.;
755 
756  case 'T':
757  return 0.;
758 
759  case 'W':
760  return 0.;
761 
762  case 'Y':
763  return 0.;
764 
765  case 'V':
766  return 0.;
767 
768  default:
769  throw Exception::InvalidValue(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Unknown amino acid one-letter-code", String(aa));
770  }
771  }
772 
773  //SUEM840101 0.883 AURR980114 0.875 AURR980113 0.849<br>
774  //PTIO830101 0.826 KANM800103 0.823 QIAN880107 0.814<br>
775  //QIAN880106 0.810 MAXF760101 0.810 AURR980109 0.802
776  //I A/L R/K N/M D/F C/P Q/S E/T G/W H/Y I/V
777  //1.08 1.05 0.85 0.85 0.95 0.95 1.15 0.55 1.00 1.05
778  //1.25 1.15 1.15 1.10 0.71 0.75 0.75 1.10 1.10 0.95
779 
791  static double getFINA770101(char aa)
792  {
793  switch (aa)
794  {
795  case 'A':
796  return 1.08;
797 
798  case 'R':
799  return 1.05;
800 
801  case 'N':
802  return 0.85;
803 
804  case 'D':
805  return 0.85;
806 
807  case 'C':
808  return 0.95;
809 
810  case 'Q':
811  return 0.95;
812 
813  case 'E':
814  return 1.15;
815 
816  case 'G':
817  return 0.55;
818 
819  case 'H':
820  return 1.00;
821 
822  case 'I':
823  return 1.05;
824 
825  case 'L':
826  return 1.25;
827 
828  case 'K':
829  return 1.15;
830 
831  case 'M':
832  return 1.15;
833 
834  case 'F':
835  return 1.10;
836 
837  case 'P':
838  return 0.71;
839 
840  case 'S':
841  return 0.75;
842 
843  case 'T':
844  return 0.75;
845 
846  case 'W':
847  return 1.10;
848 
849  case 'Y':
850  return 1.10;
851 
852  case 'V':
853  return 0.95;
854 
855  default:
856  throw Exception::InvalidValue(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Unknown amino acid one-letter-code", String(aa));
857  }
858  }
859 
860  //ARGP820103 0.961 KYTJ820101 0.803 JURD980101 0.802
861  //I A/L R/K N/M D/F C/P Q/S E/T G/W H/Y I/V
862  //1.18 0.20 0.23 0.05 1.89 0.72 0.11 0.49 0.31 1.45
863  //3.23 0.06 2.67 1.96 0.76 0.97 0.84 0.77 0.39 1.08
864 
875  static double getARGP820102(char aa)
876  {
877  switch (aa)
878  {
879  case 'A':
880  return 1.18;
881 
882  case 'R':
883  return 0.20;
884 
885  case 'N':
886  return 0.23;
887 
888  case 'D':
889  return 0.05;
890 
891  case 'C':
892  return 1.89;
893 
894  case 'Q':
895  return 0.72;
896 
897  case 'E':
898  return 0.11;
899 
900  case 'G':
901  return 0.49;
902 
903  case 'H':
904  return 0.31;
905 
906  case 'I':
907  return 1.45;
908 
909  case 'L':
910  return 3.23;
911 
912  case 'K':
913  return 0.06;
914 
915  case 'M':
916  return 2.67;
917 
918  case 'F':
919  return 1.96;
920 
921  case 'P':
922  return 0.76;
923 
924  case 'S':
925  return 0.97;
926 
927  case 'T':
928  return 0.84;
929 
930  case 'W':
931  return 0.77;
932 
933  case 'Y':
934  return 0.39;
935 
936  case 'V':
937  return 1.08;
938 
939  default:
940  throw Exception::InvalidValue(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Unknown amino acid one-letter-code", String(aa));
941  }
942  }
943 
954  static double calculateGB(const AASequence& seq, double T = 500.0)
955  {
956 
957  double R = Constants::GAS_CONSTANT / 1000.0; // ideal gas constant in kj/(K*mol)
958 
959  char left = '>';
960  char right;
961 
962  double k_app = 0.0; // apparent proton association constant
963 
964  // energy level E at each protonation site i is -GB(i)
965  // fractional proton population of a microstate k is
966  // P_k = exp (- E_k/(RT)) / ( sum_i exp (- E_i/(RT)))
967  // the apparent proton association constant k_app:
968  // k_app = sum_i GB(i)/(RT)
969  // then the apparent GB is GB_app^ion = R * T * ln(k_app)
970  for (Size i = 0; i <= seq.size(); i++)
971  {
972  // aa left to current one
973  if (i > 0)
974  {
975  Residue leftchar = seq[i - 1];
976  left = leftchar.getOneLetterCode()[0];
977  }
978 
979  // aa right to current one
980  if (i == seq.size())
981  {
982  right = '<';
983  }
984  else
985  {
986  Residue rightchar = seq[i];
987  right = rightchar.getOneLetterCode()[0];
988  }
989  double contrib = exp((GBleft_(left) + GBdeltaright_(right)) / (R * T));
990  if (i > 0 && i < seq.size())
991  {
992  contrib += exp(GBsidechain_(right) / (R * T));
993  }
994  k_app += contrib;
995  }
996  // calculate apparent GB
997  return R * T * log(k_app) / log(2.0);
998  }
999 
1000 protected:
1001 
1009  static double GBsidechain_(char aa)
1010  {
1011  switch (aa)
1012  {
1013  case 'A':
1014  return 0.0;
1015 
1016  case 'C':
1017  return 0.0;
1018 
1019  case 'D':
1020  return 784.0;
1021 
1022  case 'E':
1023  return 790.0;
1024 
1025  case 'F':
1026  return 0.0;
1027 
1028  case 'G':
1029  return 0.0;
1030 
1031  case 'H':
1032  return 927.84;
1033 
1034  case 'I':
1035  return 0.0;
1036 
1037  case 'K':
1038  return 926.74;
1039 
1040  case 'L':
1041  return 0.0;
1042 
1043  case 'M':
1044  return 830.0;
1045 
1046  case 'N':
1047  return 864.94;
1048 
1049  case 'P':
1050  return 0.0;
1051 
1052  case 'Q':
1053  return 865.25;
1054 
1055  case 'R':
1056  return 1000.0;
1057 
1058  case 'S':
1059  return 775.0;
1060 
1061  case 'T':
1062  return 780.0;
1063 
1064  case 'V':
1065  return 0.0;
1066 
1067  case 'W':
1068  return 909.53;
1069 
1070  case 'Y':
1071  return 790.0;
1072 
1073  default:
1074  throw Exception::InvalidValue(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Unknown amino acid one-letter-code", String(aa));
1075  }
1076  }
1077 
1085  static double GBleft_(char aa)
1086  {
1087  switch (aa)
1088  {
1089  case 'A':
1090  return 881.82;
1091 
1092  case 'C':
1093  return 881.15;
1094 
1095  case 'D':
1096  return 880.02;
1097 
1098  case 'E':
1099  return 880.10;
1100 
1101  case 'F':
1102  return 881.08;
1103 
1104  case 'G':
1105  return 881.17;
1106 
1107  case 'H':
1108  return 881.27;
1109 
1110  case 'I':
1111  return 880.99;
1112 
1113  case 'K':
1114  return 880.06;
1115 
1116  case 'L':
1117  return 881.88;
1118 
1119  case 'M':
1120  return 881.38;
1121 
1122  case 'N':
1123  return 881.18;
1124 
1125  case 'P':
1126  return 881.25;
1127 
1128  case 'Q':
1129  return 881.50;
1130 
1131  case 'R':
1132  return 882.98;
1133 
1134  case 'S':
1135  return 881.08;
1136 
1137  case 'T':
1138  return 881.14;
1139 
1140  case 'V':
1141  return 881.17;
1142 
1143  case 'W':
1144  return 881.31;
1145 
1146  case 'Y':
1147  return 881.20;
1148 
1149  case '>': //NH2
1150  return 916.84;
1151 
1152  default:
1153  throw Exception::InvalidValue(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Unknown amino acid one-letter-code", String(aa));
1154 
1155  }
1156  }
1157 
1165  static double GBdeltaright_(char aa)
1166  {
1167  switch (aa)
1168  {
1169  case 'A':
1170  return 0.0;
1171 
1172  case 'C':
1173  return -0.69;
1174 
1175  case 'D':
1176  return -0.63;
1177 
1178  case 'E':
1179  return -0.39;
1180 
1181  case 'F':
1182  return 0.03;
1183 
1184  case 'G':
1185  return 0.92;
1186 
1187  case 'H':
1188  return -0.19;
1189 
1190  case 'I':
1191  return -1.17;
1192 
1193  case 'K':
1194  return -0.71;
1195 
1196  case 'L':
1197  return -0.09;
1198 
1199  case 'M':
1200  return 0.30;
1201 
1202  case 'N':
1203  return 1.56;
1204 
1205  case 'P':
1206  return 11.75;
1207 
1208  case 'Q':
1209  return 4.10;
1210 
1211  case 'R':
1212  return 6.28;
1213 
1214  case 'S':
1215  return 0.98;
1216 
1217  case 'T':
1218  return 1.21;
1219 
1220  case 'V':
1221  return -0.90;
1222 
1223  case 'W':
1224  return 0.10;
1225 
1226  case 'Y':
1227  return -0.38;
1228 
1229  case '<': //COOH
1230  return -95.82;
1231 
1232  default:
1233  throw Exception::InvalidValue(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, "Unknown amino acid one-letter-code", String(aa));
1234  }
1235  }
1236 
1237 private:
1238 
1240  AAIndex();
1241  };
1242 
1243 }
OpenMS::AAIndex
Representation of selected AAIndex properties.
Definition: AAIndex.h:44
OpenMS::AAIndex::polar
static double polar(char aa)
Returns if the residue is polar (1.0 or 0.0)
Definition: AAIndex.h:87
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:452
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:954
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:283
OpenMS::AAIndex::aliphatic
static double aliphatic(char aa)
Returns if the residue is aliphatic (1.0 or 0.0)
Definition: AAIndex.h:48
OpenMS::AAIndex::acidic
static double acidic(char aa)
Returns if the residue is acidic (1.0 or 0.0)
Definition: AAIndex.h:61
OpenMS::AAIndex::getKHAG800101
static double getKHAG800101(char aa)
The Kerr-constant increments (Khanarian-Moore, 1980)
Definition: AAIndex.h:112
OpenMS::AAIndex::getOOBM850104
static double getOOBM850104(char aa)
Optimized average non-bonded energy per atom (Oobatake et al., 1985)
Definition: AAIndex.h:619
OpenMS::AAIndex::getROBB760107
static double getROBB760107(char aa)
Information measure for extended without H-bond (Robson-Suzuki, 1976)
Definition: AAIndex.h:535
OpenMS::AAIndex::basic
static double basic(char aa)
Returns if the residue is basic (1.0 or 0.0)
Definition: AAIndex.h:74
OpenMS::AAIndex::GBleft_
static double GBleft_(char aa)
Calculates part of the gas-phase basicity.
Definition: AAIndex.h:1085
OpenMS::AAIndex::getFINA770101
static double getFINA770101(char aa)
Helix-coil equilibrium constant (Finkelstein-Ptitsyn, 1977)
Definition: AAIndex.h:791
OpenMS::AAIndex::GBsidechain_
static double GBsidechain_(char aa)
Calculates part of the gas-phase basicity.
Definition: AAIndex.h:1009
OpenMS::AAIndex::AAIndex
AAIndex()
Constructor not implemented => private.
OpenMS::AAIndex::getVASM830103
static double getVASM830103(char aa)
Relative population of conformational state E (Vasquez et al., 1983)
Definition: AAIndex.h:196
OpenMS::AAIndex::getFAUJ880111
static double getFAUJ880111(char aa)
Positive charge (Fauchere et al., 1988)
Definition: AAIndex.h:704
OpenMS::AAIndex::getARGP820102
static double getARGP820102(char aa)
Signal sequence helical potential (Argos et al., 1982)
Definition: AAIndex.h:875
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:367
OpenMS::AAIndex::GBdeltaright_
static double GBdeltaright_(char aa)
Calculates part of the gas-phase basicity.
Definition: AAIndex.h:1165
OpenMS::AASequence
Representation of a peptide/protein sequence.
Definition: AASequence.h:86
OpenMS::AASequence::size
Size size() const
returns the number of residues
OpenMS::Exception::InvalidValue
Invalid value exception.
Definition: Exception.h:303
OpenMS::Residue
Representation of an amino acid residue.
Definition: Residue.h:37
OpenMS::Residue::getOneLetterCode
const String & getOneLetterCode() const
returns the name as one letter code (String of size 1)
OpenMS::String
A more convenient string class.
Definition: String.h:34
OpenMS::Size
size_t Size
Size type e.g. used as variable which can hold result of size()
Definition: Types.h:101
OpenMS::Constants::R
const double R
Definition: Constants.h:149
OpenMS::Constants::GAS_CONSTANT
const double GAS_CONSTANT
Definition: Constants.h:145
OpenMS
Main OpenMS namespace.
Definition: FeatureDeconvolution.h:22