Home  · Classes  · Annotated Classes  · Modules  · Members  · Namespaces  · Related Pages

AAIndex.h

Go to the documentation of this file.
00001 // --------------------------------------------------------------------------
00002 //                   OpenMS -- Open-Source Mass Spectrometry
00003 // --------------------------------------------------------------------------
00004 // Copyright The OpenMS Team -- Eberhard Karls University Tuebingen,
00005 // ETH Zurich, and Freie Universitaet Berlin 2002-2012.
00006 //
00007 // This software is released under a three-clause BSD license:
00008 //  * Redistributions of source code must retain the above copyright
00009 //    notice, this list of conditions and the following disclaimer.
00010 //  * Redistributions in binary form must reproduce the above copyright
00011 //    notice, this list of conditions and the following disclaimer in the
00012 //    documentation and/or other materials provided with the distribution.
00013 //  * Neither the name of any author or any participating institution
00014 //    may be used to endorse or promote products derived from this software
00015 //    without specific prior written permission.
00016 // For a full list of authors, refer to the file AUTHORS.
00017 // --------------------------------------------------------------------------
00018 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
00019 // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
00020 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
00021 // ARE DISCLAIMED. IN NO EVENT SHALL ANY OF THE AUTHORS OR THE CONTRIBUTING
00022 // INSTITUTIONS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
00023 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
00024 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
00025 // OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
00026 // WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
00027 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
00028 // ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00029 //
00030 // --------------------------------------------------------------------------
00031 // $Maintainer: Alexandra Scherbart $
00032 // $Authors: $
00033 // --------------------------------------------------------------------------
00034 
00035 #ifndef OPENMS_CHEMISTRY_AAINDEX_H
00036 #define OPENMS_CHEMISTRY_AAINDEX_H
00037 
00038 #include <OpenMS/CONCEPT/Exception.h>
00039 #include <OpenMS/CONCEPT/Constants.h>
00040 
00041 #include <cmath>
00042 
00043 namespace OpenMS
00044 {
00070   class OPENMS_DLLAPI AAIndex
00071   {
00072 public:
00073 
00075     static DoubleReal aliphatic(char aa)
00076     {
00077       if (aa == 'A' || aa == 'G' || aa == 'F' || aa == 'I' || aa == 'M' || aa == 'L' || aa == 'P' || aa == 'V')
00078       {
00079         return 1.0;
00080       }
00081       else
00082       {
00083         return 0.0;
00084       }
00085     }
00086 
00088     static DoubleReal acidic(char aa)
00089     {
00090       if (aa == 'D' || aa == 'E')
00091       {
00092         return 1.0;
00093       }
00094       else
00095       {
00096         return 0.0;
00097       }
00098     }
00099 
00101     static DoubleReal basic(char aa)
00102     {
00103       if (aa == 'K' || aa == 'R' || aa == 'H' || aa == 'W')
00104       {
00105         return 1.0;
00106       }
00107       else
00108       {
00109         return 0.0;
00110       }
00111     }
00112 
00114     static DoubleReal polar(char aa)
00115     {
00116       if (aa == 'S' || aa == 'T' || aa == 'Y' || aa == 'H' || aa == 'C' || aa == 'N' || aa == 'Q' || aa == 'W')
00117       {
00118         return 1.0;
00119       }
00120       else
00121       {
00122         return 0.0;
00123       }
00124     }
00125 
00126     //I    A/L     R/K     N/M     D/F     C/P     Q/S     E/T     G/W     H/Y     I/V
00127     //49.1    133.    -3.6      0.      0.     20.      0.    64.6    75.7    18.9
00128     //15.6      0.     6.8    54.7    43.8    44.4    31.0    70.5      0.    29.5
00139     static DoubleReal getKHAG800101(char aa)
00140     {
00141       switch (aa)
00142       {
00143       case 'A':
00144         return 49.1;
00145 
00146         break;
00147 
00148       case 'R':
00149         return 133.;
00150 
00151         break;
00152 
00153       case 'N':
00154         return -3.6;
00155 
00156         break;
00157 
00158       case 'D':
00159         return 0.;
00160 
00161         break;
00162 
00163       case 'C':
00164         return 0.;
00165 
00166         break;
00167 
00168       case 'Q':
00169         return 20.;
00170 
00171         break;
00172 
00173       case 'E':
00174         return 0.;
00175 
00176         break;
00177 
00178       case 'G':
00179         return 64.6;
00180 
00181         break;
00182 
00183       case 'H':
00184         return 75.7;
00185 
00186         break;
00187 
00188       case 'I':
00189         return 18.9;
00190 
00191         break;
00192 
00193       case 'L':
00194         return 15.6;
00195 
00196         break;
00197 
00198       case 'K':
00199         return 0.;
00200 
00201         break;
00202 
00203       case 'M':
00204         return 6.8;
00205 
00206         break;
00207 
00208       case 'F':
00209         return 54.7;
00210 
00211         break;
00212 
00213       case 'P':
00214         return 43.8;
00215 
00216         break;
00217 
00218       case 'S':
00219         return 44.4;
00220 
00221         break;
00222 
00223       case 'T':
00224         return 31.0;
00225 
00226         break;
00227 
00228       case 'W':
00229         return 70.5;
00230 
00231         break;
00232 
00233       case 'Y':
00234         return 0.;
00235 
00236         break;
00237 
00238       case 'V':
00239         return 29.5;
00240 
00241         break;
00242 
00243       default:
00244         throw Exception::InvalidValue(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Unkown amino acid one-letter-code", String(aa));
00245       }
00246     }
00247 
00248     //I    A/L     R/K     N/M     D/F     C/P     Q/S     E/T     G/W     H/Y     I/V
00249     //0.159   0.194   0.385   0.283   0.187   0.236   0.206   0.049   0.233   0.581
00250     //0.083   0.159   0.198   0.682   0.366   0.150   0.074   0.463   0.737   0.301
00251 
00263     static DoubleReal getVASM830103(char aa)
00264     {
00265       switch (aa)
00266       {
00267       case 'A':
00268         return 0.159;
00269 
00270         break;
00271 
00272       case 'R':
00273         return 0.194;
00274 
00275         break;
00276 
00277       case 'N':
00278         return 0.385;
00279 
00280         break;
00281 
00282       case 'D':
00283         return 0.283;
00284 
00285         break;
00286 
00287       case 'C':
00288         return 0.187;
00289 
00290         break;
00291 
00292       case 'Q':
00293         return 0.236;
00294 
00295         break;
00296 
00297       case 'E':
00298         return 0.206;
00299 
00300         break;
00301 
00302       case 'G':
00303         return 0.049;
00304 
00305         break;
00306 
00307       case 'H':
00308         return 0.233;
00309 
00310         break;
00311 
00312       case 'I':
00313         return 0.581;
00314 
00315         break;
00316 
00317       case 'L':
00318         return 0.083;
00319 
00320         break;
00321 
00322       case 'K':
00323         return 0.159;
00324 
00325         break;
00326 
00327       case 'M':
00328         return 0.198;
00329 
00330         break;
00331 
00332       case 'F':
00333         return 0.682;
00334 
00335         break;
00336 
00337       case 'P':
00338         return 0.366;
00339 
00340         break;
00341 
00342       case 'S':
00343         return 0.150;
00344 
00345         break;
00346 
00347       case 'T':
00348         return 0.074;
00349 
00350         break;
00351 
00352       case 'W':
00353         return 0.463;
00354 
00355         break;
00356 
00357       case 'Y':
00358         return 0.737;
00359 
00360         break;
00361 
00362       case 'V':
00363         return 0.301;
00364 
00365         break;
00366 
00367       default:
00368         throw Exception::InvalidValue(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Unkown amino acid one-letter-code", String(aa));
00369       }
00370     }
00371 
00372     //NADH010105    0.958  NADH010104    0.914  NADH010103    0.881<br>
00373     //ZHOH040103    0.819  NADH010107    0.811  BAEK050101    0.809<br>
00374     //NADH010102    0.808  PONP800103    0.803  VINM940103   -0.813<br>
00375     //KRIW710101   -0.846  KRIW790101   -0.861
00376     //I    A/L     R/K     N/M     D/F     C/P     Q/S     E/T     G/W     H/Y     I/V
00377     //5     -57     -77      45     224     -67      -8     -47     -50      83
00378     //82     -38      83     117    -103     -41      79     130      27     117
00379 
00390     static DoubleReal getNADH010106(char aa)
00391     {
00392       switch (aa)
00393       {
00394       case 'A':
00395         return 5;
00396 
00397         break;
00398 
00399       case 'R':
00400         return -57;
00401 
00402         break;
00403 
00404       case 'N':
00405         return -77;
00406 
00407         break;
00408 
00409       case 'D':
00410         return 45;
00411 
00412         break;
00413 
00414       case 'C':
00415         return 224;
00416 
00417         break;
00418 
00419       case 'Q':
00420         return -67;
00421 
00422         break;
00423 
00424       case 'E':
00425         return -8;
00426 
00427         break;
00428 
00429       case 'G':
00430         return -47;
00431 
00432         break;
00433 
00434       case 'H':
00435         return -50;
00436 
00437         break;
00438 
00439       case 'I':
00440         return 83;
00441 
00442         break;
00443 
00444       case 'L':
00445         return 82;
00446 
00447         break;
00448 
00449       case 'K':
00450         return -38;
00451 
00452         break;
00453 
00454       case 'M':
00455         return 83;
00456 
00457         break;
00458 
00459       case 'F':
00460         return 117;
00461 
00462         break;
00463 
00464       case 'P':
00465         return -103;
00466 
00467         break;
00468 
00469       case 'S':
00470         return -41;
00471 
00472         break;
00473 
00474       case 'T':
00475         return 79;
00476 
00477         break;
00478 
00479       case 'W':
00480         return 130;
00481 
00482         break;
00483 
00484       case 'Y':
00485         return 27;
00486 
00487         break;
00488 
00489       case 'V':
00490         return 117;
00491 
00492         break;
00493 
00494       default:
00495         throw Exception::InvalidValue(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Unkown amino acid one-letter-code", String(aa));
00496       }
00497     }
00498 
00499     //NADH010106    0.811
00500     //I    A/L     R/K     N/M     D/F     C/P     Q/S     E/T     G/W     H/Y     I/V
00501     //-2     -41     -97     248     329     -37     117     -66     -70      28
00502     //36     115      62     120    -132     -52     174     179      -7     114
00503 
00514     static DoubleReal getNADH010107(char aa)
00515     {
00516       switch (aa)
00517       {
00518       case 'A':
00519         return -2;
00520 
00521         break;
00522 
00523       case 'R':
00524         return -41;
00525 
00526         break;
00527 
00528       case 'N':
00529         return -97;
00530 
00531         break;
00532 
00533       case 'D':
00534         return 248;
00535 
00536         break;
00537 
00538       case 'C':
00539         return 329;
00540 
00541         break;
00542 
00543       case 'Q':
00544         return -37;
00545 
00546         break;
00547 
00548       case 'E':
00549         return 117;
00550 
00551         break;
00552 
00553       case 'G':
00554         return -66;
00555 
00556         break;
00557 
00558       case 'H':
00559         return -70;
00560 
00561         break;
00562 
00563       case 'I':
00564         return 28;
00565 
00566         break;
00567 
00568       case 'L':
00569         return 36;
00570 
00571         break;
00572 
00573       case 'K':
00574         return 115;
00575 
00576         break;
00577 
00578       case 'M':
00579         return 62;
00580 
00581         break;
00582 
00583       case 'F':
00584         return 120;
00585 
00586         break;
00587 
00588       case 'P':
00589         return -132;
00590 
00591         break;
00592 
00593       case 'S':
00594         return -52;
00595 
00596         break;
00597 
00598       case 'T':
00599         return 174;
00600 
00601         break;
00602 
00603       case 'W':
00604         return 179;
00605 
00606         break;
00607 
00608       case 'Y':
00609         return -7;
00610 
00611         break;
00612 
00613       case 'V':
00614         return 114;
00615 
00616         break;
00617 
00618       default:
00619         throw Exception::InvalidValue(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Unkown amino acid one-letter-code", String(aa));
00620       }
00621     }
00622 
00623     //WILM950101    0.838  MEEJ810102    0.809
00624     //I    A/L     R/K     N/M     D/F     C/P     Q/S     E/T     G/W     H/Y     I/V
00625     //2.62    1.26   -1.27   -2.84    0.73   -1.69   -0.45   -1.15   -0.74    4.38
00626     //6.57   -2.78   -3.12    9.14   -0.12   -1.39    1.81    5.91    1.39    2.30
00627 
00639     static DoubleReal getWILM950102(char aa)
00640     {
00641       switch (aa)
00642       {
00643       case 'A':
00644         return 2.62;
00645 
00646         break;
00647 
00648       case 'R':
00649         return 1.26;
00650 
00651         break;
00652 
00653       case 'N':
00654         return -1.27;
00655 
00656         break;
00657 
00658       case 'D':
00659         return -2.84;
00660 
00661         break;
00662 
00663       case 'C':
00664         return 0.73;
00665 
00666         break;
00667 
00668       case 'Q':
00669         return -1.69;
00670 
00671         break;
00672 
00673       case 'E':
00674         return -0.45;
00675 
00676         break;
00677 
00678       case 'G':
00679         return -1.15;
00680 
00681         break;
00682 
00683       case 'H':
00684         return -0.74;
00685 
00686         break;
00687 
00688       case 'I':
00689         return 4.38;
00690 
00691         break;
00692 
00693       case 'L':
00694         return 6.57;
00695 
00696         break;
00697 
00698       case 'K':
00699         return -2.78;
00700 
00701         break;
00702 
00703       case 'M':
00704         return -3.12;
00705 
00706         break;
00707 
00708       case 'F':
00709         return 9.14;
00710 
00711         break;
00712 
00713       case 'P':
00714         return -0.12;
00715 
00716         break;
00717 
00718       case 'S':
00719         return -1.39;
00720 
00721         break;
00722 
00723       case 'T':
00724         return 1.81;
00725 
00726         break;
00727 
00728       case 'W':
00729         return 5.91;
00730 
00731         break;
00732 
00733       case 'Y':
00734         return 1.39;
00735 
00736         break;
00737 
00738       case 'V':
00739         return 2.30;
00740 
00741         break;
00742 
00743       default:
00744         throw Exception::InvalidValue(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Unkown amino acid one-letter-code", String(aa));
00745       }
00746     }
00747 
00748     //I    A/L     R/K     N/M     D/F     C/P     Q/S     E/T     G/W     H/Y     I/V
00749     //0.0     1.1    -2.0    -2.6     5.4     2.4     3.1    -3.4     0.8    -0.1
00750     //-3.7    -3.1    -2.1     0.7     7.4     1.3     0.0    -3.4     4.8     2.7
00751 
00762     static DoubleReal getROBB760107(char aa)
00763     {
00764       switch (aa)
00765       {
00766       case 'A':
00767         return 0.0;
00768 
00769         break;
00770 
00771       case 'R':
00772         return 1.1;
00773 
00774         break;
00775 
00776       case 'N':
00777         return -2.0;
00778 
00779         break;
00780 
00781       case 'D':
00782         return -2.6;
00783 
00784         break;
00785 
00786       case 'C':
00787         return 5.4;
00788 
00789         break;
00790 
00791       case 'Q':
00792         return 2.4;
00793 
00794         break;
00795 
00796       case 'E':
00797         return 3.1;
00798 
00799         break;
00800 
00801       case 'G':
00802         return -3.4;
00803 
00804         break;
00805 
00806       case 'H':
00807         return 0.8;
00808 
00809         break;
00810 
00811       case 'I':
00812         return -0.1;
00813 
00814         break;
00815 
00816       case 'L':
00817         return -3.7;
00818 
00819         break;
00820 
00821       case 'K':
00822         return -3.1;
00823 
00824         break;
00825 
00826       case 'M':
00827         return -2.1;
00828 
00829         break;
00830 
00831       case 'F':
00832         return 0.7;
00833 
00834         break;
00835 
00836       case 'P':
00837         return 7.4;
00838 
00839         break;
00840 
00841       case 'S':
00842         return 1.3;
00843 
00844         break;
00845 
00846       case 'T':
00847         return 0.0;
00848 
00849         break;
00850 
00851       case 'W':
00852         return -3.4;
00853 
00854         break;
00855 
00856       case 'Y':
00857         return 4.8;
00858 
00859         break;
00860 
00861       case 'V':
00862         return 2.7;
00863 
00864         break;
00865 
00866       default:
00867         throw Exception::InvalidValue(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Unkown amino acid one-letter-code", String(aa));
00868       }
00869     }
00870 
00871     //I    A/L     R/K     N/M     D/F     C/P     Q/S     E/T     G/W     H/Y     I/V
00872     //-2.49    2.55    2.27    8.86   -3.13    1.79    4.04   -0.56    4.22  -10.87
00873     //-7.16   -9.97   -4.96   -6.64    5.19   -1.60   -4.75  -17.84    9.25   -3.97
00874 
00886     static DoubleReal getOOBM850104(char aa)
00887     {
00888       switch (aa)
00889       {
00890       case 'A':
00891         return -2.49;
00892 
00893         break;
00894 
00895       case 'R':
00896         return 2.55;
00897 
00898         break;
00899 
00900       case 'N':
00901         return 2.27;
00902 
00903         break;
00904 
00905       case 'D':
00906         return 8.86;
00907 
00908         break;
00909 
00910       case 'C':
00911         return -3.13;
00912 
00913         break;
00914 
00915       case 'Q':
00916         return 1.79;
00917 
00918         break;
00919 
00920       case 'E':
00921         return 4.04;
00922 
00923         break;
00924 
00925       case 'G':
00926         return -0.56;
00927 
00928         break;
00929 
00930       case 'H':
00931         return 4.22;
00932 
00933         break;
00934 
00935       case 'I':
00936         return -10.87;
00937 
00938         break;
00939 
00940       case 'L':
00941         return -7.16;
00942 
00943         break;
00944 
00945       case 'K':
00946         return -9.97;
00947 
00948         break;
00949 
00950       case 'M':
00951         return -4.96;
00952 
00953         break;
00954 
00955       case 'F':
00956         return -6.64;
00957 
00958         break;
00959 
00960       case 'P':
00961         return 5.19;
00962 
00963         break;
00964 
00965       case 'S':
00966         return -1.60;
00967 
00968         break;
00969 
00970       case 'T':
00971         return -4.75;
00972 
00973         break;
00974 
00975       case 'W':
00976         return -17.84;
00977 
00978         break;
00979 
00980       case 'Y':
00981         return 9.25;
00982 
00983         break;
00984 
00985       case 'V':
00986         return -3.97;
00987 
00988         break;
00989 
00990       default:
00991         throw Exception::InvalidValue(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Unkown amino acid one-letter-code", String(aa));
00992       }
00993     }
00994 
00995     //ZIMJ680104    0.813
00996     //I    A/L     R/K     N/M     D/F     C/P     Q/S     E/T     G/W     H/Y     I/V
00997     //0.      1.      0.      0.      0.      0.      0.      0.      1.      0.
00998     //0.      1.      0.      0.      0.      0.      0.      0.      0.      0.
00999 
01011     static DoubleReal getFAUJ880111(char aa)
01012     {
01013       switch (aa)
01014       {
01015       case 'A':
01016         return 0.;
01017 
01018         break;
01019 
01020       case 'R':
01021         return 1.;
01022 
01023         break;
01024 
01025       case 'N':
01026         return 0.;
01027 
01028         break;
01029 
01030       case 'D':
01031         return 0.;
01032 
01033         break;
01034 
01035       case 'C':
01036         return 0.;
01037 
01038         break;
01039 
01040       case 'Q':
01041         return 0.;
01042 
01043         break;
01044 
01045       case 'E':
01046         return 0.;
01047 
01048         break;
01049 
01050       case 'G':
01051         return 0.;
01052 
01053         break;
01054 
01055       case 'H':
01056         return 1.;
01057 
01058         break;
01059 
01060       case 'I':
01061         return 0.;
01062 
01063         break;
01064 
01065       case 'L':
01066         return 0.;
01067 
01068         break;
01069 
01070       case 'K':
01071         return 1.;
01072 
01073         break;
01074 
01075       case 'M':
01076         return 0.;
01077 
01078         break;
01079 
01080       case 'F':
01081         return 0.;
01082 
01083         break;
01084 
01085       case 'P':
01086         return 0.;
01087 
01088         break;
01089 
01090       case 'S':
01091         return 0.;
01092 
01093         break;
01094 
01095       case 'T':
01096         return 0.;
01097 
01098         break;
01099 
01100       case 'W':
01101         return 0.;
01102 
01103         break;
01104 
01105       case 'Y':
01106         return 0.;
01107 
01108         break;
01109 
01110       case 'V':
01111         return 0.;
01112 
01113         break;
01114 
01115       default:
01116         throw Exception::InvalidValue(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Unkown amino acid one-letter-code", String(aa));
01117       }
01118     }
01119 
01120     //SUEM840101    0.883  AURR980114    0.875  AURR980113    0.849<br>
01121     //PTIO830101    0.826  KANM800103    0.823  QIAN880107    0.814<br>
01122     //QIAN880106    0.810  MAXF760101    0.810  AURR980109    0.802
01123     //I    A/L     R/K     N/M     D/F     C/P     Q/S     E/T     G/W     H/Y     I/V
01124     //1.08    1.05    0.85    0.85    0.95    0.95    1.15    0.55    1.00    1.05
01125     //1.25    1.15    1.15    1.10    0.71    0.75    0.75    1.10    1.10    0.95
01126 
01138     static DoubleReal getFINA770101(char aa)
01139     {
01140       switch (aa)
01141       {
01142       case 'A':
01143         return 1.08;
01144 
01145         break;
01146 
01147       case 'R':
01148         return 1.05;
01149 
01150         break;
01151 
01152       case 'N':
01153         return 0.85;
01154 
01155         break;
01156 
01157       case 'D':
01158         return 0.85;
01159 
01160         break;
01161 
01162       case 'C':
01163         return 0.95;
01164 
01165         break;
01166 
01167       case 'Q':
01168         return 0.95;
01169 
01170         break;
01171 
01172       case 'E':
01173         return 1.15;
01174 
01175         break;
01176 
01177       case 'G':
01178         return 0.55;
01179 
01180         break;
01181 
01182       case 'H':
01183         return 1.00;
01184 
01185         break;
01186 
01187       case 'I':
01188         return 1.05;
01189 
01190         break;
01191 
01192       case 'L':
01193         return 1.25;
01194 
01195         break;
01196 
01197       case 'K':
01198         return 1.15;
01199 
01200         break;
01201 
01202       case 'M':
01203         return 1.15;
01204 
01205         break;
01206 
01207       case 'F':
01208         return 1.10;
01209 
01210         break;
01211 
01212       case 'P':
01213         return 0.71;
01214 
01215         break;
01216 
01217       case 'S':
01218         return 0.75;
01219 
01220         break;
01221 
01222       case 'T':
01223         return 0.75;
01224 
01225         break;
01226 
01227       case 'W':
01228         return 1.10;
01229 
01230         break;
01231 
01232       case 'Y':
01233         return 1.10;
01234 
01235         break;
01236 
01237       case 'V':
01238         return 0.95;
01239 
01240         break;
01241 
01242       default:
01243         throw Exception::InvalidValue(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Unkown amino acid one-letter-code", String(aa));
01244       }
01245     }
01246 
01247     //ARGP820103    0.961  KYTJ820101    0.803  JURD980101    0.802
01248     //I    A/L     R/K     N/M     D/F     C/P     Q/S     E/T     G/W     H/Y     I/V
01249     //1.18    0.20    0.23    0.05    1.89    0.72    0.11    0.49    0.31    1.45
01250     //3.23    0.06    2.67    1.96    0.76    0.97    0.84    0.77    0.39    1.08
01251 
01262     static DoubleReal getARGP820102(char aa)
01263     {
01264       switch (aa)
01265       {
01266       case 'A':
01267         return 1.18;
01268 
01269         break;
01270 
01271       case 'R':
01272         return 0.20;
01273 
01274         break;
01275 
01276       case 'N':
01277         return 0.23;
01278 
01279         break;
01280 
01281       case 'D':
01282         return 0.05;
01283 
01284         break;
01285 
01286       case 'C':
01287         return 1.89;
01288 
01289         break;
01290 
01291       case 'Q':
01292         return 0.72;
01293 
01294         break;
01295 
01296       case 'E':
01297         return 0.11;
01298 
01299         break;
01300 
01301       case 'G':
01302         return 0.49;
01303 
01304         break;
01305 
01306       case 'H':
01307         return 0.31;
01308 
01309         break;
01310 
01311       case 'I':
01312         return 1.45;
01313 
01314         break;
01315 
01316       case 'L':
01317         return 3.23;
01318 
01319         break;
01320 
01321       case 'K':
01322         return 0.06;
01323 
01324         break;
01325 
01326       case 'M':
01327         return 2.67;
01328 
01329         break;
01330 
01331       case 'F':
01332         return 1.96;
01333 
01334         break;
01335 
01336       case 'P':
01337         return 0.76;
01338 
01339         break;
01340 
01341       case 'S':
01342         return 0.97;
01343 
01344         break;
01345 
01346       case 'T':
01347         return 0.84;
01348 
01349         break;
01350 
01351       case 'W':
01352         return 0.77;
01353 
01354         break;
01355 
01356       case 'Y':
01357         return 0.39;
01358 
01359         break;
01360 
01361       case 'V':
01362         return 1.08;
01363 
01364         break;
01365 
01366       default:
01367         throw Exception::InvalidValue(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Unkown amino acid one-letter-code", String(aa));
01368       }
01369     }
01370 
01381     static DoubleReal calculateGB(const AASequence & seq, DoubleReal T = 500.0)
01382     {
01383 
01384       DoubleReal R = Constants::GAS_CONSTANT / 1000.0;         // ideal gas constant in kj/(K*mol)
01385 
01386       char left = '>';
01387       char right;
01388 
01389       DoubleReal k_app = 0.0;           // apparent proton association constant
01390 
01391       // energy level E at each protonation site i is -GB(i)
01392       // fractional proton population of a microstate k is
01393       // P_k = exp (- E_k/(RT)) / ( sum_i exp (- E_i/(RT)))
01394       // the apparent proton association constant k_app:
01395       // k_app = sum_i GB(i)/(RT)
01396       // then the apparent GB is GB_app^ion = R * T * ln(k_app)
01397       for (Size i = 0; i <= seq.size(); i++)
01398       {
01399         // aa left to current one
01400         if (i > 0)
01401         {
01402           Residue leftchar = seq[i - 1];
01403           left = leftchar.getOneLetterCode()[0];
01404         }
01405 
01406         // aa right to current one
01407         if (i == seq.size())
01408         {
01409           right = '<';
01410         }
01411         else
01412         {
01413           Residue rightchar = seq[i];
01414           right = rightchar.getOneLetterCode()[0];
01415         }
01416         DoubleReal contrib = exp((GBleft_(left) + GBdeltaright_(right)) / (R * T));
01417         if (i > 0 && i < seq.size())
01418         {
01419           contrib += exp(GBsidechain_(right) / (R * T));
01420         }
01421         k_app += contrib;
01422       }
01423       // calculate apparent GB
01424       return R * T * log(k_app) / log(2.0);
01425     }
01426 
01427 protected:
01428 
01436     static DoubleReal GBsidechain_(char aa)
01437     {
01438       switch (aa)
01439       {
01440       case 'A':
01441         return 0.0;
01442 
01443         break;
01444 
01445       case 'C':
01446         return 0.0;
01447 
01448         break;
01449 
01450       case 'D':
01451         return 784.0;
01452 
01453         break;
01454 
01455       case 'E':
01456         return 790.0;
01457 
01458         break;
01459 
01460       case 'F':
01461         return 0.0;
01462 
01463         break;
01464 
01465       case 'G':
01466         return 0.0;
01467 
01468         break;
01469 
01470       case 'H':
01471         return 927.84;
01472 
01473         break;
01474 
01475       case 'I':
01476         return 0.0;
01477 
01478         break;
01479 
01480       case 'K':
01481         return 926.74;
01482 
01483         break;
01484 
01485       case 'L':
01486         return 0.0;
01487 
01488         break;
01489 
01490       case 'M':
01491         return 830.0;
01492 
01493         break;
01494 
01495       case 'N':
01496         return 864.94;
01497 
01498         break;
01499 
01500       case 'P':
01501         return 0.0;
01502 
01503         break;
01504 
01505       case 'Q':
01506         return 865.25;
01507 
01508         break;
01509 
01510       case 'R':
01511         return 1000.0;
01512 
01513         break;
01514 
01515       case 'S':
01516         return 775.0;
01517 
01518         break;
01519 
01520       case 'T':
01521         return 780.0;
01522 
01523         break;
01524 
01525       case 'V':
01526         return 0.0;
01527 
01528         break;
01529 
01530       case 'W':
01531         return 909.53;
01532 
01533         break;
01534 
01535       case 'Y':
01536         return 790.0;
01537 
01538         break;
01539 
01540       default:
01541         throw Exception::InvalidValue(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Unkown amino acid one-letter-code", String(aa));
01542       }
01543 
01544       return 0.0;           //this should never be reached, but is necessary to suppress compiler warngins on older compilers
01545     }
01546 
01554     static DoubleReal GBleft_(char aa)
01555     {
01556       switch (aa)
01557       {
01558       case 'A':
01559         return 881.82;
01560 
01561         break;
01562 
01563       case 'C':
01564         return 881.15;
01565 
01566         break;
01567 
01568       case 'D':
01569         return 880.02;
01570 
01571         break;
01572 
01573       case 'E':
01574         return 880.10;
01575 
01576         break;
01577 
01578       case 'F':
01579         return 881.08;
01580 
01581         break;
01582 
01583       case 'G':
01584         return 881.17;
01585 
01586         break;
01587 
01588       case 'H':
01589         return 881.27;
01590 
01591         break;
01592 
01593       case 'I':
01594         return 880.99;
01595 
01596         break;
01597 
01598       case 'K':
01599         return 880.06;
01600 
01601         break;
01602 
01603       case 'L':
01604         return 881.88;
01605 
01606         break;
01607 
01608       case 'M':
01609         return 881.38;
01610 
01611         break;
01612 
01613       case 'N':
01614         return 881.18;
01615 
01616         break;
01617 
01618       case 'P':
01619         return 881.25;
01620 
01621         break;
01622 
01623       case 'Q':
01624         return 881.50;
01625 
01626         break;
01627 
01628       case 'R':
01629         return 882.98;
01630 
01631         break;
01632 
01633       case 'S':
01634         return 881.08;
01635 
01636         break;
01637 
01638       case 'T':
01639         return 881.14;
01640 
01641         break;
01642 
01643       case 'V':
01644         return 881.17;
01645 
01646         break;
01647 
01648       case 'W':
01649         return 881.31;
01650 
01651         break;
01652 
01653       case 'Y':
01654         return 881.20;
01655 
01656         break;
01657 
01658       case '>':               //NH2
01659         return 916.84;
01660 
01661         break;
01662 
01663       default:
01664         throw Exception::InvalidValue(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Unkown amino acid one-letter-code", String(aa));
01665 
01666       }
01667 
01668       return 0.0;           //this should never be reached, but is necessary to suppress compiler warngins on older compilers
01669     }
01670 
01678     static DoubleReal GBdeltaright_(char aa)
01679     {
01680       switch (aa)
01681       {
01682       case 'A':
01683         return 0.0;
01684 
01685         break;
01686 
01687       case 'C':
01688         return -0.69;
01689 
01690         break;
01691 
01692       case 'D':
01693         return -0.63;
01694 
01695         break;
01696 
01697       case 'E':
01698         return -0.39;
01699 
01700         break;
01701 
01702       case 'F':
01703         return 0.03;
01704 
01705         break;
01706 
01707       case 'G':
01708         return 0.92;
01709 
01710         break;
01711 
01712       case 'H':
01713         return -0.19;
01714 
01715         break;
01716 
01717       case 'I':
01718         return -1.17;
01719 
01720         break;
01721 
01722       case 'K':
01723         return -0.71;
01724 
01725         break;
01726 
01727       case 'L':
01728         return -0.09;
01729 
01730         break;
01731 
01732       case 'M':
01733         return 0.30;
01734 
01735         break;
01736 
01737       case 'N':
01738         return 1.56;
01739 
01740         break;
01741 
01742       case 'P':
01743         return 11.75;
01744 
01745         break;
01746 
01747       case 'Q':
01748         return 4.10;
01749 
01750         break;
01751 
01752       case 'R':
01753         return 6.28;
01754 
01755         break;
01756 
01757       case 'S':
01758         return 0.98;
01759 
01760         break;
01761 
01762       case 'T':
01763         return 1.21;
01764 
01765         break;
01766 
01767       case 'V':
01768         return -0.90;
01769 
01770         break;
01771 
01772       case 'W':
01773         return 0.10;
01774 
01775         break;
01776 
01777       case 'Y':
01778         return -0.38;
01779 
01780         break;
01781 
01782       case '<':               //COOH
01783         return -95.82;
01784 
01785         break;
01786 
01787       default:
01788         throw Exception::InvalidValue(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Unkown amino acid one-letter-code", String(aa));
01789       }
01790 
01791       return 0.0;           //this should never be reached, but is necessary to suppress compiler warngins on older compilers
01792     }
01793 
01794 private:
01795 
01797     AAIndex();
01798   };
01799 
01800 }
01801 #endif
OpenMS / TOPP release 1.10.0 Documentation generated on Thu Mar 7 2013 09:42:37 using doxygen 1.7.1