/**
* Calculates conservation values for a given set of sequences
- *
+ *
* @author $author$
* @version $Revision$
*/
public class Conservation
{
SequenceI[] sequences;
+
int start;
+
int end;
+
Vector seqNums; // vector of int vectors where first is sequence checksum
- int maxLength = 0; // used by quality calcs
+
+ int maxLength = 0; // used by quality calcs
+
boolean seqNumsChanged = false; // updated after any change via calcSeqNum;
+
Hashtable[] total;
+ boolean canonicaliseAa = true; // if true then conservation calculation will
+ // map all symbols to canonical aa numbering
+ // rather than consider conservation of that
+ // symbol
+
/** Stores calculated quality values */
public Vector quality;
- /** Stores maximum and minimum values of quality values */
+ /** Stores maximum and minimum values of quality values */
public Double[] qualityRange = new Double[2];
+
String consString = "";
+
Sequence consSequence;
+
Hashtable propHash;
+
int threshold;
+
String name = "";
+
int[][] cons2;
/**
* Creates a new Conservation object.
- *
- * @param name Name of conservation
- * @param propHash DOCUMENT ME!
- * @param threshold to count the residues in residueHash(). commonly used value is 3
- * @param sequences sequences to be used in calculation
- * @param start start residue position
- * @param end end residue position
+ *
+ * @param name
+ * Name of conservation
+ * @param propHash
+ * hash of properties for each symbol
+ * @param threshold
+ * to count the residues in residueHash(). commonly used value
+ * is 3
+ * @param sequences
+ * sequences to be used in calculation
+ * @param start
+ * start residue position
+ * @param end
+ * end residue position
*/
public Conservation(String name, Hashtable propHash, int threshold,
- Vector sequences, int start, int end)
+ Vector sequences, int start, int end)
{
this.name = name;
this.start = start;
this.end = end;
- maxLength = end - start + 1; // default width includes bounds of calculation
+ maxLength = end - start + 1; // default width includes bounds of
+ // calculation
int s, sSize = sequences.size();
SequenceI[] sarray = new SequenceI[sSize];
}
/**
- * DOCUMENT ME!
- *
- * @param i DOCUMENT ME!
+ * Translate sequence i into a numerical
+ * representation and store it in the i'th position of the seqNums array.
+ *
+ * @param i
*/
private void calcSeqNum(int i)
{
int sSize = sequences.length;
- if ( (i > -1) && (i < sSize))
+ if ((i > -1) && (i < sSize))
{
sq = sequences[i].getSequenceAsString();
seqNums.addElement(new int[sq.length() + 1]);
}
- if (sq.hashCode() != ( (int[]) seqNums.elementAt(i))[0])
+ if (sq.hashCode() != ((int[]) seqNums.elementAt(i))[0])
{
int j;
int len;
maxLength = len;
}
- sqnum = new int[len + 1]; // better to always make a new array - sequence can change its length
+ sqnum = new int[len + 1]; // better to always make a new array -
+ // sequence can change its length
sqnum[0] = sq.hashCode();
for (j = 1; j <= len; j++)
{
- sqnum[j] = jalview.schemes.ResidueProperties.aaIndex[sq.charAt(j - 1)];
+ sqnum[j] = jalview.schemes.ResidueProperties.aaIndex[sq
+ .charAt(j - 1)];
}
seqNums.setElementAt(sqnum, i);
else
{
// JBPNote INFO level debug
- System.err.println(
- "ERROR: calcSeqNum called with out of range sequence index for Alignment\n");
+ System.err
+ .println("ERROR: calcSeqNum called with out of range sequence index for Alignment\n");
}
}
{
c = sequences[j].getCharAt(i);
- // No need to check if its a '-'
- if (c == '.' || c == ' ')
- {
- c = '-';
+ if (canonicaliseAa)
+ { // lookup the base aa code symbol
+ c = (char) jalview.schemes.ResidueProperties.aaIndex[sequences[j]
+ .getCharAt(i)];
+ if (c > 20)
+ {
+ c = '-';
+ }
+ else
+ {
+ // recover canonical aa symbol
+ c = jalview.schemes.ResidueProperties.aa[c].charAt(0);
+ }
}
-
- if ('a' <= c && c <= 'z')
+ else
{
- c -= (32); // 32 = 'a' - 'A'
- }
+ // original behaviour - operate on ascii symbols directly
+ // No need to check if its a '-'
+ if (c == '.' || c == ' ')
+ {
+ c = '-';
+ }
+ if (!canonicaliseAa && 'a' <= c && c <= 'z')
+ {
+ c -= (32); // 32 = 'a' - 'A'
+ }
+ }
values[c]++;
}
else
}
}
- //What is the count threshold to count the residues in residueHash()
+ // What is the count threshold to count the residues in residueHash()
thresh = (threshold * (jSize)) / 100;
- //loop over all the found residues
+ // loop over all the found residues
resultHash = new Hashtable();
for (char v = '-'; v < 'Z'; v++)
{
{
res = String.valueOf(v);
- //Now loop over the properties
+ // Now loop over the properties
enumeration2 = propHash.keys();
while (enumeration2.hasMoreElements())
type = (String) enumeration2.nextElement();
ht = (Hashtable) propHash.get(type);
- //Have we ticked this before?
+ // Have we ticked this before?
if (!resultHash.containsKey(type))
{
if (ht.containsKey(res))
resultHash.put(type, ht.get("-"));
}
}
- else if ( ( (Integer) resultHash.get(type)).equals(
- (Integer) ht.get(res)) == false)
+ else if (((Integer) resultHash.get(type)).equals((Integer) ht
+ .get(res)) == false)
{
- resultHash.put(type, new Integer( -1));
+ resultHash.put(type, new Integer(-1));
}
}
}
}
}
- /***
- * countConsNGaps
- * returns gap count in int[0], and conserved residue count in int[1]
+ /*****************************************************************************
+ * count conservation for the j'th column of the alignment
+ * @return { gap count, conserved residue count}
*/
public int[] countConsNGaps(int j)
{
c = sequences[i].getCharAt(j); // gaps do not have upper/lower case
- if (jalview.util.Comparison.isGap( (c)))
+ if (jalview.util.Comparison.isGap((c)))
{
count++;
}
/**
* Calculates the conservation sequence
- *
- * @param consflag if true, poitiveve conservation; false calculates negative conservation
- * @param percentageGaps commonly used value is 25
+ *
+ * @param consflag
+ * if true, poitiveve conservation; false calculates negative
+ * conservation
+ * @param percentageGaps
+ * commonly used value is 25
*/
public void verdict(boolean consflag, float percentageGaps)
{
Hashtable resultHash;
Enumeration enumeration;
- //NOTE THIS SHOULD CHECK IF THE CONSEQUENCE ALREADY
- //EXISTS AND NOT OVERWRITE WITH '-', BUT THIS CASE
- //DOES NOT EXIST IN JALVIEW 2.1.2
+ // NOTE THIS SHOULD CHECK IF THE CONSEQUENCE ALREADY
+ // EXISTS AND NOT OVERWRITE WITH '-', BUT THIS CASE
+ // DOES NOT EXIST IN JALVIEW 2.1.2
for (int i = 0; i < start; i++)
{
consString.append('-');
{
gapcons = countConsNGaps(i);
totGaps = gapcons[1];
- pgaps = ( (float) totGaps * 100) / (float) sequences.length;
+ pgaps = ((float) totGaps * 100) / (float) sequences.length;
if (percentageGaps > pgaps)
{
resultHash = total[i - start];
- //Now find the verdict
+ // Now find the verdict
count = 0;
enumeration = resultHash.keys();
type = (String) enumeration.nextElement();
result = (Integer) resultHash.get(type);
- //Do we want to count +ve conservation or +ve and -ve cons.?
+ // Do we want to count +ve conservation or +ve and -ve cons.?
if (consflag)
{
if (result.intValue() == 1)
}
else
{
- consString.append( (gapcons[0] == 1) ? "*" : "+");
+ consString.append((gapcons[0] == 1) ? "*" : "+");
}
}
else
}
/**
- *
- *
+ *
+ *
* @return Conservation sequence
*/
public Sequence getConsSequence()
seqNums = new Vector();
// calcSeqNum(s);
int i = 0, iSize = sequences.length;
- //Do we need to calculate this again?
+ // Do we need to calculate this again?
for (i = 0; i < iSize; i++)
{
calcSeqNum(i);
}
- if ( (cons2 == null) || seqNumsChanged)
+ if ((cons2 == null) || seqNumsChanged)
{
cons2 = new int[maxLength][24];
// unnecessary ?
- /* for (int i=start; i <= end; i++) {
- int max = -1000;
- int maxi = -1;
- int maxj = -1;
-
- for (int j=0;j<24;j++) {
- if (cons2[i][j] > max) {
- max = cons2[i][j];
- maxi = i;
- maxj = j;
- }
-
- }
- } */
+ /*
+ * for (int i=start; i <= end; i++) { int max = -1000; int maxi = -1; int
+ * maxj = -1;
+ *
+ * for (int j=0;j<24;j++) { if (cons2[i][j] > max) { max = cons2[i][j];
+ * maxi = i; maxj = j; }
+ * } }
+ */
}
}
/**
* Calculates the quality of the set of sequences
- *
- * @param start Start residue
- * @param end End residue
+ *
+ * @param start
+ * Start residue
+ * @param end
+ * End residue
*/
public void findQuality(int start, int end)
{
double max = -10000;
int[][] BLOSUM62 = jalview.schemes.ResidueProperties.getBLOSUM62();
- //Loop over columns // JBPNote Profiling info
- //long ts = System.currentTimeMillis();
- //long te = System.currentTimeMillis();
+ // Loop over columns // JBPNote Profiling info
+ // long ts = System.currentTimeMillis();
+ // long te = System.currentTimeMillis();
percentIdentity2();
int size = seqNums.size();
for (l = 0; l < size; l++)
{
- lengths[l] = ( (int[]) seqNums.elementAt(l)).length - 1;
+ lengths[l] = ((int[]) seqNums.elementAt(l)).length - 1;
}
for (j = start; j <= end; j++)
for (i2 = 0; i2 < 24; i2++)
{
- x[ii] += ( ( (double) cons2[j][i2] * BLOSUM62[ii][i2]) +
- 4);
+ x[ii] += (((double) cons2[j][i2] * BLOSUM62[ii][i2]) + 4);
}
x[ii] /= size;
{
tot = 0;
xx = new double[24];
- seqNum = (j < lengths[k])
- ? ( (int[]) seqNums.elementAt(k))[j + 1] : 23; // Sequence, or gap at the end
+ seqNum = (j < lengths[k]) ? ((int[]) seqNums.elementAt(k))[j + 1]
+ : 23; // Sequence, or gap at the end
// This is a loop over r
for (i = 0; i < 23; i++)
sr = (double) BLOSUM62[i][seqNum] + 4;
- //Calculate X with another loop over residues
- // System.out.println("Xi " + i + " " + x[i] + " " + sr);
+ // Calculate X with another loop over residues
+ // System.out.println("Xi " + i + " " + x[i] + " " + sr);
xx[i] = x[i] - sr;
tot += (xx[i] * xx[i]);
max = bigtot;
}
- // bigtot = bigtot * (size-cons2[j][23])/size;
+ // bigtot = bigtot * (size-cons2[j][23])/size;
quality.addElement(new Double(bigtot));
// Need to normalize by gaps
for (j = start; j <= end; j++)
{
- tmp = ( (Double) quality.elementAt(j)).doubleValue();
- tmp = ( (max - tmp) * (size - cons2[j][23])) / size;
+ tmp = ((Double) quality.elementAt(j)).doubleValue();
+ tmp = ((max - tmp) * (size - cons2[j][23])) / size;
- // System.out.println(tmp+ " " + j);
+ // System.out.println(tmp+ " " + j);
quality.setElementAt(new Double(tmp), j);
if (tmp > newmax)
}
}
- // System.out.println("Quality " + s);
+ // System.out.println("Quality " + s);
qualityRange[0] = new Double(0);
qualityRange[1] = new Double(newmax);
}
git://source.jalview.org / jalview.git / blobdiff