OpenMS
Loading...
Searching...
No Matches
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
18namespace OpenMS
19{
45 class OPENMS_DLLAPI AAIndex
46 {
47
48public:
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
1005protected:
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:88
OpenMS::AASequence::size
Size size() const
returns the number of residues
OpenMS::Exception::InvalidValue
Invalid value exception.
Definition Exception.h:306
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
Main OpenMS namespace.
Definition openswathalgo/include/OpenMS/OPENSWATHALGO/DATAACCESS/ISpectrumAccess.h:19