Clover icon

Coverage Report

  1. Project Clover database Mon Nov 11 2024 20:42:03 GMT
  2. Package jalview.workers

File SecondaryStructureConsensusThread.java

 

Coverage histogram

../../img/srcFileCovDistChart9.png
12% of files have more coverage

Code metrics

34
86
15
1
323
217
40
0.47
5.73
15
2.67

Classes

Class Line # Actions
SecondaryStructureConsensusThread 41 86 40
0.8222222382.2%
 

Contributing tests

This file is covered by 185 tests. .

Source view

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.workers;
22   
23    import java.util.Collections;
24    import java.util.HashMap;
25    import java.util.List;
26    import java.util.Map;
27   
28    import jalview.analysis.AAFrequency;
29    import jalview.analysis.AlignmentUtils;
30    import jalview.api.AlignViewportI;
31    import jalview.api.AlignmentViewPanel;
32    import jalview.datamodel.AlignmentAnnotation;
33    import jalview.datamodel.AlignmentI;
34    import jalview.datamodel.Annotation;
35    import jalview.datamodel.ProfilesI;
36    import jalview.datamodel.SequenceI;
37    import jalview.renderer.ResidueShaderI;
38    import jalview.util.Constants;
39    import jalview.util.MessageManager;
40   
 
41    public class SecondaryStructureConsensusThread extends AlignCalcWorker
42    {
 
43  461 toggle public SecondaryStructureConsensusThread(AlignViewportI alignViewport,
44    AlignmentViewPanel alignPanel)
45    {
46  461 super(alignViewport, alignPanel);
47    }
48   
 
49  1032 toggle @Override
50    public void run()
51    {
52  1032 if (calcMan.isPending(this))
53    {
54  16 return;
55    }
56  1016 calcMan.notifyStart(this);
57    // long started = System.currentTimeMillis();
58  1016 try
59    {
60  1016 List<AlignmentAnnotation> ssConsensus = getSSConsensusAnnotation();
61  1016 AlignmentAnnotation gap = getGapAnnotation();
62  1016 if ((ssConsensus == null && gap == null) || calcMan.isPending(this))
63    {
64  60 calcMan.workerComplete(this);
65  60 return;
66    }
67  956 while (!calcMan.notifyWorking(this))
68    {
69  0 try
70    {
71  0 if (ap != null)
72    {
73  0 ap.paintAlignment(false, false);
74    }
75  0 Thread.sleep(200);
76    } catch (Exception ex)
77    {
78  0 ex.printStackTrace();
79    }
80    }
81  956 if (alignViewport.isClosed())
82    {
83  0 abortAndDestroy();
84  0 return;
85    }
86  956 AlignmentI alignment = alignViewport.getAlignment();
87   
88  956 int aWidth = -1;
89   
90  ? if (alignment == null || (aWidth = alignment.getWidth()) < 0)
91    {
92  0 calcMan.workerComplete(this);
93  0 return;
94    }
95   
96  956 setSecondaryStructureSources();
97  956 eraseSSConsensus(aWidth);
98  956 computeSSConsensus(alignment);
99  956 updateResultAnnotation(true);
100   
101  955 if (ap != null)
102    {
103  955 ap.paintAlignment(true, true);
104    }
105    } catch (OutOfMemoryError error)
106    {
107  0 calcMan.disableWorker(this);
108  0 ap.raiseOOMWarning("calculating consensus", error);
109    } finally
110    {
111    /*
112    * e.g. ArrayIndexOutOfBoundsException can happen due to a race condition
113    * - alignment was edited at same time as calculation was running
114    */
115  1016 calcMan.workerComplete(this);
116    }
117    }
118   
119    /**
120    * Clear out any existing consensus annotations
121    *
122    * @param aWidth
123    * the width (number of columns) of the annotated alignment
124    */
 
125  956 toggle protected void eraseSSConsensus(int aWidth)
126    {
127  956 List<AlignmentAnnotation> ssConsensuses = getSSConsensusAnnotation();
128  956 for (AlignmentAnnotation ssConsensus : ssConsensuses)
129    {
130  905 if (ssConsensus != null)
131    {
132  905 ssConsensus.annotations = new Annotation[aWidth];
133    }
134    }
135  956 AlignmentAnnotation gap = getGapAnnotation();
136  956 if (gap != null)
137    {
138  950 gap.annotations = new Annotation[aWidth];
139    }
140    }
141   
142    /**
143    * @param alignment
144    */
 
145  956 toggle protected void computeSSConsensus(AlignmentI alignment)
146    {
147   
148  956 SequenceI[] aseqs = getSequences();
149  956 int width = alignment.getWidth();
150  956 Map<String, ProfilesI> hSSConsensusProfileMap = new HashMap<String, ProfilesI>();
151  956 List<String> ssSources = getSecondaryStructureSources();
152  956 for (String ssSource : ssSources)
153    {
154  1003 ProfilesI hSSConsensus = AAFrequency.calculateSS(aseqs, width, 0,
155    width, true, ssSource);
156  1003 hSSConsensusProfileMap.put(ssSource, hSSConsensus);
157    }
158   
159  956 alignViewport.setSequenceSSConsensusHash(hSSConsensusProfileMap);
160  956 setColourSchemeConsensus(hSSConsensusProfileMap);
161    }
162   
163    /**
164    * @return
165    */
 
166  2798 toggle protected SequenceI[] getSequences()
167    {
168  2798 return alignViewport.getAlignment().getSequencesArray();
169    }
170   
171    /**
172    * @param hconsensus
173    */
 
174  956 toggle protected void setColourSchemeConsensus(
175    Map<String, ProfilesI> ssConsensusProfileMap)
176    {
177  956 ResidueShaderI cs = alignViewport.getResidueShading();
178  956 if (cs != null)
179    {
180  955 cs.setSSConsensusProfileMap(ssConsensusProfileMap);
181    }
182    }
183   
184    /**
185    * Get the Consensus annotation for the alignment
186    *
187    * @return
188    */
 
189  2944 toggle protected List<AlignmentAnnotation> getSSConsensusAnnotation()
190    {
191  2944 return alignViewport
192    .getAlignmentSecondaryStructureConsensusAnnotation();
193    }
194   
195    /**
196    * Get the Consensus annotation for the alignment
197    *
198    * @return
199    */
 
200  956 toggle protected void setSecondaryStructureSources()
201    {
202  956 List<String> sources = null;
203  956 AlignmentAnnotation[] aa = alignViewport.getAlignment()
204    .getAlignmentAnnotation();
205  956 if (aa != null)
206    {
207  956 sources = AlignmentUtils.extractSSSourceInAlignmentAnnotation(aa);
208  956 if (sources != null)
209    {
210  956 sources.add(0, Constants.SS_ALL_PROVIDERS);
211  956 alignViewport.setSecondaryStructureSources(sources);
212    }
213    }
214    }
215   
 
216  956 toggle protected List<String> getSecondaryStructureSources()
217    {
218  956 return alignViewport.getSecondaryStructureSources();
219    }
220   
221    /**
222    * Get the Gap annotation for the alignment
223    *
224    * @return
225    */
 
226  2896 toggle protected AlignmentAnnotation getGapAnnotation()
227    {
228  2896 return alignViewport.getAlignmentGapAnnotation();
229    }
230   
231    /**
232    * update the consensus annotation from the sequence profile data using
233    * current visualization settings.
234    */
 
235  16 toggle @Override
236    public void updateAnnotation()
237    {
238  16 updateResultAnnotation(false);
239    }
240   
 
241  972 toggle public void updateResultAnnotation(boolean immediate)
242    {
243  972 List<AlignmentAnnotation> ssConsensuses = getSSConsensusAnnotation();
244  972 Map<String, ProfilesI> ssConsensusProfileMap = getViewportSSConsensus();
245  972 for (AlignmentAnnotation ssConsensus : ssConsensuses)
246    {
247  925 ProfilesI ssConsensusProfile = null;
248  925 for (String source : ssConsensusProfileMap.keySet())
249    {
250  956 if (ssConsensus.description.startsWith(source))
251    {
252  925 ssConsensusProfile = ssConsensusProfileMap.get(source);
253  925 break;
254    }
255    }
256  925 if (ssConsensusProfile == null)
257    {
258  0 continue;
259    }
260  925 if (immediate || !calcMan.isWorking(this) && ssConsensus != null
261    && ssConsensusProfile != null)
262    {
263  924 if (ssConsensusProfile.get(0) != null)
264  924 ssConsensus.setNoOfSequencesIncluded(
265    ssConsensusProfile.get(0).getSeqWithSSCount());
266  924 deriveSSConsensus(ssConsensus, ssConsensusProfile);
267  924 AlignmentAnnotation gap = getGapAnnotation();
268  924 if (gap != null)
269    {
270  918 deriveGap(gap, ssConsensusProfile);
271    }
272    }
273    }
274    }
275   
276    /**
277    * Convert the computed consensus data into the desired annotation for
278    * display.
279    *
280    * @param consensusAnnotation
281    * the annotation to be populated
282    * @param hconsensus
283    * the computed consensus data
284    */
 
285  924 toggle protected void deriveSSConsensus(AlignmentAnnotation ssConsensus,
286    ProfilesI hSSConsensus)
287    {
288   
289  924 long nseq = getSequences().length;
290  924 AAFrequency.completeSSConsensus(ssConsensus, hSSConsensus,
291    hSSConsensus.getStartColumn(), hSSConsensus.getEndColumn() + 1,
292    alignViewport.isIgnoreGapsConsensus(),
293    alignViewport.isShowSequenceLogo(), nseq);
294    }
295   
296    /**
297    * Convert the computed consensus data into a gap annotation row for display.
298    *
299    * @param gapAnnotation
300    * the annotation to be populated
301    * @param hconsensus
302    * the computed consensus data
303    */
 
304  918 toggle protected void deriveGap(AlignmentAnnotation gapAnnotation,
305    ProfilesI hconsensus)
306    {
307  918 long nseq = getSequences().length;
308  918 AAFrequency.completeGapAnnot(gapAnnotation, hconsensus,
309    hconsensus.getStartColumn(), hconsensus.getEndColumn() + 1,
310    nseq);
311    }
312   
313    /**
314    * Get the consensus data stored on the viewport.
315    *
316    * @return
317    */
 
318  972 toggle protected Map<String, ProfilesI> getViewportSSConsensus()
319    {
320    // TODO convert ComplementConsensusThread to use Profile
321  972 return alignViewport.getSequenceSSConsensusHash();
322    }
323    }