formatting
[jalview.git] / src / jalview / analysis / StructureFrequency.java
index c15dba4..33a08e6 100644 (file)
@@ -1,18 +1,18 @@
 /*
  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.7)
  * Copyright (C) 2011 J Procter, AM Waterhouse, J Engelhardt, LM Lui, G Barton, M Clamp, S Searle
- * 
+ *
  * 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 
+ * 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.
- * 
- * 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 
+ *
+ * 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/>.
  */
 
@@ -122,40 +122,40 @@ public class StructureFrequency
       }
       else
       {
-        for (j = 0; j < jSize; j++) // foreach row
+        bpEnd = findPair(rna, i);
+        if (bpEnd > -1)
         {
-          if (sequences[j] == null)
+          for (j = 0; j < jSize; j++) // foreach row
           {
-            System.err
-                    .println("WARNING: Consensus skipping null sequence - possible race condition.");
-            continue;
-          }
-          seq = sequences[j].getSequence();
-
-          if (seq.length > i)
-          {
-            c = seq[i];
-
-            // standard representation for gaps in sequence and structure
-            if (c == '.' || c == ' ')
-            {
-              c = '-';
-            }
-
-            if (c == '-')
+            if (sequences[j] == null)
             {
-              values['-']++;
+              System.err
+                      .println("WARNING: Consensus skipping null sequence - possible race condition.");
               continue;
             }
-            bpEnd = findPair(rna, i);
-            cEnd = seq[bpEnd];
-            if (checkBpType(c, cEnd))
+            c = sequences[j].getCharAt(i);
             {
-              values['(']++; // H means it's a helix (structured)
-            }
-            pairs[c][cEnd]++;
 
-            maxResidue = "(";
+              // standard representation for gaps in sequence and structure
+              if (c == '.' || c == ' ')
+              {
+                c = '-';
+              }
+
+              if (c == '-')
+              {
+                values['-']++;
+                continue;
+              }
+              cEnd = sequences[j].getCharAt(bpEnd);
+              if (checkBpType(c, cEnd))
+              {
+                values['(']++; // H means it's a helix (structured)
+              }
+              pairs[c][cEnd]++;
+
+              maxResidue = "(";
+            }
           }
         }
         // nonGap++;
@@ -175,7 +175,7 @@ public class StructureFrequency
       residueHash.put(MAXCOUNT, new Integer(count));
       residueHash.put(MAXRESIDUE, maxResidue);
 
-      percentage = ((float) count * 100) / (float) jSize;
+      percentage = ((float) count * 100) / jSize;
       residueHash.put(PID_GAPS, new Float(percentage));
 
       // percentage = ((float) count * 100) / (float) nongap;
@@ -204,7 +204,7 @@ public class StructureFrequency
         residueHash.put(MAXCOUNT, new Integer(count));
         residueHash.put(MAXRESIDUE, maxResidue);
 
-        percentage = ((float) count * 100) / (float) jSize;
+        percentage = ((float) count * 100) / jSize;
         residueHash.put(PID_GAPS, new Float(percentage));
 
         result[bpEnd] = residueHash;
@@ -310,7 +310,8 @@ public class StructureFrequency
     }
     for (int i = iStart; i < width; i++)
     {
-      if (i >= hconsensus.length)
+      Hashtable hci;
+      if (i >= hconsensus.length || ((hci = hconsensus[i]) == null))
       {
         // happens if sequences calculated over were shorter than alignment
         // width
@@ -318,30 +319,31 @@ public class StructureFrequency
         continue;
       }
       value = 0;
+      Float fv;
       if (ignoreGapsInConsensusCalculation)
       {
-        value = ((Float) hconsensus[i].get(StructureFrequency.PID_NOGAPS))
-                .floatValue();
+        fv = (Float) hci.get(StructureFrequency.PID_NOGAPS);
       }
       else
       {
-        value = ((Float) hconsensus[i].get(StructureFrequency.PID_GAPS))
-                .floatValue();
+        fv = (Float) hci.get(StructureFrequency.PID_GAPS);
       }
-
-      String maxRes = hconsensus[i].get(StructureFrequency.MAXRESIDUE)
-              .toString();
-      String mouseOver = hconsensus[i].get(StructureFrequency.MAXRESIDUE)
-              + " ";
+      if (fv == null)
+      {
+        consensus.annotations[i] = null;
+        // data has changed below us .. give up and
+        continue;
+      }
+      value = fv.floatValue();
+      String maxRes = hci.get(StructureFrequency.MAXRESIDUE).toString();
+      String mouseOver = hci.get(StructureFrequency.MAXRESIDUE) + " ";
       if (maxRes.length() > 1)
       {
         mouseOver = "[" + maxRes + "] ";
         maxRes = "+";
       }
-      int[][] profile = (int[][]) hconsensus[i]
-              .get(StructureFrequency.PROFILE);
-      int[][] pairs = (int[][]) hconsensus[i]
-              .get(StructureFrequency.PAIRPROFILE);
+      int[][] profile = (int[][]) hci.get(StructureFrequency.PROFILE);
+      int[][] pairs = (int[][]) hci.get(StructureFrequency.PAIRPROFILE);
 
       if (pairs != null && includeAllConsSymbols) // Just responsible for the
       // tooltip
@@ -349,7 +351,9 @@ public class StructureFrequency
       {
         mouseOver = "";
 
-        /* TODO It's not sure what is the purpose of the alphabet and wheter it is useful for structure?
+        /*
+         * TODO It's not sure what is the purpose of the alphabet and wheter it
+         * is useful for structure?
          * 
          * if (alphabet != null) { for (int c = 0; c < alphabet.length; c++) {
          * tval = ((float) profile[0][alphabet[c]]) 100f / (float)
@@ -366,7 +370,7 @@ public class StructureFrequency
           {
             ca[x] = new int[]
             { c, d };
-            vl[x] = (float) pairs[c][d];
+            vl[x] = pairs[c][d];
             x++;
           }
         }
@@ -377,7 +381,7 @@ public class StructureFrequency
         {
           if (vl[c] > 0)
           {
-            tval = ((float) vl[c] * 100f / (float) profile[1][ignoreGapsInConsensusCalculation ? 1
+            tval = (vl[c] * 100f / profile[1][ignoreGapsInConsensusCalculation ? 1
                     : 0]);
             mouseOver += ((p == 0) ? "" : "; ") + (char) ((int[]) ca[c])[0]
                     + (char) ((int[]) ca[c])[1] + " " + ((int) tval) + "%";
@@ -406,7 +410,7 @@ public class StructureFrequency
   public static int[] extractProfile(Hashtable hconsensus,
           boolean ignoreGapsInConsensusCalculation)
   {
-    int[] rtnval = new int[51]; // 2*(5*5)+1
+    int[] rtnval = new int[74]; // 2*(5*5)+2
     int[][] profile = (int[][]) hconsensus.get(StructureFrequency.PROFILE);
     int[][] pairs = (int[][]) hconsensus
             .get(StructureFrequency.PAIRPROFILE);
@@ -424,21 +428,23 @@ public class StructureFrequency
       {
         ca[x] = new int[]
         { c, d };
-        vl[x] = (float) pairs[c][d];
+        vl[x] = pairs[c][d];
         x++;
       }
     }
     jalview.util.QuickSort.sort(vl, ca);
 
-    rtnval[0] = 1;
+    rtnval[0] = 2;
+    rtnval[1] = 0;
     for (int c = 624; c > 0; c--)
     {
       if (vl[c] > 0)
       {
         rtnval[rtnval[0]++] = ((int[]) ca[c])[0];
         rtnval[rtnval[0]++] = ((int[]) ca[c])[1];
-        rtnval[rtnval[0]++] = (int) ((float) vl[c] * 100f / (float) profile[1][ignoreGapsInConsensusCalculation ? 1
+        rtnval[rtnval[0]] = (int) (vl[c] * 100f / profile[1][ignoreGapsInConsensusCalculation ? 1
                 : 0]);
+        rtnval[1] += rtnval[rtnval[0]++];
       }
     }