OpenMS
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-2023.
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
Representation of selected AAIndex properties.
Definition: AAIndex.h:70
OpenMS::AAIndex::polar
static double polar(char aa)
Returns if the residue is polar (1.0 or 0.0)
Definition: AAIndex.h:113
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::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::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::aliphatic
static double aliphatic(char aa)
Returns if the residue is aliphatic (1.0 or 0.0)
Definition: AAIndex.h:74
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::getKHAG800101
static double getKHAG800101(char aa)
The Kerr-constant increments (Khanarian-Moore, 1980)
Definition: AAIndex.h:138
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::getROBB760107
static double getROBB760107(char aa)
Information measure for extended without H-bond (Robson-Suzuki, 1976)
Definition: AAIndex.h:561
OpenMS::AAIndex::basic
static double basic(char aa)
Returns if the residue is basic (1.0 or 0.0)
Definition: AAIndex.h:100
OpenMS::AAIndex::GBleft_
static double GBleft_(char aa)
Calculates part of the gas-phase basicity.
Definition: AAIndex.h:1111
OpenMS::AAIndex::getFINA770101
static double getFINA770101(char aa)
Helix-coil equilibrium constant (Finkelstein-Ptitsyn, 1977)
Definition: AAIndex.h:817
OpenMS::AAIndex::GBsidechain_
static double GBsidechain_(char aa)
Calculates part of the gas-phase basicity.
Definition: AAIndex.h:1035
OpenMS::AAIndex::AAIndex
AAIndex()
Constructor not implemented => private.
OpenMS::AAIndex::getVASM830103
static double getVASM830103(char aa)
Relative population of conformational state E (Vasquez et al., 1983)
Definition: AAIndex.h:222
OpenMS::AAIndex::getFAUJ880111
static double getFAUJ880111(char aa)
Positive charge (Fauchere et al., 1988)
Definition: AAIndex.h:730
OpenMS::AAIndex::getARGP820102
static double getARGP820102(char aa)
Signal sequence helical potential (Argos et al., 1982)
Definition: AAIndex.h:901
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::GBdeltaright_
static double GBdeltaright_(char aa)
Calculates part of the gas-phase basicity.
Definition: AAIndex.h:1191
OpenMS::AASequence
Representation of a peptide/protein sequence.
Definition: AASequence.h:112
OpenMS::AASequence::size
Size size() const
returns the number of residues
OpenMS::Exception::InvalidValue
Invalid value exception.
Definition: Exception.h:329
OpenMS::Residue
Representation of an amino acid residue.
Definition: Residue.h:63
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:60
OpenMS::Size
size_t Size
Size type e.g. used as variable which can hold result of size()
Definition: Types.h:127
OpenMS::Constants::R
const double R
Definition: Constants.h:175
OpenMS::Constants::GAS_CONSTANT
const double GAS_CONSTANT
Definition: Constants.h:171
OpenMS
Main OpenMS namespace.
Definition: FeatureDeconvolution.h:48