Merge remote-tracking branch 'origin/tasks/JAL-3035_remove_dasobert_dependency' into...
[jalview.git] / src / jalview / analysis / Conservation.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
4  * 
5  * This file is part of Jalview.
6  * 
7  * Jalview is free software: you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License 
9  * as published by the Free Software Foundation, either version 3
10  * of the License, or (at your option) any later version.
11  *  
12  * Jalview is distributed in the hope that it will be useful, but 
13  * WITHOUT ANY WARRANTY; without even the implied warranty 
14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
15  * PURPOSE.  See the GNU General Public License for more details.
16  * 
17  * You should have received a copy of the GNU General Public License
18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
19  * The Jalview Authors are detailed in the 'AUTHORS' file.
20  */
21 package jalview.analysis;
22
23 import jalview.analysis.scoremodels.ScoreMatrix;
24 import jalview.analysis.scoremodels.ScoreModels;
25 import jalview.datamodel.AlignmentAnnotation;
26 import jalview.datamodel.Annotation;
27 import jalview.datamodel.ResidueCount;
28 import jalview.datamodel.ResidueCount.SymbolCounts;
29 import jalview.datamodel.Sequence;
30 import jalview.datamodel.SequenceI;
31 import jalview.schemes.ResidueProperties;
32 import jalview.util.Comparison;
33
34 import java.awt.Color;
35 import java.util.List;
36 import java.util.Map;
37 import java.util.Map.Entry;
38 import java.util.SortedMap;
39 import java.util.TreeMap;
40 import java.util.Vector;
41
42 /**
43  * Calculates conservation values for a given set of sequences
44  */
45 public class Conservation
46 {
47   /*
48    * need to have a minimum of 3% of sequences with a residue
49    * for it to be included in the conservation calculation
50    */
51   private static final int THRESHOLD_PERCENT = 3;
52
53   private static final int TOUPPERCASE = 'a' - 'A';
54
55   private static final int GAP_INDEX = -1;
56
57   SequenceI[] sequences;
58
59   int start;
60
61   int end;
62
63   /*
64    * a list whose i'th element is an array whose first entry is the checksum
65    * of the i'th sequence, followed by residues encoded to score matrix index
66    */
67   Vector<int[]> seqNums;
68
69   int maxLength = 0; // used by quality calcs
70
71   boolean seqNumsChanged = false; // updated after any change via calcSeqNum;
72
73   /*
74    * a map per column with {property, conservation} where conservation value is
75    * 1 (property is conserved), 0 (absence of property is conserved) or -1
76    * (property is not conserved i.e. column has residues with and without it)
77    */
78   Map<String, Integer>[] total;
79
80   /*
81    * if true then conservation calculation will map all symbols to canonical aa
82    * numbering rather than consider conservation of that symbol
83    */
84   boolean canonicaliseAa = true;
85
86   private Vector<Double> quality;
87
88   private double qualityMinimum;
89
90   private double qualityMaximum;
91
92   private Sequence consSequence;
93
94   /*
95    * percentage of residues in a column to qualify for counting conservation
96    */
97   private int threshold;
98
99   private String name = "";
100
101   /*
102    * an array, for each column, of counts of symbols (by score matrix index)
103    */
104   private int[][] cons2;
105
106   /*
107    * gap counts for each column
108    */
109   private int[] cons2GapCounts;
110
111   private String[] consSymbs;
112
113   /**
114    * Constructor using default threshold of 3%
115    * 
116    * @param name
117    *          Name of conservation
118    * @param sequences
119    *          sequences to be used in calculation
120    * @param start
121    *          start residue position
122    * @param end
123    *          end residue position
124    */
125   public Conservation(String name, List<SequenceI> sequences, int start,
126           int end)
127   {
128     this(name, THRESHOLD_PERCENT, sequences, start, end);
129   }
130
131   /**
132    * Constructor
133    * 
134    * @param name
135    *          Name of conservation
136    * @param threshold
137    *          percentage of sequences at or below which property conservation is
138    *          ignored
139    * @param sequences
140    *          sequences to be used in calculation
141    * @param start
142    *          start column position
143    * @param end
144    *          end column position
145    */
146   public Conservation(String name, int threshold, List<SequenceI> sequences,
147           int start, int end)
148   {
149     this.name = name;
150     this.threshold = threshold;
151     this.start = start;
152     this.end = end;
153
154     maxLength = end - start + 1; // default width includes bounds of
155     // calculation
156
157     int s, sSize = sequences.size();
158     SequenceI[] sarray = new SequenceI[sSize];
159     this.sequences = sarray;
160     try
161     {
162       for (s = 0; s < sSize; s++)
163       {
164         sarray[s] = sequences.get(s);
165         if (sarray[s].getLength() > maxLength)
166         {
167           maxLength = sarray[s].getLength();
168         }
169       }
170     } catch (ArrayIndexOutOfBoundsException ex)
171     {
172       // bail - another thread has modified the sequence array, so the current
173       // calculation is probably invalid.
174       this.sequences = new SequenceI[0];
175       maxLength = 0;
176     }
177   }
178
179   /**
180    * Translate sequence i into score matrix indices and store it in the i'th
181    * position of the seqNums array.
182    * 
183    * @param i
184    * @param sm
185    */
186   private void calcSeqNum(int i, ScoreMatrix sm)
187   {
188     int sSize = sequences.length;
189
190     if ((i > -1) && (i < sSize))
191     {
192       String sq = sequences[i].getSequenceAsString();
193
194       if (seqNums.size() <= i)
195       {
196         seqNums.addElement(new int[sq.length() + 1]);
197       }
198
199       /*
200        * the first entry in the array is the sequence's hashcode,
201        * following entries are matrix indices of sequence characters
202        */
203       if (sq.hashCode() != seqNums.elementAt(i)[0])
204       {
205         int j;
206         int len;
207         seqNumsChanged = true;
208         len = sq.length();
209
210         if (maxLength < len)
211         {
212           maxLength = len;
213         }
214
215         int[] sqnum = new int[len + 1]; // better to always make a new array -
216         // sequence can change its length
217         sqnum[0] = sq.hashCode();
218
219         for (j = 1; j <= len; j++)
220         {
221           // sqnum[j] = ResidueProperties.aaIndex[sq.charAt(j - 1)];
222           char residue = sq.charAt(j - 1);
223           if (Comparison.isGap(residue))
224           {
225             sqnum[j] = GAP_INDEX;
226           }
227           else
228           {
229             sqnum[j] = sm.getMatrixIndex(residue);
230             if (sqnum[j] == -1)
231             {
232               sqnum[j] = GAP_INDEX;
233             }
234           }
235         }
236
237         seqNums.setElementAt(sqnum, i);
238       }
239       else
240       {
241         System.out.println("SEQUENCE HAS BEEN DELETED!!!");
242       }
243     }
244     else
245     {
246       // JBPNote INFO level debug
247       System.err.println(
248               "ERROR: calcSeqNum called with out of range sequence index for Alignment\n");
249     }
250   }
251
252   /**
253    * Calculates the conservation values for given set of sequences
254    */
255   public void calculate()
256   {
257     int height = sequences.length;
258
259     total = new Map[maxLength];
260
261     for (int column = start; column <= end; column++)
262     {
263       ResidueCount values = countResidues(column);
264
265       /*
266        * percentage count at or below which we ignore residues
267        */
268       int thresh = (threshold * height) / 100;
269
270       /*
271        * check observed residues in column and record whether each 
272        * physico-chemical property is conserved (+1), absence conserved (0),
273        * or not conserved (-1)
274        * Using TreeMap means properties are displayed in alphabetical order
275        */
276       SortedMap<String, Integer> resultHash = new TreeMap<>();
277       SymbolCounts symbolCounts = values.getSymbolCounts();
278       char[] symbols = symbolCounts.symbols;
279       int[] counts = symbolCounts.values;
280       for (int j = 0; j < symbols.length; j++)
281       {
282         char c = symbols[j];
283         if (counts[j] > thresh)
284         {
285           recordConservation(resultHash, String.valueOf(c));
286         }
287       }
288       if (values.getGapCount() > thresh)
289       {
290         recordConservation(resultHash, "-");
291       }
292
293       if (total.length > 0)
294       {
295         total[column - start] = resultHash;
296       }
297     }
298   }
299
300   /**
301    * Updates the conservation results for an observed residue
302    * 
303    * @param resultMap
304    *          a map of {property, conservation} where conservation value is +1
305    *          (all residues have the property), 0 (no residue has the property)
306    *          or -1 (some do, some don't)
307    * @param res
308    */
309   protected static void recordConservation(Map<String, Integer> resultMap,
310           String res)
311   {
312     res = res.toUpperCase();
313     for (Entry<String, Map<String, Integer>> property : ResidueProperties.propHash
314             .entrySet())
315     {
316       String propertyName = property.getKey();
317       Integer residuePropertyValue = property.getValue().get(res);
318
319       if (!resultMap.containsKey(propertyName))
320       {
321         /*
322          * first time we've seen this residue - note whether it has this property
323          */
324         if (residuePropertyValue != null)
325         {
326           resultMap.put(propertyName, residuePropertyValue);
327         }
328         else
329         {
330           /*
331            * unrecognised residue - use default value for property
332            */
333           resultMap.put(propertyName, property.getValue().get("-"));
334         }
335       }
336       else
337       {
338         Integer currentResult = resultMap.get(propertyName);
339         if (currentResult.intValue() != -1
340                 && !currentResult.equals(residuePropertyValue))
341         {
342           /*
343            * property is unconserved - residues seen both with and without it
344            */
345           resultMap.put(propertyName, Integer.valueOf(-1));
346         }
347       }
348     }
349   }
350
351   /**
352    * Counts residues (upper-cased) and gaps in the given column
353    * 
354    * @param column
355    * @return
356    */
357   protected ResidueCount countResidues(int column)
358   {
359     ResidueCount values = new ResidueCount(false);
360
361     for (int row = 0; row < sequences.length; row++)
362     {
363       if (sequences[row].getLength() > column)
364       {
365         char c = sequences[row].getCharAt(column);
366         if (canonicaliseAa)
367         {
368           int index = ResidueProperties.aaIndex[c];
369           c = index > 20 ? '-' : ResidueProperties.aa[index].charAt(0);
370         }
371         else
372         {
373           c = toUpperCase(c);
374         }
375         if (Comparison.isGap(c))
376         {
377           values.addGap();
378         }
379         else
380         {
381           values.add(c);
382         }
383       }
384       else
385       {
386         values.addGap();
387       }
388     }
389     return values;
390   }
391
392   /**
393    * Counts conservation and gaps for a column of the alignment
394    * 
395    * @return { 1 if fully conserved, else 0, gap count }
396    */
397   public int[] countConservationAndGaps(int column)
398   {
399     int gapCount = 0;
400     boolean fullyConserved = true;
401     int iSize = sequences.length;
402
403     if (iSize == 0)
404     {
405       return new int[] { 0, 0 };
406     }
407
408     char lastRes = '0';
409     for (int i = 0; i < iSize; i++)
410     {
411       if (column >= sequences[i].getLength())
412       {
413         gapCount++;
414         continue;
415       }
416
417       char c = sequences[i].getCharAt(column); // gaps do not have upper/lower
418                                                // case
419
420       if (Comparison.isGap((c)))
421       {
422         gapCount++;
423       }
424       else
425       {
426         c = toUpperCase(c);
427         if (lastRes == '0')
428         {
429           lastRes = c;
430         }
431         if (c != lastRes)
432         {
433           fullyConserved = false;
434         }
435       }
436     }
437
438     int[] r = new int[] { fullyConserved ? 1 : 0, gapCount };
439     return r;
440   }
441
442   /**
443    * Returns the upper-cased character if between 'a' and 'z', else the
444    * unchanged value
445    * 
446    * @param c
447    * @return
448    */
449   char toUpperCase(char c)
450   {
451     if ('a' <= c && c <= 'z')
452     {
453       c -= TOUPPERCASE;
454     }
455     return c;
456   }
457
458   /**
459    * Calculates the conservation sequence
460    * 
461    * @param positiveOnly
462    *          if true, calculate positive conservation; else calculate both
463    *          positive and negative conservation
464    * @param maxPercentageGaps
465    *          the percentage of gaps in a column, at or above which no
466    *          conservation is asserted
467    */
468   public void verdict(boolean positiveOnly, float maxPercentageGaps)
469   {
470     // TODO call this at the end of calculate(), should not be a public method
471
472     StringBuilder consString = new StringBuilder(end);
473
474     // NOTE THIS SHOULD CHECK IF THE CONSEQUENCE ALREADY
475     // EXISTS AND NOT OVERWRITE WITH '-', BUT THIS CASE
476     // DOES NOT EXIST IN JALVIEW 2.1.2
477     for (int i = 0; i < start; i++)
478     {
479       consString.append('-');
480     }
481     consSymbs = new String[end - start + 1];
482     for (int i = start; i <= end; i++)
483     {
484       int[] gapcons = countConservationAndGaps(i);
485       boolean fullyConserved = gapcons[0] == 1;
486       int totGaps = gapcons[1];
487       float pgaps = (totGaps * 100f) / sequences.length;
488
489       if (maxPercentageGaps > pgaps)
490       {
491         Map<String, Integer> resultHash = total[i - start];
492         int count = 0;
493         StringBuilder positives = new StringBuilder(64);
494         StringBuilder negatives = new StringBuilder(32);
495         for (String type : resultHash.keySet())
496         {
497           int result = resultHash.get(type).intValue();
498           if (result == -1)
499           {
500             /*
501              * not conserved (present or absent)
502              */
503             continue;
504           }
505           count++;
506           if (result == 1)
507           {
508             /*
509              * positively conserved property (all residues have it)
510              */
511             positives.append(positives.length() == 0 ? "" : " ");
512             positives.append(type);
513           }
514           if (result == 0 && !positiveOnly)
515           {
516             /*
517              * absense of property is conserved (all residues lack it)
518              */
519             negatives.append(negatives.length() == 0 ? "" : " ");
520             negatives.append("!").append(type);
521           }
522         }
523         if (negatives.length() > 0)
524         {
525           positives.append(" ").append(negatives);
526         }
527         consSymbs[i - start] = positives.toString();
528
529         if (count < 10)
530         {
531           consString.append(count); // Conserved props!=Identity
532         }
533         else
534         {
535           consString.append(fullyConserved ? "*" : "+");
536         }
537       }
538       else
539       {
540         consString.append('-');
541       }
542     }
543
544     consSequence = new Sequence(name, consString.toString(), start, end);
545   }
546
547   /**
548    * 
549    * 
550    * @return Conservation sequence
551    */
552   public SequenceI getConsSequence()
553   {
554     return consSequence;
555   }
556
557   // From Alignment.java in jalview118
558   public void findQuality()
559   {
560     findQuality(0, maxLength - 1, ScoreModels.getInstance().getBlosum62());
561   }
562
563   /**
564    * DOCUMENT ME!
565    * 
566    * @param sm
567    */
568   private void percentIdentity(ScoreMatrix sm)
569   {
570     seqNums = new Vector<>();
571     int i = 0, iSize = sequences.length;
572     // Do we need to calculate this again?
573     for (i = 0; i < iSize; i++)
574     {
575       calcSeqNum(i, sm);
576     }
577
578     if ((cons2 == null) || seqNumsChanged)
579     {
580       // FIXME remove magic number 24 without changing calc
581       // sm.getSize() returns 25 so doesn't quite do it...
582       cons2 = new int[maxLength][24];
583       cons2GapCounts = new int[maxLength];
584
585       int j = 0;
586
587       while (j < sequences.length)
588       {
589         int[] sqnum = seqNums.elementAt(j);
590
591         for (i = 1; i < sqnum.length; i++)
592         {
593           int index = sqnum[i];
594           if (index == GAP_INDEX)
595           {
596             cons2GapCounts[i - 1]++;
597           }
598           else
599           {
600             cons2[i - 1][index]++;
601           }
602         }
603
604         // TODO should this start from sqnum.length?
605         for (i = sqnum.length - 1; i < maxLength; i++)
606         {
607           cons2GapCounts[i]++;
608         }
609         j++;
610       }
611     }
612   }
613
614   /**
615    * Calculates the quality of the set of sequences over the given inclusive
616    * column range, using the specified substitution score matrix
617    * 
618    * @param startCol
619    * @param endCol
620    * @param scoreMatrix
621    */
622   protected void findQuality(int startCol, int endCol,
623           ScoreMatrix scoreMatrix)
624   {
625     quality = new Vector<>();
626
627     double max = -Double.MAX_VALUE;
628     float[][] scores = scoreMatrix.getMatrix();
629
630     percentIdentity(scoreMatrix);
631
632     int size = seqNums.size();
633     int[] lengths = new int[size];
634
635     for (int l = 0; l < size; l++)
636     {
637       lengths[l] = seqNums.elementAt(l).length - 1;
638     }
639
640     final int symbolCount = scoreMatrix.getSize();
641
642     for (int j = startCol; j <= endCol; j++)
643     {
644       double bigtot = 0;
645
646       // First Xr = depends on column only
647       double[] x = new double[symbolCount];
648
649       for (int ii = 0; ii < symbolCount; ii++)
650       {
651         x[ii] = 0;
652
653         /*
654          * todo JAL-728 currently assuming last symbol in matrix is * for gap
655          * (which we ignore as counted separately); true for BLOSUM62 but may
656          * not be once alternative matrices are supported
657          */
658         for (int i2 = 0; i2 < symbolCount - 1; i2++)
659         {
660           x[ii] += (((double) cons2[j][i2] * scores[ii][i2]) + 4D);
661         }
662         x[ii] += 4D + cons2GapCounts[j] * scoreMatrix.getMinimumScore();
663
664         x[ii] /= size;
665       }
666
667       // Now calculate D for each position and sum
668       for (int k = 0; k < size; k++)
669       {
670         double tot = 0;
671         double[] xx = new double[symbolCount];
672         // sequence character index, or implied gap if sequence too short
673         int seqNum = (j < lengths[k]) ? seqNums.elementAt(k)[j + 1]
674                 : GAP_INDEX;
675
676         for (int i = 0; i < symbolCount - 1; i++)
677         {
678           double sr = 4D;
679           if (seqNum == GAP_INDEX)
680           {
681             sr += scoreMatrix.getMinimumScore();
682           }
683           else
684           {
685             sr += scores[i][seqNum];
686           }
687
688           xx[i] = x[i] - sr;
689
690           tot += (xx[i] * xx[i]);
691         }
692
693         bigtot += Math.sqrt(tot);
694       }
695
696       max = Math.max(max, bigtot);
697
698       quality.addElement(new Double(bigtot));
699     }
700
701     double newmax = -Double.MAX_VALUE;
702
703     for (int j = startCol; j <= endCol; j++)
704     {
705       double tmp = quality.elementAt(j).doubleValue();
706       // tmp = ((max - tmp) * (size - cons2[j][23])) / size;
707       tmp = ((max - tmp) * (size - cons2GapCounts[j])) / size;
708
709       // System.out.println(tmp+ " " + j);
710       quality.setElementAt(new Double(tmp), j);
711
712       if (tmp > newmax)
713       {
714         newmax = tmp;
715       }
716     }
717
718     qualityMinimum = 0D;
719     qualityMaximum = newmax;
720   }
721
722   /**
723    * Complete the given consensus and quuality annotation rows. Note: currently
724    * this method will reallocate the given annotation row if it is different to
725    * the calculated width, otherwise will leave its length unchanged.
726    * 
727    * @param conservation
728    *          conservation annotation row
729    * @param quality2
730    *          (optional - may be null)
731    * @param istart
732    *          first column for conservation
733    * @param alWidth
734    *          extent of conservation
735    */
736   public void completeAnnotations(AlignmentAnnotation conservation,
737           AlignmentAnnotation quality2, int istart, int alWidth)
738   {
739     SequenceI cons = getConsSequence();
740
741     /*
742      * colour scale for Conservation and Quality;
743      */
744     float minR = 0.3f;
745     float minG = 0.0f;
746     float minB = 0f;
747     float maxR = 1.0f - minR;
748     float maxG = 0.9f - minG;
749     float maxB = 0f - minB;
750
751     float min = 0f;
752     float max = 11f;
753     float qmin = 0f;
754     float qmax = 0f;
755
756     if (conservation != null && conservation.annotations != null
757             && conservation.annotations.length != alWidth)
758     {
759       conservation.annotations = new Annotation[alWidth];
760     }
761
762     if (quality2 != null)
763     {
764       quality2.graphMax = (float) qualityMaximum;
765       if (quality2.annotations != null
766               && quality2.annotations.length != alWidth)
767       {
768         quality2.annotations = new Annotation[alWidth];
769       }
770       qmin = (float) qualityMinimum;
771       qmax = (float) qualityMaximum;
772     }
773
774     for (int i = istart; i < alWidth; i++)
775     {
776       float value = 0;
777
778       char c = cons.getCharAt(i);
779
780       if (Character.isDigit(c))
781       {
782         value = c - '0';
783       }
784       else if (c == '*')
785       {
786         value = 11;
787       }
788       else if (c == '+')
789       {
790         value = 10;
791       }
792
793       if (conservation != null)
794       {
795         float vprop = value - min;
796         vprop /= max;
797         int consp = i - start;
798         String conssym = (value > 0 && consp > -1
799                 && consp < consSymbs.length) ? consSymbs[consp] : "";
800         conservation.annotations[i] = new Annotation(String.valueOf(c),
801                 conssym, ' ', value, new Color(minR + (maxR * vprop),
802                         minG + (maxG * vprop), minB + (maxB * vprop)));
803       }
804
805       // Quality calc
806       if (quality2 != null)
807       {
808         value = quality.elementAt(i).floatValue();
809         float vprop = value - qmin;
810         vprop /= qmax;
811         quality2.annotations[i] = new Annotation(" ", String.valueOf(value),
812                 ' ', value, new Color(minR + (maxR * vprop),
813                         minG + (maxG * vprop), minB + (maxB * vprop)));
814       }
815     }
816   }
817
818   /**
819    * construct and call the calculation methods on a new Conservation object
820    * 
821    * @param name
822    *          - name of conservation
823    * @param seqs
824    * @param start
825    *          first column in calculation window
826    * @param end
827    *          last column in calculation window
828    * @param positiveOnly
829    *          calculate positive (true) or positive and negative (false)
830    *          conservation
831    * @param maxPercentGaps
832    *          percentage of gaps tolerated in column
833    * @param calcQuality
834    *          flag indicating if alignment quality should be calculated
835    * @return Conservation object ready for use in visualization
836    */
837   public static Conservation calculateConservation(String name,
838           List<SequenceI> seqs, int start, int end, boolean positiveOnly,
839           int maxPercentGaps, boolean calcQuality)
840   {
841     Conservation cons = new Conservation(name, seqs, start, end);
842     cons.calculate();
843     cons.verdict(positiveOnly, maxPercentGaps);
844
845     if (calcQuality)
846     {
847       cons.findQuality();
848     }
849
850     return cons;
851   }
852
853   /**
854    * Returns the computed tooltip (annotation description) for a given column.
855    * The tip is empty if the conservation score is zero, otherwise holds the
856    * conserved properties (and, optionally, properties whose absence is
857    * conserved).
858    * 
859    * @param column
860    * @return
861    */
862   String getTooltip(int column)
863   {
864     SequenceI cons = getConsSequence();
865     char val = column < cons.getLength() ? cons.getCharAt(column) : '-';
866     boolean hasConservation = val != '-' && val != '0';
867     int consp = column - start;
868     String tip = (hasConservation && consp > -1 && consp < consSymbs.length)
869             ? consSymbs[consp]
870             : "";
871     return tip;
872   }
873 }