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