X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fschemes%2FResidueProperties.java;h=d5c542caf04ad052a72d66c13cd6b679db5bccf6;hb=4231d40261fef32ce4570a6bbad0d35df44e8baf;hp=7dd6520547a073604a78c81dcc67fb5e39130968;hpb=7b4ec47748c8785073981750de8a4f9d716395bb;p=jalview.git diff --git a/src/jalview/schemes/ResidueProperties.java b/src/jalview/schemes/ResidueProperties.java index 7dd6520..d5c542c 100755 --- a/src/jalview/schemes/ResidueProperties.java +++ b/src/jalview/schemes/ResidueProperties.java @@ -1,33 +1,46 @@ /* - * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.1) - * Copyright (C) 2014 The Jalview Authors + * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$) + * Copyright (C) $$Year-Rel$$ The Jalview Authors * * This file is part of Jalview. * * Jalview is free software: you can redistribute it and/or * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. + * as published by the Free Software Foundation, either version 3 + * of the License, or (at your option) any later version. * * Jalview is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty * of MERCHANTABILITY or FITNESS FOR A PARTICULAR * PURPOSE. See the GNU General Public License for more details. * - * You should have received a copy of the GNU General Public License along with Jalview. If not, see . + * You should have received a copy of the GNU General Public License + * along with Jalview. If not, see . * The Jalview Authors are detailed in the 'AUTHORS' file. */ package jalview.schemes; +import java.awt.Color; +import java.util.ArrayList; +import java.util.Enumeration; +import java.util.HashMap; +import java.util.Hashtable; +import java.util.List; +import java.util.Map; +import java.util.Vector; + +import javajs.J2SRequireImport; + +import jalview.analysis.scoremodels.FeatureScoreModel; import jalview.analysis.scoremodels.PIDScoreModel; import jalview.api.analysis.ScoreModelI; -import java.util.*; -import java.util.List; -import java.awt.*; +// required because of the static defs +@J2SRequireImport({ScoreMatrix.class, PIDScoreModel.class, FeatureScoreModel.class}) public class ResidueProperties { - public static Hashtable scoreMatrices = new Hashtable(); + public static Hashtable scoreMatrices = new Hashtable(); // Stores residue codes/names and colours and other things public static final int[] aaIndex; // aaHash version 2.1.1 and below @@ -36,11 +49,11 @@ public class ResidueProperties public static final int[] purinepyrimidineIndex; - public static final Hashtable aa3Hash = new Hashtable(); + public static final Map aa3Hash = new HashMap(); - public static final Hashtable aa2Triplet = new Hashtable(); + public static final Map aa2Triplet = new HashMap(); - public static final Hashtable nucleotideName = new Hashtable(); + public static final Map nucleotideName = new HashMap(); static { @@ -625,49 +638,51 @@ public class ResidueProperties public static final float[] pidThresholds = { 80, 60, 40, }; - public static Hashtable codonHash = new Hashtable(); + public static Map> codonHash = new HashMap>(); + + private static List Lys = new ArrayList(); - public static Vector Lys = new Vector(); + private static List Asn = new ArrayList(); - public static Vector Asn = new Vector(); + private static List Gln = new ArrayList(); - public static Vector Gln = new Vector(); + private static List His = new ArrayList(); - public static Vector His = new Vector(); + private static List Glu = new ArrayList(); - public static Vector Glu = new Vector(); + private static List Asp = new ArrayList(); - public static Vector Asp = new Vector(); + private static List Tyr = new ArrayList(); - public static Vector Tyr = new Vector(); + private static List Thr = new ArrayList(); - public static Vector Thr = new Vector(); + private static List Pro = new ArrayList(); - public static Vector Pro = new Vector(); + private static List Ala = new ArrayList(); - public static Vector Ala = new Vector(); + private static List Ser = new ArrayList(); - public static Vector Ser = new Vector(); + private static List Arg = new ArrayList(); - public static Vector Arg = new Vector(); + private static List Gly = new ArrayList(); - public static Vector Gly = new Vector(); + private static List Trp = new ArrayList(); - public static Vector Trp = new Vector(); + private static List Cys = new ArrayList(); - public static Vector Cys = new Vector(); + private static List Ile = new ArrayList(); - public static Vector Ile = new Vector(); + private static List Met = new ArrayList(); - public static Vector Met = new Vector(); + private static List Leu = new ArrayList(); - public static Vector Leu = new Vector(); + private static List Val = new ArrayList(); - public static Vector Val = new Vector(); + private static List Phe = new ArrayList(); - public static Vector Phe = new Vector(); + public static List STOP = new ArrayList(); - public static Vector STOP = new Vector(); + public static String START = "ATG"; static { @@ -695,121 +710,49 @@ public class ResidueProperties } /** - * Nucleotide Ambiguity Codes + * Nucleotide Ambiguity Codes */ - public static final Hashtable ambiguityCodes=new Hashtable(); + public static final Map ambiguityCodes = new Hashtable(); + /** - * Codon triplets with additional symbols for unambiguous codons that include ambiguity codes + * Codon triplets with additional symbols for unambiguous codons that include + * ambiguity codes */ - public static final Hashtable codonHash2 = new Hashtable(); - + public static final Hashtable codonHash2 = new Hashtable(); + /** * all ambiguity codes for a given base */ - public final static Hashtable> _ambiguityCodes = new Hashtable>(); - + public final static Hashtable> _ambiguityCodes = new Hashtable>(); static { - /** - * 3.2. Purine (adenine or guanine): R - * - * R is the symbol previously recommended [1]. + /* + * Ambiguity codes as per http://www.chem.qmul.ac.uk/iubmb/misc/naseq.html */ ambiguityCodes.put("R", new String[] { "A", "G" }); - - /** - * 3.3. Pyrimidine (thymine or cytosine): Y - * - * Y is the symbol previously recommended [1]. - */ ambiguityCodes.put("Y", new String[] { "T", "C" }); - /** - * 3.4. Adenine or thymine: W - * - * Although several diverse symbols have been used for this pair, (and for - * the reciprocal pair G+C), only two symbols have a rational basis, L and - * W: L derives from DNA density (light; G+C - heavy - would thus be H); W - * derives from the strength of the hydrogen bonding interaction between the - * base pairs (weak for A+T: G +C - strong - would thus be S). However, the - * system recommended for the three-base series (not-A = B, etc., see below, - * section 3.8) rules out H as this would be not-G. W is thus recommended. - */ ambiguityCodes.put("W", new String[] { "A", "T" }); - /** - * 3.5. Guanine or cytosine: S - * - * The choice of this symbol is discussed above in section 3.4. - */ ambiguityCodes.put("S", new String[] { "G", "C" }); - /** - * 3.6. Adenine or cytosine: M - * - * There are few common features between A and C. The presence of an NH2 - * group in similar positions on both bases (Fig. 1) makes possible a - * logically derived symbol. A and N being ruled out, M (from aMino) is - * recommended. - * - * - * Fig. 1. Origin of the symbols M and K The four bases are drawn so as to - * show the relationship between adenine and cytosine on the one hand, which - * both have aMino groups at the ring position most distant from the point - * of attachment to the sugar, and between guanine and thymine on the other, - * which both have Keto groups at the corresponding position. The ring atoms - * are numbered as recommended [24-26], although for the present purpose - * this has the disadvantage of giving discordant numbers to the - * corresponding positions. - */ ambiguityCodes.put("M", new String[] { "A", "C" }); - /** - * 3.7. Guanine or thymine: K By analogy with A and C (section 3.6), both G - * and T have Keto groups in similar positions (Fig. 1). - */ ambiguityCodes.put("K", new String[] { "G", "T" }); - /** - * 3.8. Adenine or thymine or cytosine: H - * - * Not-G is the most simple means of memorising this combination and symbols - * logically related to G were examined. F and H would both be suitable, as - * the letters before and after G in the alphabet, but A would have no - * equivalent to F. The use of H has historical precedence [2]. - */ ambiguityCodes.put("H", new String[] { "A", "T", "C" }); - /** - * 3.9. Guanine or cytosine or thymine: B - * - * Not-A as above (section 3.8). - */ ambiguityCodes.put("B", new String[] { "G", "T", "C" }); - /** - * 3.10. Guanine or adenine or cytosine: V - * - * Not-T by analogy with not-G (section 3.8) would be U but this is ruled - * out to eliminate confusion with uracil. V is the next logical choice. - * Note that T and U may in some cases be considered to be synonyms. - */ ambiguityCodes.put("V", new String[] { "G", "A", "C" }); - /** - * 3.11. Guanine or adenine or thymine: D - * - * Not-C as above (section 3.8). - */ ambiguityCodes.put("D", new String[] { "G", "A", "T" }); - /** - * 3.12. Guanine or adenine or thymine or cytosine: N - */ - ambiguityCodes.put("R", new String[] + ambiguityCodes.put("N", new String[] { "G", "A", "T", "C" }); + // Now build codon translation table codonHash2.put("AAA", "K"); codonHash2.put("AAG", "K"); @@ -892,10 +835,10 @@ public class ResidueProperties codonHash2.put("TTC", "F"); codonHash2.put("TTT", "F"); - + buildAmbiguityCodonSet(); } - + /** * programmatic generation of codons including ambiguity codes */ @@ -931,7 +874,10 @@ public class ResidueProperties } // and programmatically add in the ambiguity codes that yield the same amino // acid - String[] unambcodons = codonHash2.keySet().toArray(new String[codonHash2.size()]); + + + String[] unambcodons = codonHash2.keySet().toArray( + new String[codonHash2.size()]); for (String codon : unambcodons) { String residue = codonHash2.get(codon); @@ -966,7 +912,7 @@ public class ResidueProperties char _anuc; for (ipos = 0; ipos < tpos.length; ipos++) { - if (acodon[ipos].length==0 || tpos[ipos] < 0) + if (acodon[ipos].length == 0 || tpos[ipos] < 0) { _acodon += codon.charAt(ipos); allres[ipos] = new char[] @@ -998,7 +944,7 @@ public class ResidueProperties _codon += allres[j][cpos[j]]; } String tr = codonHash2.get(_codon); - if (valid = (tr!=null && tr.equals(residue))) + if (valid = (tr != null && tr.equals(residue))) { // advance to next combination ipos = acodon.length - 1; @@ -1012,14 +958,14 @@ public class ResidueProperties if (valid) { // Add this to the set of codons we will translate -// System.out.println("Adding ambiguity codon: " + _acodon + " for " -// + residue); + // System.out.println("Adding ambiguity codon: " + _acodon + " for " + // + residue); codonHash2.put(_acodon, residue); } else { -// System.err.println("Rejecting ambiguity codon: " + _acodon -// + " for " + residue); + // System.err.println("Rejecting ambiguity codon: " + _acodon + // + " for " + residue); } // next combination ipos = acodon.length - 1; @@ -1035,87 +981,87 @@ public class ResidueProperties static { - Lys.addElement("AAA"); - Lys.addElement("AAG"); - Asn.addElement("AAC"); - Asn.addElement("AAT"); - - Gln.addElement("CAA"); - Gln.addElement("CAG"); - His.addElement("CAC"); - His.addElement("CAT"); - - Glu.addElement("GAA"); - Glu.addElement("GAG"); - Asp.addElement("GAC"); - Asp.addElement("GAT"); - - Tyr.addElement("TAC"); - Tyr.addElement("TAT"); - - Thr.addElement("ACA"); - Thr.addElement("ACG"); - Thr.addElement("ACC"); - Thr.addElement("ACT"); - - Pro.addElement("CCA"); - Pro.addElement("CCG"); - Pro.addElement("CCC"); - Pro.addElement("CCT"); - - Ala.addElement("GCA"); - Ala.addElement("GCG"); - Ala.addElement("GCC"); - Ala.addElement("GCT"); - - Ser.addElement("TCA"); - Ser.addElement("TCG"); - Ser.addElement("TCC"); - Ser.addElement("TCT"); - Ser.addElement("AGC"); - Ser.addElement("AGT"); - - Arg.addElement("AGA"); - Arg.addElement("AGG"); - Arg.addElement("CGA"); - Arg.addElement("CGG"); - Arg.addElement("CGC"); - Arg.addElement("CGT"); - - Gly.addElement("GGA"); - Gly.addElement("GGG"); - Gly.addElement("GGC"); - Gly.addElement("GGT"); - - STOP.addElement("TGA"); - STOP.addElement("TAA"); - STOP.addElement("TAG"); - - Trp.addElement("TGG"); - - Cys.addElement("TGC"); - Cys.addElement("TGT"); - - Ile.addElement("ATA"); - Ile.addElement("ATC"); - Ile.addElement("ATT"); - - Met.addElement("ATG"); - - Leu.addElement("CTA"); - Leu.addElement("CTG"); - Leu.addElement("CTC"); - Leu.addElement("CTT"); - Leu.addElement("TTA"); - Leu.addElement("TTG"); - - Val.addElement("GTA"); - Val.addElement("GTG"); - Val.addElement("GTC"); - Val.addElement("GTT"); - - Phe.addElement("TTC"); - Phe.addElement("TTT"); + Lys.add("AAA"); + Lys.add("AAG"); + Asn.add("AAC"); + Asn.add("AAT"); + + Gln.add("CAA"); + Gln.add("CAG"); + His.add("CAC"); + His.add("CAT"); + + Glu.add("GAA"); + Glu.add("GAG"); + Asp.add("GAC"); + Asp.add("GAT"); + + Tyr.add("TAC"); + Tyr.add("TAT"); + + Thr.add("ACA"); + Thr.add("ACG"); + Thr.add("ACC"); + Thr.add("ACT"); + + Pro.add("CCA"); + Pro.add("CCG"); + Pro.add("CCC"); + Pro.add("CCT"); + + Ala.add("GCA"); + Ala.add("GCG"); + Ala.add("GCC"); + Ala.add("GCT"); + + Ser.add("TCA"); + Ser.add("TCG"); + Ser.add("TCC"); + Ser.add("TCT"); + Ser.add("AGC"); + Ser.add("AGT"); + + Arg.add("AGA"); + Arg.add("AGG"); + Arg.add("CGA"); + Arg.add("CGG"); + Arg.add("CGC"); + Arg.add("CGT"); + + Gly.add("GGA"); + Gly.add("GGG"); + Gly.add("GGC"); + Gly.add("GGT"); + + STOP.add("TGA"); + STOP.add("TAA"); + STOP.add("TAG"); + + Trp.add("TGG"); + + Cys.add("TGC"); + Cys.add("TGT"); + + Ile.add("ATA"); + Ile.add("ATC"); + Ile.add("ATT"); + + Met.add("ATG"); + + Leu.add("CTA"); + Leu.add("CTG"); + Leu.add("CTC"); + Leu.add("CTT"); + Leu.add("TTA"); + Leu.add("TTG"); + + Val.add("GTA"); + Val.add("GTG"); + Val.add("GTC"); + Val.add("GTT"); + + Phe.add("TTC"); + Phe.add("TTT"); } // Stores residue codes/names and colours and other things @@ -1420,50 +1366,77 @@ public class ResidueProperties } static { - int[][] propMatrixF = new int[maxProteinIndex][maxProteinIndex], - propMatrixPos = new int[maxProteinIndex][maxProteinIndex], - propMatrixEpos = new int[maxProteinIndex][maxProteinIndex]; - for (int i=0;ii) { - ic+=aa[i]; + int maxF = 0, maxP = 0, maxEP = 0; + String ic = ""; + if (aa.length > i) + { + ic += aa[i]; + } + else + { + ic = "-"; } - else {ic = "-";} - propMatrixF[i][i]=propHash.size(); - propMatrixPos[i][i]=propHash.size(); - propMatrixEpos[i][i]=propHash.size(); - for (int j=i+1;jj) { - jc+=aa[j]; + String jc = ""; + if (aa.length > j) + { + jc += aa[j]; } - else {jc = "-";} - propMatrixF[i][j]=0; - propMatrixPos[i][j]=0; - propMatrixEpos[i][j]=0; - for (Enumeration en= (Enumeration)propHash.keys(); en.hasMoreElements(); ) + else + { + jc = "-"; + } + propMatrixF[i][j] = 0; + propMatrixPos[i][j] = 0; + propMatrixEpos[i][j] = 0; + for (Enumeration en = propHash.keys(); en + .hasMoreElements();) { String ph = en.nextElement(); - Map pph=(Map)propHash.get(ph); - if (pph.get(ic)!=null && pph.get(jc)!=null) { - int icp=pph.get(ic).intValue(),jcp=pph.get(jc).intValue(); - - propMatrixPos[i][j] += icp == jcp ? icp : -1; - propMatrixPos[j][i] += icp == jcp ? icp : -1; - propMatrixF[i][j] += icp == jcp ? 2 : -1; - propMatrixF[j][i] += icp == jcp ? 2 : -1; - propMatrixEpos[i][j] += icp == jcp ? (1+icp * 2) : -1; - propMatrixEpos[j][i] += icp == jcp ? (1+icp * 2) : -1; - }} + Map pph = (Map) propHash + .get(ph); + if (pph.get(ic) != null && pph.get(jc) != null) + { + int icp = pph.get(ic).intValue(), jcp = pph.get(jc).intValue(); + // Still working on these definitions. + propMatrixPos[i][j] += icp == jcp && icp > 0 ? 2 : 0; + propMatrixPos[j][i] += icp == jcp && icp > 0 ? 2 : 0; + propMatrixF[i][j] += icp == jcp ? 2 : 0; + propMatrixF[j][i] += icp == jcp ? 2 : 0; + propMatrixEpos[i][j] += icp == jcp ? (1 + icp * 2) : 0; + propMatrixEpos[j][i] += icp == jcp ? (1 + icp * 2) : 0; + } + } + if (maxF < propMatrixF[i][j]) + { + maxF = propMatrixF[i][j]; + } + if (maxP < propMatrixPos[i][j]) + { + maxP = propMatrixPos[i][j]; + } + if (maxEP < propMatrixEpos[i][j]) + { + maxEP = propMatrixEpos[i][j]; + } } + propMatrixF[i][i] = maxF; + propMatrixPos[i][i] = maxP; + propMatrixEpos[i][i] = maxEP; } - - scoreMatrices.put("Conservation Pos", new ScoreMatrix("Conservation Pos",propMatrixF,0)); - scoreMatrices.put("Conservation Both", new ScoreMatrix("Conservation Both",propMatrixPos,0)); - scoreMatrices.put("Conservation EnhPos", new ScoreMatrix("Conservation EnhPos",propMatrixEpos,0)); + // JAL-1512 comment out physicochemical score matrices for 2.8.1 release + // scoreMatrices.put("Conservation Pos", new + // ScoreMatrix("Conservation Pos",propMatrixPos,0)); + // scoreMatrices.put("Conservation Both", new + // ScoreMatrix("Conservation Both",propMatrixF,0)); + // scoreMatrices.put("Conservation EnhPos", new + // ScoreMatrix("Conservation EnhPos",propMatrixEpos,0)); scoreMatrices.put("PID", new PIDScoreModel()); + scoreMatrices.put("Displayed Features", new FeatureScoreModel()); } private ResidueProperties() @@ -1485,7 +1458,7 @@ public class ResidueProperties return hyd; } - public static Hashtable getAA3Hash() + public static Map getAA3Hash() { return aa3Hash; } @@ -1540,12 +1513,13 @@ public class ResidueProperties return _codonTranslate(lccodon); } String cdn = codonHash2.get(lccodon.toUpperCase()); - if (cdn!=null && cdn.equals("*")) + if (cdn != null && cdn.equals("*")) { return "STOP"; } return cdn; } + public static String _codonTranslate(String lccodon) { String codon = lccodon.toUpperCase(); @@ -1554,14 +1528,9 @@ public class ResidueProperties { return "X"; } - Enumeration e = codonHash.keys(); - - while (e.hasMoreElements()) + for (String key : codonHash.keySet()) { - String key = (String) e.nextElement(); - Vector tmp = (Vector) codonHash.get(key); - - if (tmp.contains(codon)) + if (codonHash.get(key).contains(codon)) { return key; } @@ -1595,6 +1564,7 @@ public class ResidueProperties } return null; } + /** * get a ScoreModel based on its string name * @@ -1663,12 +1633,81 @@ public class ResidueProperties * Used by getRNASecStrucState * */ - public static Hashtable toRNAssState; + public static Hashtable toRNAssState; + + public static boolean RNAcloseParen[] = new boolean[255]; static { - toRNAssState = new Hashtable(); - toRNAssState.put(")", "S"); - toRNAssState.put("(", "S"); + toRNAssState = new Hashtable(); + toRNAssState.put(")", "("); + toRNAssState.put("(", "("); + toRNAssState.put("]", "["); + toRNAssState.put("[", "["); + toRNAssState.put("{", "{"); + toRNAssState.put("}", "{"); + toRNAssState.put(">", ">"); + toRNAssState.put("<", ">"); + toRNAssState.put("A", "A"); + toRNAssState.put("a", "A"); + toRNAssState.put("B", "B"); + toRNAssState.put("b", "B"); + toRNAssState.put("C", "C"); + toRNAssState.put("c", "C"); + toRNAssState.put("D", "D"); + toRNAssState.put("d", "D"); + toRNAssState.put("E", "E"); + toRNAssState.put("e", "E"); + toRNAssState.put("F", "F"); + toRNAssState.put("f", "F"); + toRNAssState.put("G", "G"); + toRNAssState.put("g", "G"); + toRNAssState.put("H", "H"); + toRNAssState.put("h", "H"); + toRNAssState.put("I", "I"); + toRNAssState.put("i", "I"); + toRNAssState.put("J", "J"); + toRNAssState.put("j", "J"); + toRNAssState.put("K", "K"); + toRNAssState.put("k", "K"); + toRNAssState.put("L", "L"); + toRNAssState.put("l", "L"); + toRNAssState.put("M", "M"); + toRNAssState.put("m", "M"); + toRNAssState.put("N", "N"); + toRNAssState.put("n", "N"); + toRNAssState.put("O", "O"); + toRNAssState.put("o", "O"); + toRNAssState.put("P", "P"); + toRNAssState.put("p", "P"); + toRNAssState.put("Q", "Q"); + toRNAssState.put("q", "Q"); + toRNAssState.put("R", "R"); + toRNAssState.put("r", "R"); + toRNAssState.put("S", "S"); + toRNAssState.put("s", "S"); + toRNAssState.put("T", "T"); + toRNAssState.put("t", "T"); + toRNAssState.put("U", "U"); + toRNAssState.put("u", "U"); + toRNAssState.put("V", "V"); + toRNAssState.put("v", "V"); + toRNAssState.put("W", "W"); + toRNAssState.put("w", "W"); + toRNAssState.put("X", "X"); + toRNAssState.put("x", "X"); + toRNAssState.put("Y", "Y"); + toRNAssState.put("y", "Y"); + toRNAssState.put("Z", "Z"); + toRNAssState.put("z", "Z"); + for (int p = 0; p < RNAcloseParen.length; p++) + { + RNAcloseParen[p] = false; + } + for (String k : toRNAssState.keySet()) + { + RNAcloseParen[k.charAt(0)] = k.charAt(0) != toRNAssState.get(k) + .charAt(0); + } } /** @@ -1689,7 +1728,8 @@ public class ResidueProperties String ssc = ssstring.substring(i, i + 1); if (toRNAssState.containsKey(ssc)) { - ss.append((String) toRNAssState.get(ssc)); + // valid ss character - so return it + ss.append(ssc); // (String) toRNAssState.get(ssc)); } else { @@ -1699,8 +1739,19 @@ public class ResidueProperties return ss.toString(); } + public static boolean isCloseParenRNA(char dc) + { + return RNAcloseParen[dc]; + } + // main method generates perl representation of residue property hash // / cut here + + /** + * @j2sIgnore + * + * @param args + */ public static void main(String[] args) { Hashtable aa = new Hashtable(); @@ -1748,4 +1799,53 @@ public class ResidueProperties System.out.println("};"); } // to here + + /** + * Returns a list of residue characters for the specified inputs + * + * @param nucleotide + * @param includeAmbiguous + * @return + */ + public static List getResidues(boolean nucleotide, + boolean includeAmbiguous) + { + List result = new ArrayList(); + if (nucleotide) + { + for (String nuc : nucleotideName.keySet()) + { + int val = nucleotideIndex[nuc.charAt(0)]; + if ((!includeAmbiguous && val > 4) || (val >= maxNucleotideIndex)) + { + continue; + } + nuc = nuc.toUpperCase(); + if (!result.contains(nuc)) + { + result.add(nuc); + } + } + } else { + /* + * Peptide + */ + for (String res : aa3Hash.keySet()) + { + int index = aa3Hash.get(res).intValue(); + if ((!includeAmbiguous && index >= 20) || index >= maxProteinIndex) + { + continue; + } + res = res.toUpperCase(); + if (!result.contains(res)) + { + result.add(res); + } + } + } + + return result; + } + }