| OpenMS 2.5.0

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