Clover icon

Coverage Report

  1. Project Clover database Thu Nov 7 2024 10:11:34 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.814814881.5%
 

Contributing tests

This file is covered by 182 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  457 toggle public SecondaryStructureConsensusThread(AlignViewportI alignViewport,
44    AlignmentViewPanel alignPanel)
45    {
46  457 super(alignViewport, alignPanel);
47    }
48   
 
49  1025 toggle @Override
50    public void run()
51    {
52  1025 if (calcMan.isPending(this))
53    {
54  6 return;
55    }
56  1019 calcMan.notifyStart(this);
57    // long started = System.currentTimeMillis();
58  1019 try
59    {
60  1019 List<AlignmentAnnotation> ssConsensus = getSSConsensusAnnotation();
61  1019 AlignmentAnnotation gap = getGapAnnotation();
62  1019 if ((ssConsensus == null && gap == null) || calcMan.isPending(this))
63    {
64  47 calcMan.workerComplete(this);
65  47 return;
66    }
67  972 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  972 if (alignViewport.isClosed())
82    {
83  0 abortAndDestroy();
84  0 return;
85    }
86  972 AlignmentI alignment = alignViewport.getAlignment();
87   
88  972 int aWidth = -1;
89   
90  ? if (alignment == null || (aWidth = alignment.getWidth()) < 0)
91    {
92  0 calcMan.workerComplete(this);
93  0 return;
94    }
95   
96  972 setSecondaryStructureSources();
97  972 eraseSSConsensus(aWidth);
98  972 computeSSConsensus(alignment);
99  972 updateResultAnnotation(true);
100   
101  971 if (ap != null)
102    {
103  971 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  1019 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  972 toggle protected void eraseSSConsensus(int aWidth)
126    {
127  972 List<AlignmentAnnotation> ssConsensuses = getSSConsensusAnnotation();
128  972 for (AlignmentAnnotation ssConsensus : ssConsensuses)
129    {
130  926 if (ssConsensus != null)
131    {
132  926 ssConsensus.annotations = new Annotation[aWidth];
133    }
134    }
135  972 AlignmentAnnotation gap = getGapAnnotation();
136  972 if (gap != null)
137    {
138  965 gap.annotations = new Annotation[aWidth];
139    }
140    }
141   
142    /**
143    * @param alignment
144    */
 
145  972 toggle protected void computeSSConsensus(AlignmentI alignment)
146    {
147   
148  972 SequenceI[] aseqs = getSequences();
149  972 int width = alignment.getWidth();
150  972 Map<String, ProfilesI> hSSConsensusProfileMap = new HashMap<String, ProfilesI>();
151  972 List<String> ssSources = getSecondaryStructureSources();
152  972 for (String ssSource : ssSources)
153    {
154  1022 ProfilesI hSSConsensus = AAFrequency.calculateSS(aseqs, width, 0,
155    width, true, ssSource);
156  1022 hSSConsensusProfileMap.put(ssSource, hSSConsensus);
157    }
158   
159  972 alignViewport.setSequenceSSConsensusHash(hSSConsensusProfileMap);
160  972 setColourSchemeConsensus(hSSConsensusProfileMap);
161    }
162   
163    /**
164    * @return
165    */
 
166  2856 toggle protected SequenceI[] getSequences()
167    {
168  2856 return alignViewport.getAlignment().getSequencesArray();
169    }
170   
171    /**
172    * @param hconsensus
173    */
 
174  972 toggle protected void setColourSchemeConsensus(
175    Map<String, ProfilesI> ssConsensusProfileMap)
176    {
177  972 ResidueShaderI cs = alignViewport.getResidueShading();
178  972 if (cs != null)
179    {
180  972 cs.setSSConsensusProfileMap(ssConsensusProfileMap);
181    }
182    }
183   
184    /**
185    * Get the Consensus annotation for the alignment
186    *
187    * @return
188    */
 
189  2980 toggle protected List<AlignmentAnnotation> getSSConsensusAnnotation()
190    {
191  2980 return alignViewport
192    .getAlignmentSecondaryStructureConsensusAnnotation();
193    }
194   
195    /**
196    * Get the Consensus annotation for the alignment
197    *
198    * @return
199    */
 
200  972 toggle protected void setSecondaryStructureSources()
201    {
202  972 List<String> sources = null;
203  972 AlignmentAnnotation[] aa = alignViewport.getAlignment()
204    .getAlignmentAnnotation();
205  972 if (aa != null)
206    {
207  972 sources = AlignmentUtils.extractSSSourceInAlignmentAnnotation(aa);
208  972 if (sources != null)
209    {
210  972 sources.add(0, Constants.SS_ALL_PROVIDERS);
211  972 alignViewport.setSecondaryStructureSources(sources);
212    }
213    }
214    }
215   
 
216  972 toggle protected List<String> getSecondaryStructureSources()
217    {
218  972 return alignViewport.getSecondaryStructureSources();
219    }
220   
221    /**
222    * Get the Gap annotation for the alignment
223    *
224    * @return
225    */
 
226  2938 toggle protected AlignmentAnnotation getGapAnnotation()
227    {
228  2938 return alignViewport.getAlignmentGapAnnotation();
229    }
230   
231    /**
232    * update the consensus annotation from the sequence profile data using
233    * current visualization settings.
234    */
 
235  17 toggle @Override
236    public void updateAnnotation()
237    {
238  17 updateResultAnnotation(false);
239    }
240   
 
241  989 toggle public void updateResultAnnotation(boolean immediate)
242    {
243  989 List<AlignmentAnnotation> ssConsensuses = getSSConsensusAnnotation();
244  989 Map<String, ProfilesI> ssConsensusProfileMap = getViewportSSConsensus();
245  989 for (AlignmentAnnotation ssConsensus : ssConsensuses)
246    {
247  948 ProfilesI ssConsensusProfile = null;
248  948 for (String source : ssConsensusProfileMap.keySet())
249    {
250  984 if (ssConsensus.description.startsWith(source))
251    {
252  948 ssConsensusProfile = ssConsensusProfileMap.get(source);
253  948 break;
254    }
255    }
256  948 if (ssConsensusProfile == null)
257    {
258  0 continue;
259    }
260  948 if (immediate || !calcMan.isWorking(this) && ssConsensus != null
261    && ssConsensusProfile != null)
262    {
263  947 if (ssConsensusProfile.get(0) != null)
264  947 ssConsensus.setNoOfSequencesIncluded(
265    ssConsensusProfile.get(0).getSeqWithSSCount());
266  947 deriveSSConsensus(ssConsensus, ssConsensusProfile);
267  947 AlignmentAnnotation gap = getGapAnnotation();
268  947 if (gap != null)
269    {
270  937 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  947 toggle protected void deriveSSConsensus(AlignmentAnnotation ssConsensus,
286    ProfilesI hSSConsensus)
287    {
288   
289  947 long nseq = getSequences().length;
290  947 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  937 toggle protected void deriveGap(AlignmentAnnotation gapAnnotation,
305    ProfilesI hconsensus)
306    {
307  937 long nseq = getSequences().length;
308  937 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  989 toggle protected Map<String, ProfilesI> getViewportSSConsensus()
319    {
320    // TODO convert ComplementConsensusThread to use Profile
321  989 return alignViewport.getSequenceSSConsensusHash();
322    }
323    }
  • Report generated by OpenClover v 4.4.1 on Thu Nov 7 2024 10:19:08 GMT using coverage data from Thu Nov 7 2024 10:18:53 GMT.
  • OpenClover is free and open-source software.