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-2013.
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: Alexandra Scherbart $
32 // $Authors: $
33 // --------------------------------------------------------------------------
34 
35 #ifndef OPENMS_CHEMISTRY_AAINDEX_H
36 #define OPENMS_CHEMISTRY_AAINDEX_H
37 
40 
41 #include <cmath>
42 
43 namespace OpenMS
44 {
70  class OPENMS_DLLAPI AAIndex
71  {
72 public:
73 
75  static DoubleReal 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 DoubleReal 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 DoubleReal 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 DoubleReal 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 DoubleReal getKHAG800101(char aa)
140  {
141  switch (aa)
142  {
143  case 'A':
144  return 49.1;
145 
146  break;
147 
148  case 'R':
149  return 133.;
150 
151  break;
152 
153  case 'N':
154  return -3.6;
155 
156  break;
157 
158  case 'D':
159  return 0.;
160 
161  break;
162 
163  case 'C':
164  return 0.;
165 
166  break;
167 
168  case 'Q':
169  return 20.;
170 
171  break;
172 
173  case 'E':
174  return 0.;
175 
176  break;
177 
178  case 'G':
179  return 64.6;
180 
181  break;
182 
183  case 'H':
184  return 75.7;
185 
186  break;
187 
188  case 'I':
189  return 18.9;
190 
191  break;
192 
193  case 'L':
194  return 15.6;
195 
196  break;
197 
198  case 'K':
199  return 0.;
200 
201  break;
202 
203  case 'M':
204  return 6.8;
205 
206  break;
207 
208  case 'F':
209  return 54.7;
210 
211  break;
212 
213  case 'P':
214  return 43.8;
215 
216  break;
217 
218  case 'S':
219  return 44.4;
220 
221  break;
222 
223  case 'T':
224  return 31.0;
225 
226  break;
227 
228  case 'W':
229  return 70.5;
230 
231  break;
232 
233  case 'Y':
234  return 0.;
235 
236  break;
237 
238  case 'V':
239  return 29.5;
240 
241  break;
242 
243  default:
244  throw Exception::InvalidValue(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Unknown amino acid one-letter-code", String(aa));
245  }
246  }
247 
248  //I A/L R/K N/M D/F C/P Q/S E/T G/W H/Y I/V
249  //0.159 0.194 0.385 0.283 0.187 0.236 0.206 0.049 0.233 0.581
250  //0.083 0.159 0.198 0.682 0.366 0.150 0.074 0.463 0.737 0.301
251 
263  static DoubleReal getVASM830103(char aa)
264  {
265  switch (aa)
266  {
267  case 'A':
268  return 0.159;
269 
270  break;
271 
272  case 'R':
273  return 0.194;
274 
275  break;
276 
277  case 'N':
278  return 0.385;
279 
280  break;
281 
282  case 'D':
283  return 0.283;
284 
285  break;
286 
287  case 'C':
288  return 0.187;
289 
290  break;
291 
292  case 'Q':
293  return 0.236;
294 
295  break;
296 
297  case 'E':
298  return 0.206;
299 
300  break;
301 
302  case 'G':
303  return 0.049;
304 
305  break;
306 
307  case 'H':
308  return 0.233;
309 
310  break;
311 
312  case 'I':
313  return 0.581;
314 
315  break;
316 
317  case 'L':
318  return 0.083;
319 
320  break;
321 
322  case 'K':
323  return 0.159;
324 
325  break;
326 
327  case 'M':
328  return 0.198;
329 
330  break;
331 
332  case 'F':
333  return 0.682;
334 
335  break;
336 
337  case 'P':
338  return 0.366;
339 
340  break;
341 
342  case 'S':
343  return 0.150;
344 
345  break;
346 
347  case 'T':
348  return 0.074;
349 
350  break;
351 
352  case 'W':
353  return 0.463;
354 
355  break;
356 
357  case 'Y':
358  return 0.737;
359 
360  break;
361 
362  case 'V':
363  return 0.301;
364 
365  break;
366 
367  default:
368  throw Exception::InvalidValue(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Unknown amino acid one-letter-code", String(aa));
369  }
370  }
371 
372  //NADH010105 0.958 NADH010104 0.914 NADH010103 0.881<br>
373  //ZHOH040103 0.819 NADH010107 0.811 BAEK050101 0.809<br>
374  //NADH010102 0.808 PONP800103 0.803 VINM940103 -0.813<br>
375  //KRIW710101 -0.846 KRIW790101 -0.861
376  //I A/L R/K N/M D/F C/P Q/S E/T G/W H/Y I/V
377  //5 -57 -77 45 224 -67 -8 -47 -50 83
378  //82 -38 83 117 -103 -41 79 130 27 117
379 
390  static DoubleReal getNADH010106(char aa)
391  {
392  switch (aa)
393  {
394  case 'A':
395  return 5;
396 
397  break;
398 
399  case 'R':
400  return -57;
401 
402  break;
403 
404  case 'N':
405  return -77;
406 
407  break;
408 
409  case 'D':
410  return 45;
411 
412  break;
413 
414  case 'C':
415  return 224;
416 
417  break;
418 
419  case 'Q':
420  return -67;
421 
422  break;
423 
424  case 'E':
425  return -8;
426 
427  break;
428 
429  case 'G':
430  return -47;
431 
432  break;
433 
434  case 'H':
435  return -50;
436 
437  break;
438 
439  case 'I':
440  return 83;
441 
442  break;
443 
444  case 'L':
445  return 82;
446 
447  break;
448 
449  case 'K':
450  return -38;
451 
452  break;
453 
454  case 'M':
455  return 83;
456 
457  break;
458 
459  case 'F':
460  return 117;
461 
462  break;
463 
464  case 'P':
465  return -103;
466 
467  break;
468 
469  case 'S':
470  return -41;
471 
472  break;
473 
474  case 'T':
475  return 79;
476 
477  break;
478 
479  case 'W':
480  return 130;
481 
482  break;
483 
484  case 'Y':
485  return 27;
486 
487  break;
488 
489  case 'V':
490  return 117;
491 
492  break;
493 
494  default:
495  throw Exception::InvalidValue(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Unknown amino acid one-letter-code", String(aa));
496  }
497  }
498 
499  //NADH010106 0.811
500  //I A/L R/K N/M D/F C/P Q/S E/T G/W H/Y I/V
501  //-2 -41 -97 248 329 -37 117 -66 -70 28
502  //36 115 62 120 -132 -52 174 179 -7 114
503 
514  static DoubleReal getNADH010107(char aa)
515  {
516  switch (aa)
517  {
518  case 'A':
519  return -2;
520 
521  break;
522 
523  case 'R':
524  return -41;
525 
526  break;
527 
528  case 'N':
529  return -97;
530 
531  break;
532 
533  case 'D':
534  return 248;
535 
536  break;
537 
538  case 'C':
539  return 329;
540 
541  break;
542 
543  case 'Q':
544  return -37;
545 
546  break;
547 
548  case 'E':
549  return 117;
550 
551  break;
552 
553  case 'G':
554  return -66;
555 
556  break;
557 
558  case 'H':
559  return -70;
560 
561  break;
562 
563  case 'I':
564  return 28;
565 
566  break;
567 
568  case 'L':
569  return 36;
570 
571  break;
572 
573  case 'K':
574  return 115;
575 
576  break;
577 
578  case 'M':
579  return 62;
580 
581  break;
582 
583  case 'F':
584  return 120;
585 
586  break;
587 
588  case 'P':
589  return -132;
590 
591  break;
592 
593  case 'S':
594  return -52;
595 
596  break;
597 
598  case 'T':
599  return 174;
600 
601  break;
602 
603  case 'W':
604  return 179;
605 
606  break;
607 
608  case 'Y':
609  return -7;
610 
611  break;
612 
613  case 'V':
614  return 114;
615 
616  break;
617 
618  default:
619  throw Exception::InvalidValue(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Unknown amino acid one-letter-code", String(aa));
620  }
621  }
622 
623  //WILM950101 0.838 MEEJ810102 0.809
624  //I A/L R/K N/M D/F C/P Q/S E/T G/W H/Y I/V
625  //2.62 1.26 -1.27 -2.84 0.73 -1.69 -0.45 -1.15 -0.74 4.38
626  //6.57 -2.78 -3.12 9.14 -0.12 -1.39 1.81 5.91 1.39 2.30
627 
639  static DoubleReal getWILM950102(char aa)
640  {
641  switch (aa)
642  {
643  case 'A':
644  return 2.62;
645 
646  break;
647 
648  case 'R':
649  return 1.26;
650 
651  break;
652 
653  case 'N':
654  return -1.27;
655 
656  break;
657 
658  case 'D':
659  return -2.84;
660 
661  break;
662 
663  case 'C':
664  return 0.73;
665 
666  break;
667 
668  case 'Q':
669  return -1.69;
670 
671  break;
672 
673  case 'E':
674  return -0.45;
675 
676  break;
677 
678  case 'G':
679  return -1.15;
680 
681  break;
682 
683  case 'H':
684  return -0.74;
685 
686  break;
687 
688  case 'I':
689  return 4.38;
690 
691  break;
692 
693  case 'L':
694  return 6.57;
695 
696  break;
697 
698  case 'K':
699  return -2.78;
700 
701  break;
702 
703  case 'M':
704  return -3.12;
705 
706  break;
707 
708  case 'F':
709  return 9.14;
710 
711  break;
712 
713  case 'P':
714  return -0.12;
715 
716  break;
717 
718  case 'S':
719  return -1.39;
720 
721  break;
722 
723  case 'T':
724  return 1.81;
725 
726  break;
727 
728  case 'W':
729  return 5.91;
730 
731  break;
732 
733  case 'Y':
734  return 1.39;
735 
736  break;
737 
738  case 'V':
739  return 2.30;
740 
741  break;
742 
743  default:
744  throw Exception::InvalidValue(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Unknown amino acid one-letter-code", String(aa));
745  }
746  }
747 
748  //I A/L R/K N/M D/F C/P Q/S E/T G/W H/Y I/V
749  //0.0 1.1 -2.0 -2.6 5.4 2.4 3.1 -3.4 0.8 -0.1
750  //-3.7 -3.1 -2.1 0.7 7.4 1.3 0.0 -3.4 4.8 2.7
751 
762  static DoubleReal getROBB760107(char aa)
763  {
764  switch (aa)
765  {
766  case 'A':
767  return 0.0;
768 
769  break;
770 
771  case 'R':
772  return 1.1;
773 
774  break;
775 
776  case 'N':
777  return -2.0;
778 
779  break;
780 
781  case 'D':
782  return -2.6;
783 
784  break;
785 
786  case 'C':
787  return 5.4;
788 
789  break;
790 
791  case 'Q':
792  return 2.4;
793 
794  break;
795 
796  case 'E':
797  return 3.1;
798 
799  break;
800 
801  case 'G':
802  return -3.4;
803 
804  break;
805 
806  case 'H':
807  return 0.8;
808 
809  break;
810 
811  case 'I':
812  return -0.1;
813 
814  break;
815 
816  case 'L':
817  return -3.7;
818 
819  break;
820 
821  case 'K':
822  return -3.1;
823 
824  break;
825 
826  case 'M':
827  return -2.1;
828 
829  break;
830 
831  case 'F':
832  return 0.7;
833 
834  break;
835 
836  case 'P':
837  return 7.4;
838 
839  break;
840 
841  case 'S':
842  return 1.3;
843 
844  break;
845 
846  case 'T':
847  return 0.0;
848 
849  break;
850 
851  case 'W':
852  return -3.4;
853 
854  break;
855 
856  case 'Y':
857  return 4.8;
858 
859  break;
860 
861  case 'V':
862  return 2.7;
863 
864  break;
865 
866  default:
867  throw Exception::InvalidValue(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Unknown amino acid one-letter-code", String(aa));
868  }
869  }
870 
871  //I A/L R/K N/M D/F C/P Q/S E/T G/W H/Y I/V
872  //-2.49 2.55 2.27 8.86 -3.13 1.79 4.04 -0.56 4.22 -10.87
873  //-7.16 -9.97 -4.96 -6.64 5.19 -1.60 -4.75 -17.84 9.25 -3.97
874 
886  static DoubleReal getOOBM850104(char aa)
887  {
888  switch (aa)
889  {
890  case 'A':
891  return -2.49;
892 
893  break;
894 
895  case 'R':
896  return 2.55;
897 
898  break;
899 
900  case 'N':
901  return 2.27;
902 
903  break;
904 
905  case 'D':
906  return 8.86;
907 
908  break;
909 
910  case 'C':
911  return -3.13;
912 
913  break;
914 
915  case 'Q':
916  return 1.79;
917 
918  break;
919 
920  case 'E':
921  return 4.04;
922 
923  break;
924 
925  case 'G':
926  return -0.56;
927 
928  break;
929 
930  case 'H':
931  return 4.22;
932 
933  break;
934 
935  case 'I':
936  return -10.87;
937 
938  break;
939 
940  case 'L':
941  return -7.16;
942 
943  break;
944 
945  case 'K':
946  return -9.97;
947 
948  break;
949 
950  case 'M':
951  return -4.96;
952 
953  break;
954 
955  case 'F':
956  return -6.64;
957 
958  break;
959 
960  case 'P':
961  return 5.19;
962 
963  break;
964 
965  case 'S':
966  return -1.60;
967 
968  break;
969 
970  case 'T':
971  return -4.75;
972 
973  break;
974 
975  case 'W':
976  return -17.84;
977 
978  break;
979 
980  case 'Y':
981  return 9.25;
982 
983  break;
984 
985  case 'V':
986  return -3.97;
987 
988  break;
989 
990  default:
991  throw Exception::InvalidValue(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Unknown amino acid one-letter-code", String(aa));
992  }
993  }
994 
995  //ZIMJ680104 0.813
996  //I A/L R/K N/M D/F C/P Q/S E/T G/W H/Y I/V
997  //0. 1. 0. 0. 0. 0. 0. 0. 1. 0.
998  //0. 1. 0. 0. 0. 0. 0. 0. 0. 0.
999 
1011  static DoubleReal getFAUJ880111(char aa)
1012  {
1013  switch (aa)
1014  {
1015  case 'A':
1016  return 0.;
1017 
1018  break;
1019 
1020  case 'R':
1021  return 1.;
1022 
1023  break;
1024 
1025  case 'N':
1026  return 0.;
1027 
1028  break;
1029 
1030  case 'D':
1031  return 0.;
1032 
1033  break;
1034 
1035  case 'C':
1036  return 0.;
1037 
1038  break;
1039 
1040  case 'Q':
1041  return 0.;
1042 
1043  break;
1044 
1045  case 'E':
1046  return 0.;
1047 
1048  break;
1049 
1050  case 'G':
1051  return 0.;
1052 
1053  break;
1054 
1055  case 'H':
1056  return 1.;
1057 
1058  break;
1059 
1060  case 'I':
1061  return 0.;
1062 
1063  break;
1064 
1065  case 'L':
1066  return 0.;
1067 
1068  break;
1069 
1070  case 'K':
1071  return 1.;
1072 
1073  break;
1074 
1075  case 'M':
1076  return 0.;
1077 
1078  break;
1079 
1080  case 'F':
1081  return 0.;
1082 
1083  break;
1084 
1085  case 'P':
1086  return 0.;
1087 
1088  break;
1089 
1090  case 'S':
1091  return 0.;
1092 
1093  break;
1094 
1095  case 'T':
1096  return 0.;
1097 
1098  break;
1099 
1100  case 'W':
1101  return 0.;
1102 
1103  break;
1104 
1105  case 'Y':
1106  return 0.;
1107 
1108  break;
1109 
1110  case 'V':
1111  return 0.;
1112 
1113  break;
1114 
1115  default:
1116  throw Exception::InvalidValue(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Unknown amino acid one-letter-code", String(aa));
1117  }
1118  }
1119 
1120  //SUEM840101 0.883 AURR980114 0.875 AURR980113 0.849<br>
1121  //PTIO830101 0.826 KANM800103 0.823 QIAN880107 0.814<br>
1122  //QIAN880106 0.810 MAXF760101 0.810 AURR980109 0.802
1123  //I A/L R/K N/M D/F C/P Q/S E/T G/W H/Y I/V
1124  //1.08 1.05 0.85 0.85 0.95 0.95 1.15 0.55 1.00 1.05
1125  //1.25 1.15 1.15 1.10 0.71 0.75 0.75 1.10 1.10 0.95
1126 
1138  static DoubleReal getFINA770101(char aa)
1139  {
1140  switch (aa)
1141  {
1142  case 'A':
1143  return 1.08;
1144 
1145  break;
1146 
1147  case 'R':
1148  return 1.05;
1149 
1150  break;
1151 
1152  case 'N':
1153  return 0.85;
1154 
1155  break;
1156 
1157  case 'D':
1158  return 0.85;
1159 
1160  break;
1161 
1162  case 'C':
1163  return 0.95;
1164 
1165  break;
1166 
1167  case 'Q':
1168  return 0.95;
1169 
1170  break;
1171 
1172  case 'E':
1173  return 1.15;
1174 
1175  break;
1176 
1177  case 'G':
1178  return 0.55;
1179 
1180  break;
1181 
1182  case 'H':
1183  return 1.00;
1184 
1185  break;
1186 
1187  case 'I':
1188  return 1.05;
1189 
1190  break;
1191 
1192  case 'L':
1193  return 1.25;
1194 
1195  break;
1196 
1197  case 'K':
1198  return 1.15;
1199 
1200  break;
1201 
1202  case 'M':
1203  return 1.15;
1204 
1205  break;
1206 
1207  case 'F':
1208  return 1.10;
1209 
1210  break;
1211 
1212  case 'P':
1213  return 0.71;
1214 
1215  break;
1216 
1217  case 'S':
1218  return 0.75;
1219 
1220  break;
1221 
1222  case 'T':
1223  return 0.75;
1224 
1225  break;
1226 
1227  case 'W':
1228  return 1.10;
1229 
1230  break;
1231 
1232  case 'Y':
1233  return 1.10;
1234 
1235  break;
1236 
1237  case 'V':
1238  return 0.95;
1239 
1240  break;
1241 
1242  default:
1243  throw Exception::InvalidValue(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Unknown amino acid one-letter-code", String(aa));
1244  }
1245  }
1246 
1247  //ARGP820103 0.961 KYTJ820101 0.803 JURD980101 0.802
1248  //I A/L R/K N/M D/F C/P Q/S E/T G/W H/Y I/V
1249  //1.18 0.20 0.23 0.05 1.89 0.72 0.11 0.49 0.31 1.45
1250  //3.23 0.06 2.67 1.96 0.76 0.97 0.84 0.77 0.39 1.08
1251 
1262  static DoubleReal getARGP820102(char aa)
1263  {
1264  switch (aa)
1265  {
1266  case 'A':
1267  return 1.18;
1268 
1269  break;
1270 
1271  case 'R':
1272  return 0.20;
1273 
1274  break;
1275 
1276  case 'N':
1277  return 0.23;
1278 
1279  break;
1280 
1281  case 'D':
1282  return 0.05;
1283 
1284  break;
1285 
1286  case 'C':
1287  return 1.89;
1288 
1289  break;
1290 
1291  case 'Q':
1292  return 0.72;
1293 
1294  break;
1295 
1296  case 'E':
1297  return 0.11;
1298 
1299  break;
1300 
1301  case 'G':
1302  return 0.49;
1303 
1304  break;
1305 
1306  case 'H':
1307  return 0.31;
1308 
1309  break;
1310 
1311  case 'I':
1312  return 1.45;
1313 
1314  break;
1315 
1316  case 'L':
1317  return 3.23;
1318 
1319  break;
1320 
1321  case 'K':
1322  return 0.06;
1323 
1324  break;
1325 
1326  case 'M':
1327  return 2.67;
1328 
1329  break;
1330 
1331  case 'F':
1332  return 1.96;
1333 
1334  break;
1335 
1336  case 'P':
1337  return 0.76;
1338 
1339  break;
1340 
1341  case 'S':
1342  return 0.97;
1343 
1344  break;
1345 
1346  case 'T':
1347  return 0.84;
1348 
1349  break;
1350 
1351  case 'W':
1352  return 0.77;
1353 
1354  break;
1355 
1356  case 'Y':
1357  return 0.39;
1358 
1359  break;
1360 
1361  case 'V':
1362  return 1.08;
1363 
1364  break;
1365 
1366  default:
1367  throw Exception::InvalidValue(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Unknown amino acid one-letter-code", String(aa));
1368  }
1369  }
1370 
1381  static DoubleReal calculateGB(const AASequence & seq, DoubleReal T = 500.0)
1382  {
1383 
1384  DoubleReal R = Constants::GAS_CONSTANT / 1000.0; // ideal gas constant in kj/(K*mol)
1385 
1386  char left = '>';
1387  char right;
1388 
1389  DoubleReal k_app = 0.0; // apparent proton association constant
1390 
1391  // energy level E at each protonation site i is -GB(i)
1392  // fractional proton population of a microstate k is
1393  // P_k = exp (- E_k/(RT)) / ( sum_i exp (- E_i/(RT)))
1394  // the apparent proton association constant k_app:
1395  // k_app = sum_i GB(i)/(RT)
1396  // then the apparent GB is GB_app^ion = R * T * ln(k_app)
1397  for (Size i = 0; i <= seq.size(); i++)
1398  {
1399  // aa left to current one
1400  if (i > 0)
1401  {
1402  Residue leftchar = seq[i - 1];
1403  left = leftchar.getOneLetterCode()[0];
1404  }
1405 
1406  // aa right to current one
1407  if (i == seq.size())
1408  {
1409  right = '<';
1410  }
1411  else
1412  {
1413  Residue rightchar = seq[i];
1414  right = rightchar.getOneLetterCode()[0];
1415  }
1416  DoubleReal contrib = exp((GBleft_(left) + GBdeltaright_(right)) / (R * T));
1417  if (i > 0 && i < seq.size())
1418  {
1419  contrib += exp(GBsidechain_(right) / (R * T));
1420  }
1421  k_app += contrib;
1422  }
1423  // calculate apparent GB
1424  return R * T * log(k_app) / log(2.0);
1425  }
1426 
1427 protected:
1428 
1436  static DoubleReal GBsidechain_(char aa)
1437  {
1438  switch (aa)
1439  {
1440  case 'A':
1441  return 0.0;
1442 
1443  break;
1444 
1445  case 'C':
1446  return 0.0;
1447 
1448  break;
1449 
1450  case 'D':
1451  return 784.0;
1452 
1453  break;
1454 
1455  case 'E':
1456  return 790.0;
1457 
1458  break;
1459 
1460  case 'F':
1461  return 0.0;
1462 
1463  break;
1464 
1465  case 'G':
1466  return 0.0;
1467 
1468  break;
1469 
1470  case 'H':
1471  return 927.84;
1472 
1473  break;
1474 
1475  case 'I':
1476  return 0.0;
1477 
1478  break;
1479 
1480  case 'K':
1481  return 926.74;
1482 
1483  break;
1484 
1485  case 'L':
1486  return 0.0;
1487 
1488  break;
1489 
1490  case 'M':
1491  return 830.0;
1492 
1493  break;
1494 
1495  case 'N':
1496  return 864.94;
1497 
1498  break;
1499 
1500  case 'P':
1501  return 0.0;
1502 
1503  break;
1504 
1505  case 'Q':
1506  return 865.25;
1507 
1508  break;
1509 
1510  case 'R':
1511  return 1000.0;
1512 
1513  break;
1514 
1515  case 'S':
1516  return 775.0;
1517 
1518  break;
1519 
1520  case 'T':
1521  return 780.0;
1522 
1523  break;
1524 
1525  case 'V':
1526  return 0.0;
1527 
1528  break;
1529 
1530  case 'W':
1531  return 909.53;
1532 
1533  break;
1534 
1535  case 'Y':
1536  return 790.0;
1537 
1538  break;
1539 
1540  default:
1541  throw Exception::InvalidValue(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Unknown amino acid one-letter-code", String(aa));
1542  }
1543 
1544  return 0.0; //this should never be reached, but is necessary to suppress compiler warnings on older compilers
1545  }
1546 
1554  static DoubleReal GBleft_(char aa)
1555  {
1556  switch (aa)
1557  {
1558  case 'A':
1559  return 881.82;
1560 
1561  break;
1562 
1563  case 'C':
1564  return 881.15;
1565 
1566  break;
1567 
1568  case 'D':
1569  return 880.02;
1570 
1571  break;
1572 
1573  case 'E':
1574  return 880.10;
1575 
1576  break;
1577 
1578  case 'F':
1579  return 881.08;
1580 
1581  break;
1582 
1583  case 'G':
1584  return 881.17;
1585 
1586  break;
1587 
1588  case 'H':
1589  return 881.27;
1590 
1591  break;
1592 
1593  case 'I':
1594  return 880.99;
1595 
1596  break;
1597 
1598  case 'K':
1599  return 880.06;
1600 
1601  break;
1602 
1603  case 'L':
1604  return 881.88;
1605 
1606  break;
1607 
1608  case 'M':
1609  return 881.38;
1610 
1611  break;
1612 
1613  case 'N':
1614  return 881.18;
1615 
1616  break;
1617 
1618  case 'P':
1619  return 881.25;
1620 
1621  break;
1622 
1623  case 'Q':
1624  return 881.50;
1625 
1626  break;
1627 
1628  case 'R':
1629  return 882.98;
1630 
1631  break;
1632 
1633  case 'S':
1634  return 881.08;
1635 
1636  break;
1637 
1638  case 'T':
1639  return 881.14;
1640 
1641  break;
1642 
1643  case 'V':
1644  return 881.17;
1645 
1646  break;
1647 
1648  case 'W':
1649  return 881.31;
1650 
1651  break;
1652 
1653  case 'Y':
1654  return 881.20;
1655 
1656  break;
1657 
1658  case '>': //NH2
1659  return 916.84;
1660 
1661  break;
1662 
1663  default:
1664  throw Exception::InvalidValue(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Unknown amino acid one-letter-code", String(aa));
1665 
1666  }
1667 
1668  return 0.0; //this should never be reached, but is necessary to suppress compiler warnings on older compilers
1669  }
1670 
1678  static DoubleReal GBdeltaright_(char aa)
1679  {
1680  switch (aa)
1681  {
1682  case 'A':
1683  return 0.0;
1684 
1685  break;
1686 
1687  case 'C':
1688  return -0.69;
1689 
1690  break;
1691 
1692  case 'D':
1693  return -0.63;
1694 
1695  break;
1696 
1697  case 'E':
1698  return -0.39;
1699 
1700  break;
1701 
1702  case 'F':
1703  return 0.03;
1704 
1705  break;
1706 
1707  case 'G':
1708  return 0.92;
1709 
1710  break;
1711 
1712  case 'H':
1713  return -0.19;
1714 
1715  break;
1716 
1717  case 'I':
1718  return -1.17;
1719 
1720  break;
1721 
1722  case 'K':
1723  return -0.71;
1724 
1725  break;
1726 
1727  case 'L':
1728  return -0.09;
1729 
1730  break;
1731 
1732  case 'M':
1733  return 0.30;
1734 
1735  break;
1736 
1737  case 'N':
1738  return 1.56;
1739 
1740  break;
1741 
1742  case 'P':
1743  return 11.75;
1744 
1745  break;
1746 
1747  case 'Q':
1748  return 4.10;
1749 
1750  break;
1751 
1752  case 'R':
1753  return 6.28;
1754 
1755  break;
1756 
1757  case 'S':
1758  return 0.98;
1759 
1760  break;
1761 
1762  case 'T':
1763  return 1.21;
1764 
1765  break;
1766 
1767  case 'V':
1768  return -0.90;
1769 
1770  break;
1771 
1772  case 'W':
1773  return 0.10;
1774 
1775  break;
1776 
1777  case 'Y':
1778  return -0.38;
1779 
1780  break;
1781 
1782  case '<': //COOH
1783  return -95.82;
1784 
1785  break;
1786 
1787  default:
1788  throw Exception::InvalidValue(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Unknown amino acid one-letter-code", String(aa));
1789  }
1790 
1791  return 0.0; //this should never be reached, but is necessary to suppress compiler warnings on older compilers
1792  }
1793 
1794 private:
1795 
1797  AAIndex();
1798  };
1799 
1800 }
1801 #endif
static DoubleReal polar(char aa)
Returns if the residue is polar (1.0 or 0.0)
Definition: AAIndex.h:114
A more convenient string class.
Definition: String.h:56
static DoubleReal getNADH010106(char aa)
Hydropathy scale based on self-information values in the two-state model (36% accessibility) (Naderi-...
Definition: AAIndex.h:390
const String & getOneLetterCode() const
returns the name as one letter code
static DoubleReal getWILM950102(char aa)
Hydrophobicity coefficient in RP-HPLC, C8 with 0.1TFA/MeCN/H2O (Wilce et al. 1995) ...
Definition: AAIndex.h:639
static DoubleReal getFINA770101(char aa)
Helix-coil equilibrium constant (Finkelstein-Ptitsyn, 1977)
Definition: AAIndex.h:1138
Representation of a peptide/protein sequence.
Definition: AASequence.h:84
const double R
Representation of a residue.
Definition: Residue.h:64
static DoubleReal getVASM830103(char aa)
Relative population of conformational state E (Vasquez et al., 1983)
Definition: AAIndex.h:263
static DoubleReal GBleft_(char aa)
Calculates part of the gas-phase basicity.
Definition: AAIndex.h:1554
static DoubleReal aliphatic(char aa)
Returns if the residue is aliphatic (1.0 or 0.0)
Definition: AAIndex.h:75
static DoubleReal basic(char aa)
Returns if the residue is basic (1.0 or 0.0)
Definition: AAIndex.h:101
static DoubleReal GBdeltaright_(char aa)
Calculates part of the gas-phase basicity.
Definition: AAIndex.h:1678
static DoubleReal getKHAG800101(char aa)
The Kerr-constant increments (Khanarian-Moore, 1980)
Definition: AAIndex.h:139
static DoubleReal GBsidechain_(char aa)
Calculates part of the gas-phase basicity.
Definition: AAIndex.h:1436
static DoubleReal getOOBM850104(char aa)
Optimized average non-bonded energy per atom (Oobatake et al., 1985)
Definition: AAIndex.h:886
static DoubleReal getFAUJ880111(char aa)
Positive charge (Fauchere et al., 1988)
Definition: AAIndex.h:1011
static DoubleReal calculateGB(const AASequence &seq, DoubleReal T=500.0)
Calculates an estimated gas-phase basicity for an amino acid sequence at a given temperature.
Definition: AAIndex.h:1381
Invalid value exception.
Definition: Exception.h:336
static DoubleReal getARGP820102(char aa)
Signal sequence helical potential (Argos et al., 1982)
Definition: AAIndex.h:1262
Size size() const
returns the number of residues
size_t Size
Size type e.g. used as variable which can hold result of size()
Definition: Types.h:144
static DoubleReal acidic(char aa)
Returns if the residue is acidic (1.0 or 0.0)
Definition: AAIndex.h:88
static DoubleReal getROBB760107(char aa)
Information measure for extended without H-bond (Robson-Suzuki, 1976)
Definition: AAIndex.h:762
static DoubleReal getNADH010107(char aa)
Hydropathy scale based on self-information values in the two-state model (50% accessibility) (Naderi-...
Definition: AAIndex.h:514
const double GAS_CONSTANT
Representation of selected AAIndex properties.
Definition: AAIndex.h:70

OpenMS / TOPP release 1.11.1 Documentation generated on Thu Nov 14 2013 11:19:11 using doxygen 1.8.5