X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fschemes%2FResidueProperties.java;h=662a77e4ba0bf1c49d88f558fa14f81bbb533e24;hb=a8aec438cd92c74061c89487b2431a52bb0c2799;hp=fa4260ff37dcec6dc257f3e74de7b1d38f85bb2a;hpb=59d682209891099d46b960509907c79e3fb276fe;p=jalview.git

diff --git a/src/jalview/schemes/ResidueProperties.java b/src/jalview/schemes/ResidueProperties.java
index fa4260f..662a77e 100755
--- a/src/jalview/schemes/ResidueProperties.java
+++ b/src/jalview/schemes/ResidueProperties.java
@@ -1,29 +1,41 @@
 /*
- * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8)
- * Copyright (C) 2012 J Procter, AM Waterhouse, LM Lui, J Engelhardt, G Barton, M Clamp, S Searle
+ * 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 <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU General Public License
+ * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
+ * The Jalview Authors are detailed in the 'AUTHORS' file.
  */
 package jalview.schemes;
 
-import java.util.*;
+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 java.awt.*;
+import jalview.analysis.scoremodels.FeatureScoreModel;
+import jalview.analysis.scoremodels.PIDScoreModel;
+import jalview.api.analysis.ScoreModelI;
 
 public class ResidueProperties
 {
-  public static Hashtable scoreMatrices = new Hashtable();
+  public static Hashtable<String, ScoreModelI> scoreMatrices = new Hashtable();
 
   // Stores residue codes/names and colours and other things
   public static final int[] aaIndex; // aaHash version 2.1.1 and below
@@ -32,11 +44,11 @@ public class ResidueProperties
 
   public static final int[] purinepyrimidineIndex;
 
-  public static final Hashtable aa3Hash = new Hashtable();
+  public static final Map<String, Integer> aa3Hash = new HashMap<String, Integer>();
 
-  public static final Hashtable aa2Triplet = new Hashtable();
+  public static final Map<String, String> aa2Triplet = new HashMap<String, String>();
 
-  public static final Hashtable nucleotideName = new Hashtable();
+  public static final Map<String, String> nucleotideName = new HashMap<String, String>();
 
   static
   {
@@ -621,49 +633,51 @@ public class ResidueProperties
   public static final float[] pidThresholds =
   { 80, 60, 40, };
 
-  public static Hashtable codonHash = new Hashtable();
+  public static Map<String, List<String>> codonHash = new HashMap<String, List<String>>();
 
-  public static Vector Lys = new Vector();
+  private static List<String> Lys = new ArrayList<String>();
 
-  public static Vector Asn = new Vector();
+  private static List<String> Asn = new ArrayList<String>();
 
-  public static Vector Gln = new Vector();
+  private static List<String> Gln = new ArrayList<String>();
 
-  public static Vector His = new Vector();
+  private static List<String> His = new ArrayList<String>();
 
-  public static Vector Glu = new Vector();
+  private static List<String> Glu = new ArrayList<String>();
 
-  public static Vector Asp = new Vector();
+  private static List<String> Asp = new ArrayList<String>();
 
-  public static Vector Tyr = new Vector();
+  private static List<String> Tyr = new ArrayList<String>();
 
-  public static Vector Thr = new Vector();
+  private static List<String> Thr = new ArrayList<String>();
 
-  public static Vector Pro = new Vector();
+  private static List<String> Pro = new ArrayList<String>();
 
-  public static Vector Ala = new Vector();
+  private static List<String> Ala = new ArrayList<String>();
 
-  public static Vector Ser = new Vector();
+  private static List<String> Ser = new ArrayList<String>();
 
-  public static Vector Arg = new Vector();
+  private static List<String> Arg = new ArrayList<String>();
 
-  public static Vector Gly = new Vector();
+  private static List<String> Gly = new ArrayList<String>();
 
-  public static Vector Trp = new Vector();
+  private static List<String> Trp = new ArrayList<String>();
 
-  public static Vector Cys = new Vector();
+  private static List<String> Cys = new ArrayList<String>();
 
-  public static Vector Ile = new Vector();
+  private static List<String> Ile = new ArrayList<String>();
 
-  public static Vector Met = new Vector();
+  private static List<String> Met = new ArrayList<String>();
 
-  public static Vector Leu = new Vector();
+  private static List<String> Leu = new ArrayList<String>();
 
-  public static Vector Val = new Vector();
+  private static List<String> Val = new ArrayList<String>();
 
-  public static Vector Phe = new Vector();
+  private static List<String> Phe = new ArrayList<String>();
 
-  public static Vector STOP = new Vector();
+  public static List<String> STOP = new ArrayList<String>();
+
+  public static String START = "ATG";
 
   static
   {
@@ -690,22 +704,63 @@ public class ResidueProperties
     codonHash.put("STOP", STOP);
   }
 
-  public static Hashtable codonHash2 = new Hashtable();
+  /**
+   * Nucleotide Ambiguity Codes
+   */
+  public static final Map<String, String[]> ambiguityCodes = new Hashtable<String, String[]>();
+
+  /**
+   * Codon triplets with additional symbols for unambiguous codons that include
+   * ambiguity codes
+   */
+  public static final Hashtable<String, String> codonHash2 = new Hashtable<String, String>();
+
+  /**
+   * all ambiguity codes for a given base
+   */
+  public final static Hashtable<String, List<String>> _ambiguityCodes = new Hashtable<String, List<String>>();
 
   static
   {
+    /*
+     * Ambiguity codes as per http://www.chem.qmul.ac.uk/iubmb/misc/naseq.html
+     */
+    ambiguityCodes.put("R", new String[]
+    { "A", "G" });
+    ambiguityCodes.put("Y", new String[]
+    { "T", "C" });
+    ambiguityCodes.put("W", new String[]
+    { "A", "T" });
+    ambiguityCodes.put("S", new String[]
+    { "G", "C" });
+    ambiguityCodes.put("M", new String[]
+    { "A", "C" });
+    ambiguityCodes.put("K", new String[]
+    { "G", "T" });
+    ambiguityCodes.put("H", new String[]
+    { "A", "T", "C" });
+    ambiguityCodes.put("B", new String[]
+    { "G", "T", "C" });
+    ambiguityCodes.put("V", new String[]
+    { "G", "A", "C" });
+    ambiguityCodes.put("D", new String[]
+    { "G", "A", "T" });
+    ambiguityCodes.put("N", new String[]
+    { "G", "A", "T", "C" });
+
+    // Now build codon translation table
     codonHash2.put("AAA", "K");
     codonHash2.put("AAG", "K");
     codonHash2.put("AAC", "N");
     codonHash2.put("AAT", "N");
 
-    codonHash2.put("CAA", "E");
-    codonHash2.put("CAG", "E");
+    codonHash2.put("CAA", "Q");
+    codonHash2.put("CAG", "Q");
     codonHash2.put("CAC", "H");
     codonHash2.put("CAT", "H");
 
-    codonHash2.put("GAA", "Q");
-    codonHash2.put("GAG", "Q");
+    codonHash2.put("GAA", "E");
+    codonHash2.put("GAG", "E");
     codonHash2.put("GAC", "D");
     codonHash2.put("GAT", "D");
 
@@ -713,9 +768,9 @@ public class ResidueProperties
     codonHash2.put("TAT", "Y");
 
     codonHash2.put("ACA", "T");
-    codonHash2.put("AAG", "T");
     codonHash2.put("ACC", "T");
     codonHash2.put("ACT", "T");
+    codonHash2.put("ACG", "T");
 
     codonHash2.put("CCA", "P");
     codonHash2.put("CCG", "P");
@@ -775,91 +830,231 @@ public class ResidueProperties
 
     codonHash2.put("TTC", "F");
     codonHash2.put("TTT", "F");
+
+    buildAmbiguityCodonSet();
+  }
+
+  /**
+   * programmatic generation of codons including ambiguity codes
+   */
+  public static void buildAmbiguityCodonSet()
+  {
+    if (_ambiguityCodes.size() > 0)
+    {
+      System.err
+              .println("Ignoring multiple calls to buildAmbiguityCodonSet");
+      return;
+    }
+    // Invert the ambiguity code set
+    for (Map.Entry<String, String[]> acode : ambiguityCodes.entrySet())
+    {
+      for (String r : acode.getValue())
+      {
+        List<String> codesfor = _ambiguityCodes.get(r);
+        if (codesfor == null)
+        {
+          _ambiguityCodes.put(r, codesfor = new ArrayList<String>());
+        }
+        if (!codesfor.contains(acode.getKey()))
+        {
+          codesfor.add(acode.getKey());
+        }
+        else
+        {
+          System.err
+                  .println("Inconsistency in the IUBMB ambiguity code nomenclature table: collision for "
+                          + acode.getKey() + " in residue " + r);
+        }
+      }
+    }
+    // and programmatically add in the ambiguity codes that yield the same amino
+    // acid
+    String[] unambcodons = codonHash2.keySet().toArray(
+            new String[codonHash2.size()]);
+    for (String codon : unambcodons)
+    {
+      String residue = codonHash2.get(codon);
+      String acodon[][] = new String[codon.length()][];
+      for (int i = 0, iSize = codon.length(); i < iSize; i++)
+      {
+        String _ac = "" + codon.charAt(i);
+        List<String> acodes = _ambiguityCodes.get(_ac);
+        if (acodes != null)
+        {
+          acodon[i] = acodes.toArray(new String[acodes.size()]);
+        }
+        else
+        {
+          acodon[i] = new String[]
+          {};
+        }
+      }
+      // enumerate all combinations and test for veracity of translation
+      int tpos[] = new int[codon.length()], cpos[] = new int[codon.length()];
+      for (int i = 0; i < tpos.length; i++)
+      {
+        tpos[i] = -1;
+      }
+      tpos[acodon.length - 1] = 0;
+      int ipos, j;
+      while (tpos[0] < acodon[0].length)
+      {
+        // make all codons for this combination
+        char allres[][] = new char[tpos.length][];
+        String _acodon = "";
+        char _anuc;
+        for (ipos = 0; ipos < tpos.length; ipos++)
+        {
+          if (acodon[ipos].length == 0 || tpos[ipos] < 0)
+          {
+            _acodon += codon.charAt(ipos);
+            allres[ipos] = new char[]
+            { codon.charAt(ipos) };
+          }
+          else
+          {
+            _acodon += acodon[ipos][tpos[ipos]];
+            String[] altbase = ambiguityCodes.get(acodon[ipos][tpos[ipos]]);
+            allres[ipos] = new char[altbase.length];
+            j = 0;
+            for (String ab : altbase)
+            {
+              allres[ipos][j++] = ab.charAt(0);
+            }
+          }
+        }
+        // test all codons for this combination
+        for (ipos = 0; ipos < cpos.length; ipos++)
+        {
+          cpos[ipos] = 0;
+        }
+        boolean valid = true;
+        do
+        {
+          String _codon = "";
+          for (j = 0; j < cpos.length; j++)
+          {
+            _codon += allres[j][cpos[j]];
+          }
+          String tr = codonHash2.get(_codon);
+          if (valid = (tr != null && tr.equals(residue)))
+          {
+            // advance to next combination
+            ipos = acodon.length - 1;
+            while (++cpos[ipos] >= allres[ipos].length && ipos > 0)
+            {
+              cpos[ipos] = 0;
+              ipos--;
+            }
+          }
+        } while (valid && cpos[0] < allres[0].length);
+        if (valid)
+        {
+          // Add this to the set of codons we will translate
+          // System.out.println("Adding ambiguity codon: " + _acodon + " for "
+          // + residue);
+          codonHash2.put(_acodon, residue);
+        }
+        else
+        {
+          // System.err.println("Rejecting ambiguity codon: " + _acodon
+          // + " for " + residue);
+        }
+        // next combination
+        ipos = acodon.length - 1;
+        while (++tpos[ipos] >= acodon[ipos].length && ipos > 0)
+        {
+          tpos[ipos] = -1;
+          ipos--;
+        }
+      }
+    }
+
   }
 
   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
@@ -1162,6 +1357,80 @@ public class ResidueProperties
     propHash.put("proline", proline);
     propHash.put("polar", polar);
   }
+  static
+  {
+    int[][] propMatrixF = new int[maxProteinIndex][maxProteinIndex], propMatrixPos = new int[maxProteinIndex][maxProteinIndex], propMatrixEpos = new int[maxProteinIndex][maxProteinIndex];
+    for (int i = 0; i < maxProteinIndex; i++)
+    {
+      int maxF = 0, maxP = 0, maxEP = 0;
+      String ic = "";
+      if (aa.length > i)
+      {
+        ic += aa[i];
+      }
+      else
+      {
+        ic = "-";
+      }
+      for (int j = i + 1; j < maxProteinIndex; 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<String> en = propHash.keys(); en
+                .hasMoreElements();)
+        {
+          String ph = en.nextElement();
+          Map<String, Integer> pph = (Map<String, Integer>) 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;
+    }
+    // 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()
   {
@@ -1182,7 +1451,7 @@ public class ResidueProperties
     return hyd;
   }
 
-  public static Hashtable getAA3Hash()
+  public static Map<String, Integer> getAA3Hash()
   {
     return aa3Hash;
   }
@@ -1232,20 +1501,29 @@ public class ResidueProperties
 
   public static String codonTranslate(String lccodon)
   {
+    if (false)
+    {
+      return _codonTranslate(lccodon);
+    }
+    String cdn = codonHash2.get(lccodon.toUpperCase());
+    if (cdn != null && cdn.equals("*"))
+    {
+      return "STOP";
+    }
+    return cdn;
+  }
+
+  public static String _codonTranslate(String lccodon)
+  {
     String codon = lccodon.toUpperCase();
     // all base ambiguity codes yield an 'X' amino acid residue
     if (codon.indexOf('X') > -1 || codon.indexOf('N') > -1)
     {
       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;
       }
@@ -1273,13 +1551,24 @@ public class ResidueProperties
   public static ScoreMatrix getScoreMatrix(String pwtype)
   {
     Object val = scoreMatrices.get(pwtype);
-    if (val != null)
+    if (val != null && val instanceof ScoreMatrix)
     {
       return (ScoreMatrix) val;
     }
     return null;
   }
 
+  /**
+   * get a ScoreModel based on its string name
+   * 
+   * @param pwtype
+   * @return scoremodel of type pwtype or null
+   */
+  public static ScoreModelI getScoreModel(String pwtype)
+  {
+    return scoreMatrices.get(pwtype);
+  }
+
   public static int getPAM250(char c, char d)
   {
     int a = aaIndex[c];
@@ -1337,12 +1626,81 @@ public class ResidueProperties
    * Used by getRNASecStrucState
    * 
    */
-  public static Hashtable toRNAssState;
+  public static Hashtable<String, String> toRNAssState;
+
+  public static boolean RNAcloseParen[] = new boolean[255];
   static
   {
-    toRNAssState = new Hashtable();
-    toRNAssState.put(")", "S");
-    toRNAssState.put("(", "S");
+    toRNAssState = new Hashtable<String, String>();
+    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);
+    }
   }
 
   /**
@@ -1363,7 +1721,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
       {
@@ -1373,6 +1732,11 @@ 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
   public static void main(String[] args)
@@ -1422,4 +1786,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<String> getResidues(boolean nucleotide,
+          boolean includeAmbiguous)
+  {
+    List<String> result = new ArrayList<String>();
+    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;
+  }
+
 }