convenience method to discover all Jmols
[jalview.git] / src / jalview / io / MSFfile.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.6)
3  * Copyright (C) 2010 J Procter, AM Waterhouse, G Barton, M Clamp, S Searle
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 of the License, or (at your option) any later version.
10  * 
11  * Jalview is distributed in the hope that it will be useful, but 
12  * WITHOUT ANY WARRANTY; without even the implied warranty 
13  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
14  * PURPOSE.  See the GNU General Public License for more details.
15  * 
16  * You should have received a copy of the GNU General Public License along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
17  */
18 package jalview.io;
19
20 import java.io.*;
21 import java.util.*;
22
23 import jalview.datamodel.*;
24 import jalview.util.*;
25
26 /**
27  * DOCUMENT ME!
28  * 
29  * @author $author$
30  * @version $Revision$
31  */
32 public class MSFfile extends AlignFile
33 {
34
35   /**
36    * Creates a new MSFfile object.
37    */
38   public MSFfile()
39   {
40   }
41
42   /**
43    * Creates a new MSFfile object.
44    * 
45    * @param inFile
46    *          DOCUMENT ME!
47    * @param type
48    *          DOCUMENT ME!
49    * 
50    * @throws IOException
51    *           DOCUMENT ME!
52    */
53   public MSFfile(String inFile, String type) throws IOException
54   {
55     super(inFile, type);
56   }
57
58   public MSFfile(FileParse source) throws IOException
59   {
60     super(source);
61   }
62
63   {
64     // TODO Auto-generated constructor stub
65   }
66
67   /**
68    * DOCUMENT ME!
69    */
70   public void parse() throws IOException
71   {
72     int i = 0;
73     boolean seqFlag = false;
74     String key = new String();
75     Vector headers = new Vector();
76     Hashtable seqhash = new Hashtable();
77     String line;
78
79     try
80     {
81       while ((line = nextLine()) != null)
82       {
83         StringTokenizer str = new StringTokenizer(line);
84
85         while (str.hasMoreTokens())
86         {
87           String inStr = str.nextToken();
88
89           // If line has header information add to the headers vector
90           if (inStr.indexOf("Name:") != -1)
91           {
92             key = str.nextToken();
93             headers.addElement(key);
94           }
95
96           // if line has // set SeqFlag to 1 so we know sequences are coming
97           if (inStr.indexOf("//") != -1)
98           {
99             seqFlag = true;
100           }
101
102           // Process lines as sequence lines if seqFlag is set
103           if ((inStr.indexOf("//") == -1) && (seqFlag == true))
104           {
105             // seqeunce id is the first field
106             key = inStr;
107
108             StringBuffer tempseq;
109
110             // Get sequence from hash if it exists
111             if (seqhash.containsKey(key))
112             {
113               tempseq = (StringBuffer) seqhash.get(key);
114             }
115             else
116             {
117               tempseq = new StringBuffer();
118               seqhash.put(key, tempseq);
119             }
120
121             // loop through the rest of the words
122             while (str.hasMoreTokens())
123             {
124               // append the word to the sequence
125               tempseq.append(str.nextToken());
126             }
127           }
128         }
129       }
130     } catch (IOException e)
131     {
132       System.err.println("Exception parsing MSFFile " + e);
133       e.printStackTrace();
134     }
135
136     this.noSeqs = headers.size();
137
138     // Add sequences to the hash
139     for (i = 0; i < headers.size(); i++)
140     {
141       if (seqhash.get(headers.elementAt(i)) != null)
142       {
143         String head = headers.elementAt(i).toString();
144         String seq = seqhash.get(head).toString();
145
146         if (maxLength < head.length())
147         {
148           maxLength = head.length();
149         }
150
151         // Replace ~ with a sensible gap character
152         seq = seq.replace('~', '-');
153
154         Sequence newSeq = parseId(head);
155
156         newSeq.setSequence(seq);
157
158         seqs.addElement(newSeq);
159       }
160       else
161       {
162         System.err.println("MSFFile Parser: Can't find sequence for "
163                 + headers.elementAt(i));
164       }
165     }
166   }
167
168   /**
169    * DOCUMENT ME!
170    * 
171    * @param seq
172    *          DOCUMENT ME!
173    * 
174    * @return DOCUMENT ME!
175    */
176   public int checkSum(String seq)
177   {
178     int check = 0;
179     String sequence = seq.toUpperCase();
180
181     for (int i = 0; i < sequence.length(); i++)
182     {
183       try
184       {
185
186         int value = sequence.charAt(i);
187         if (value != -1)
188         {
189           check += (i % 57 + 1) * value;
190         }
191       } catch (Exception e)
192       {
193         System.err.println("Exception during MSF Checksum calculation");
194         e.printStackTrace();
195       }
196     }
197
198     return check % 10000;
199   }
200
201   /**
202    * DOCUMENT ME!
203    * 
204    * @param s
205    *          DOCUMENT ME!
206    * @param is_NA
207    *          DOCUMENT ME!
208    * 
209    * @return DOCUMENT ME!
210    */
211   public String print(SequenceI[] seqs)
212   {
213
214     boolean is_NA = jalview.util.Comparison.isNucleotide(seqs);
215
216     SequenceI[] s = new SequenceI[seqs.length];
217
218     StringBuffer out = new StringBuffer("!!" + (is_NA ? "NA" : "AA")
219             + "_MULTIPLE_ALIGNMENT 1.0");
220      // TODO: JBPNote : Jalview doesn't remember NA or AA yet.
221     out.append(newline);
222     out.append(newline);
223     int max = 0;
224     int maxid = 0;
225     int i = 0;
226
227     while ((i < seqs.length) && (seqs[i] != null))
228     {
229       // Replace all internal gaps with . and external spaces with ~
230       s[i] = new Sequence(seqs[i].getName(), seqs[i].getSequenceAsString()
231               .replace('-', '.'));
232
233       StringBuffer sb = new StringBuffer();
234       sb.append(s[i].getSequence());
235
236       for (int ii = 0; ii < sb.length(); ii++)
237       {
238         if (sb.charAt(ii) == '.')
239         {
240           sb.setCharAt(ii, '~');
241         }
242         else
243         {
244           break;
245         }
246       }
247
248       for (int ii = sb.length() - 1; ii > 0; ii--)
249       {
250         if (sb.charAt(ii) == '.')
251         {
252           sb.setCharAt(ii, '~');
253         }
254         else
255         {
256           break;
257         }
258       }
259
260       s[i].setSequence(sb.toString());
261
262       if (s[i].getSequence().length > max)
263       {
264         max = s[i].getSequence().length;
265       }
266
267       i++;
268     }
269
270     Format maxLenpad = new Format("%" + (new String("" + max)).length()
271             + "d");
272     Format maxChkpad = new Format("%" + (new String("1" + max)).length()
273             + "d");
274     i = 0;
275
276     int bigChecksum = 0;
277     int[] checksums = new int[s.length];
278     while (i < s.length)
279     {
280       checksums[i] = checkSum(s[i].getSequenceAsString());
281       bigChecksum += checksums[i];
282       i++;
283     }
284
285     long maxNB = 0;
286     out.append("   MSF: " + s[0].getSequence().length + "   Type: "
287             + (is_NA ? "N" : "P") + "    Check:  " + (bigChecksum % 10000)
288             + "   ..");
289     out.append(newline);
290     out.append(newline);
291     out.append(newline);
292
293     String[] nameBlock = new String[s.length];
294     String[] idBlock = new String[s.length];
295
296     i = 0;
297     while ((i < s.length) && (s[i] != null))
298     {
299
300       nameBlock[i] = new String("  Name: " + printId(s[i]) + " ");
301
302       idBlock[i] = new String("Len: "
303               + maxLenpad.form(s[i].getSequence().length) + "  Check: "
304               + maxChkpad.form(checksums[i]) + "  Weight: 1.00"+newline);
305
306       if (s[i].getName().length() > maxid)
307       {
308         maxid = s[i].getName().length();
309       }
310
311       if (nameBlock[i].length() > maxNB)
312       {
313         maxNB = nameBlock[i].length();
314       }
315
316       i++;
317     }
318
319     if (maxid < 10)
320     {
321       maxid = 10;
322     }
323
324     if (maxNB < 15)
325     {
326       maxNB = 15;
327     }
328
329     Format nbFormat = new Format("%-" + maxNB + "s");
330
331     for (i = 0; (i < s.length) && (s[i] != null); i++)
332     {
333       out.append(nbFormat.form(nameBlock[i]) + idBlock[i]);
334     }
335
336     maxid++;
337     out.append(newline);
338     out.append(newline);out.append("//");
339     out.append(newline);
340     out.append(newline);
341     int len = 50;
342
343     int nochunks = (max / len) + 1;
344
345     if ((max % len) == 0)
346     {
347       nochunks--;
348     }
349
350     for (i = 0; i < nochunks; i++)
351     {
352       int j = 0;
353
354       while ((j < s.length) && (s[j] != null))
355       {
356         String name = printId(s[j]);
357
358         out.append(new Format("%-" + maxid + "s").form(name + " "));
359
360         for (int k = 0; k < 5; k++)
361         {
362           int start = (i * 50) + (k * 10);
363           int end = start + 10;
364
365           if ((end < s[j].getSequence().length)
366                   && (start < s[j].getSequence().length))
367           {
368             out.append(s[j].getSequence(start, end));
369
370             if (k < 4)
371             {
372               out.append(" ");
373             }
374             else
375             {
376               out.append(newline);
377             }
378           }
379           else
380           {
381             if (start < s[j].getSequence().length)
382             {
383               out.append(s[j].getSequenceAsString().substring(start));
384               out.append(newline);
385             }
386             else
387             {
388               if (k == 0)
389               {
390                 out.append(newline);
391               }
392             }
393           }
394         }
395
396         j++;
397       }
398
399       out.append(newline);
400     }
401
402     return out.toString();
403   }
404
405   /**
406    * DOCUMENT ME!
407    * 
408    * @return DOCUMENT ME!
409    */
410   public String print()
411   {
412     return print(getSeqsAsArray());
413   }
414 }