JAL-2465 bugfix and rerefactor renamed getPdbFile() method to getStructureFile()
[jalview.git] / src / jalview / ext / jmol / JmolParser.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.ext.jmol;
22
23 import jalview.datamodel.AlignmentAnnotation;
24 import jalview.datamodel.Annotation;
25 import jalview.datamodel.PDBEntry;
26 import jalview.datamodel.SequenceI;
27 import jalview.io.DataSourceType;
28 import jalview.io.FileParse;
29 import jalview.io.StructureFile;
30 import jalview.schemes.ResidueProperties;
31 import jalview.structure.StructureImportSettings;
32 import jalview.util.Format;
33 import jalview.util.MessageManager;
34
35 import java.io.IOException;
36 import java.util.ArrayList;
37 import java.util.HashMap;
38 import java.util.List;
39 import java.util.Map;
40 import java.util.Vector;
41
42 import org.jmol.api.JmolStatusListener;
43 import org.jmol.api.JmolViewer;
44 import org.jmol.c.CBK;
45 import org.jmol.c.STR;
46 import org.jmol.modelset.ModelSet;
47 import org.jmol.viewer.Viewer;
48
49 import MCview.Atom;
50 import MCview.PDBChain;
51 import MCview.Residue;
52
53 /**
54  * Import and process files with Jmol for file like PDB, mmCIF
55  * 
56  * @author jprocter
57  * 
58  */
59 public class JmolParser extends StructureFile implements JmolStatusListener
60 {
61   Viewer viewer = null;
62
63   public JmolParser(String inFile, DataSourceType sourceType)
64           throws IOException
65   {
66     super(inFile, sourceType);
67   }
68
69   public JmolParser(FileParse fp) throws IOException
70   {
71     super(fp);
72   }
73
74   public JmolParser()
75   {
76   }
77
78   /**
79    * Calls the Jmol library to parse the PDB/mmCIF file, and then inspects the
80    * resulting object model to generate Jalview-style sequences, with secondary
81    * structure annotation added where available (i.e. where it has been computed
82    * by Jmol using DSSP).
83    * 
84    * @see jalview.io.AlignFile#parse()
85    */
86   @Override
87   public void parse() throws IOException
88   {
89     setChains(new Vector<PDBChain>());
90     Viewer jmolModel = getJmolData();
91     jmolModel.openReader(getDataName(), getDataName(), getReader());
92     waitForScript(jmolModel);
93
94     /*
95      * Convert one or more Jmol Model objects to Jalview sequences
96      */
97     if (jmolModel.ms.mc > 0)
98     {
99       // ideally we do this
100       // try
101       // {
102       // setStructureFileType(jmolModel.evalString("show _fileType"));
103       // } catch (Exception q)
104       // {
105       // }
106       // ;
107       // instead, we distinguish .cif from non-.cif by filename
108       setStructureFileType(getDataName().toLowerCase().endsWith(".cif") ? PDBEntry.Type.MMCIF
109               .toString() : "PDB");
110
111       transformJmolModelToJalview(jmolModel.ms);
112     }
113   }
114
115   /**
116    * create a headless jmol instance for dataprocessing
117    * 
118    * @return
119    */
120   private Viewer getJmolData()
121   {
122     if (viewer == null)
123     {
124       try
125       {
126         /*
127          * params -o (output to sysout) -n (nodisplay) -x (exit when finished)
128          * see http://wiki.jmol.org/index.php/Jmol_Application
129          */
130         viewer = (Viewer) JmolViewer.allocateViewer(null, null, null, null,
131                 null, "-x -o -n", this);
132         // ensure the 'new' (DSSP) not 'old' (Ramachandran) SS method is used
133         viewer.setBooleanProperty("defaultStructureDSSP", true);
134       } catch (ClassCastException x)
135       {
136         throw new Error(MessageManager.formatMessage(
137                 "error.jmol_version_not_compatible_with_jalview_version",
138                 new String[] { JmolViewer.getJmolVersion() }), x);
139       }
140     }
141     return viewer;
142   }
143
144   public void transformJmolModelToJalview(ModelSet ms) throws IOException
145   {
146     try
147     {
148       String lastID = "";
149       List<SequenceI> rna = new ArrayList<SequenceI>();
150       List<SequenceI> prot = new ArrayList<SequenceI>();
151       PDBChain tmpchain;
152       String pdbId = (String) ms.getInfo(0, "title");
153
154       if (pdbId == null)
155       {
156         setId(safeName(getDataName()));
157         setPDBIdAvailable(false);
158       }
159       else
160       {
161         setId(pdbId);
162         setPDBIdAvailable(true);
163       }
164       List<Atom> significantAtoms = convertSignificantAtoms(ms);
165       for (Atom tmpatom : significantAtoms)
166       {
167         try
168         {
169           tmpchain = findChain(tmpatom.chain);
170           if (tmpatom.resNumIns.trim().equals(lastID))
171           {
172             // phosphorylated protein - seen both CA and P..
173             continue;
174           }
175           tmpchain.atoms.addElement(tmpatom);
176         } catch (Exception e)
177         {
178           tmpchain = new PDBChain(getId(), tmpatom.chain);
179           getChains().add(tmpchain);
180           tmpchain.atoms.addElement(tmpatom);
181         }
182         lastID = tmpatom.resNumIns.trim();
183       }
184       xferSettings();
185
186       makeResidueList();
187       makeCaBondList();
188
189       if (getId() == null)
190       {
191         // always use resource name, not the hardwired file
192         // Does the value of ID get used ? Behaviour needs to be
193         // documented and tested
194         setId(getDataName());
195       }
196
197       for (PDBChain chain : getChains())
198       {
199         SequenceI chainseq = postProcessChain(chain);
200         if (isRNA(chainseq))
201         {
202           rna.add(chainseq);
203         }
204         else
205         {
206           prot.add(chainseq);
207         }
208
209         if (StructureImportSettings.isProcessSecondaryStructure())
210         {
211           createAnnotation(chainseq, chain, ms.at);
212         }
213       }
214     } catch (OutOfMemoryError er)
215     {
216       System.out
217               .println("OUT OF MEMORY LOADING TRANSFORMING JMOL MODEL TO JALVIEW MODEL");
218       throw new IOException(
219               MessageManager
220                       .getString("exception.outofmemory_loading_mmcif_file"));
221     }
222   }
223
224   private List<Atom> convertSignificantAtoms(ModelSet ms)
225   {
226     List<Atom> significantAtoms = new ArrayList<Atom>();
227     HashMap<String, org.jmol.modelset.Atom> chainTerMap = new HashMap<String, org.jmol.modelset.Atom>();
228     org.jmol.modelset.Atom prevAtom = null;
229     for (org.jmol.modelset.Atom atom : ms.at)
230     {
231       if (atom.getAtomName().equalsIgnoreCase("CA")
232               || atom.getAtomName().equalsIgnoreCase("P"))
233       {
234         if (!atomValidated(atom, prevAtom, chainTerMap))
235         {
236           continue;
237         }
238         Atom curAtom = new Atom(atom.x, atom.y, atom.z);
239         curAtom.atomIndex = atom.getIndex();
240         curAtom.chain = atom.getChainIDStr();
241         curAtom.insCode = atom.group.getInsertionCode() == '\000' ? ' '
242                 : atom.group.getInsertionCode();
243         curAtom.name = atom.getAtomName();
244         curAtom.number = atom.getAtomNumber();
245         curAtom.resName = atom.getGroup3(true);
246         curAtom.resNumber = atom.getResno();
247         curAtom.occupancy = ms.occupancies != null ? ms.occupancies[atom
248                 .getIndex()] : Float.valueOf(atom.getOccupancy100());
249         String fmt = new Format("%4i").form(curAtom.resNumber);
250         curAtom.resNumIns = (fmt + curAtom.insCode);
251         curAtom.tfactor = atom.getBfactor100() / 100f;
252         curAtom.type = 0;
253         // significantAtoms.add(curAtom);
254         // ignore atoms from subsequent models
255         if (!significantAtoms.contains(curAtom))
256         {
257           significantAtoms.add(curAtom);
258         }
259         prevAtom = atom;
260       }
261     }
262     return significantAtoms;
263   }
264
265   private boolean atomValidated(org.jmol.modelset.Atom curAtom,
266           org.jmol.modelset.Atom prevAtom,
267           HashMap<String, org.jmol.modelset.Atom> chainTerMap)
268   {
269     // System.out.println("Atom: " + curAtom.getAtomNumber()
270     // + "   Last atom index " + curAtom.group.lastAtomIndex);
271     if (chainTerMap == null || prevAtom == null)
272     {
273       return true;
274     }
275     String curAtomChId = curAtom.getChainIDStr();
276     String prevAtomChId = prevAtom.getChainIDStr();
277     // new chain encoutered
278     if (!prevAtomChId.equals(curAtomChId))
279     {
280       // On chain switch add previous chain termination to xTerMap if not exists
281       if (!chainTerMap.containsKey(prevAtomChId))
282       {
283         chainTerMap.put(prevAtomChId, prevAtom);
284       }
285       // if current atom belongs to an already terminated chain and the resNum
286       // diff < 5 then mark as valid and update termination Atom
287       if (chainTerMap.containsKey(curAtomChId))
288       {
289         if (curAtom.getResno() < chainTerMap.get(curAtomChId).getResno())
290         {
291           return false;
292         }
293         if ((curAtom.getResno() - chainTerMap.get(curAtomChId).getResno()) < 5)
294         {
295           chainTerMap.put(curAtomChId, curAtom);
296           return true;
297         }
298         return false;
299       }
300     }
301     // atom with previously terminated chain encountered
302     else if (chainTerMap.containsKey(curAtomChId))
303     {
304       if (curAtom.getResno() < chainTerMap.get(curAtomChId).getResno())
305       {
306         return false;
307       }
308       if ((curAtom.getResno() - chainTerMap.get(curAtomChId).getResno()) < 5)
309       {
310         chainTerMap.put(curAtomChId, curAtom);
311         return true;
312       }
313       return false;
314     }
315     // HETATM with resNum jump > 2
316     return !(curAtom.isHetero() && ((curAtom.getResno() - prevAtom
317             .getResno()) > 2));
318   }
319
320   private void createAnnotation(SequenceI sequence, PDBChain chain,
321           org.jmol.modelset.Atom[] jmolAtoms)
322   {
323     char[] secstr = new char[sequence.getLength()];
324     char[] secstrcode = new char[sequence.getLength()];
325
326     // Ensure Residue size equals Seq size
327     if (chain.residues.size() != sequence.getLength())
328     {
329       return;
330     }
331     int annotIndex = 0;
332     for (Residue residue : chain.residues)
333     {
334       Atom repAtom = residue.getAtoms().get(0);
335       STR proteinStructureSubType = jmolAtoms[repAtom.atomIndex].group
336               .getProteinStructureSubType();
337       setSecondaryStructure(proteinStructureSubType, annotIndex, secstr,
338               secstrcode);
339       ++annotIndex;
340     }
341     addSecondaryStructureAnnotation(chain.pdbid, sequence, secstr,
342             secstrcode, chain.id, sequence.getStart());
343   }
344
345   /**
346    * Helper method that adds an AlignmentAnnotation for secondary structure to
347    * the sequence, provided at least one secondary structure prediction has been
348    * made
349    * 
350    * @param modelTitle
351    * @param seq
352    * @param secstr
353    * @param secstrcode
354    * @param chainId
355    * @param firstResNum
356    * @return
357    */
358   protected void addSecondaryStructureAnnotation(String modelTitle,
359           SequenceI sq, char[] secstr, char[] secstrcode, String chainId,
360           int firstResNum)
361   {
362     char[] seq = sq.getSequence();
363     boolean ssFound = false;
364     Annotation asecstr[] = new Annotation[seq.length + firstResNum - 1];
365     for (int p = 0; p < seq.length; p++)
366     {
367       if (secstr[p] >= 'A' && secstr[p] <= 'z')
368       {
369         try
370         {
371           asecstr[p] = new Annotation(String.valueOf(secstr[p]), null,
372                   secstrcode[p], Float.NaN);
373           ssFound = true;
374         } catch (Exception e)
375         {
376           // e.printStackTrace();
377         }
378       }
379     }
380
381     if (ssFound)
382     {
383       String mt = modelTitle == null ? getDataName() : modelTitle;
384       mt += chainId;
385       AlignmentAnnotation ann = new AlignmentAnnotation(
386               "Secondary Structure", "Secondary Structure for " + mt,
387               asecstr);
388       ann.belowAlignment = true;
389       ann.visible = true;
390       ann.autoCalculated = false;
391       ann.setCalcId(getClass().getName());
392       ann.adjustForAlignment();
393       ann.validateRangeAndDisplay();
394       annotations.add(ann);
395       sq.addAlignmentAnnotation(ann);
396     }
397   }
398
399   private void waitForScript(Viewer jmd)
400   {
401     while (jmd.isScriptExecuting())
402     {
403       try
404       {
405         Thread.sleep(50);
406
407       } catch (InterruptedException x)
408       {
409       }
410     }
411   }
412
413   /**
414    * Convert Jmol's secondary structure code to Jalview's, and stored it in the
415    * secondary structure arrays at the given sequence position
416    * 
417    * @param proteinStructureSubType
418    * @param pos
419    * @param secstr
420    * @param secstrcode
421    */
422   protected void setSecondaryStructure(STR proteinStructureSubType,
423           int pos, char[] secstr, char[] secstrcode)
424   {
425     switch (proteinStructureSubType)
426     {
427     case HELIX310:
428       secstr[pos] = '3';
429       break;
430     case HELIX:
431     case HELIXALPHA:
432       secstr[pos] = 'H';
433       break;
434     case HELIXPI:
435       secstr[pos] = 'P';
436       break;
437     case SHEET:
438       secstr[pos] = 'E';
439       break;
440     default:
441       secstr[pos] = 0;
442     }
443
444     switch (proteinStructureSubType)
445     {
446     case HELIX310:
447     case HELIXALPHA:
448     case HELIXPI:
449     case HELIX:
450       secstrcode[pos] = 'H';
451       break;
452     case SHEET:
453       secstrcode[pos] = 'E';
454       break;
455     default:
456       secstrcode[pos] = 0;
457     }
458   }
459
460   /**
461    * Convert any non-standard peptide codes to their standard code table
462    * equivalent. (Initial version only does Selenomethionine MSE->MET.)
463    * 
464    * @param threeLetterCode
465    * @param seq
466    * @param pos
467    */
468   protected void replaceNonCanonicalResidue(String threeLetterCode,
469           char[] seq, int pos)
470   {
471     String canonical = ResidueProperties
472             .getCanonicalAminoAcid(threeLetterCode);
473     if (canonical != null && !canonical.equalsIgnoreCase(threeLetterCode))
474     {
475       seq[pos] = ResidueProperties.getSingleCharacterCode(canonical);
476     }
477   }
478
479   /**
480    * Not implemented - returns null
481    */
482   @Override
483   public String print(SequenceI[] seqs, boolean jvSuffix)
484   {
485     return null;
486   }
487
488   /**
489    * Not implemented
490    */
491   @Override
492   public void setCallbackFunction(String callbackType,
493           String callbackFunction)
494   {
495   }
496
497   @Override
498   public void notifyCallback(CBK cbType, Object[] data)
499   {
500     String strInfo = (data == null || data[1] == null ? null : data[1]
501             .toString());
502     switch (cbType)
503     {
504     case ECHO:
505       sendConsoleEcho(strInfo);
506       break;
507     case SCRIPT:
508       notifyScriptTermination((String) data[2],
509               ((Integer) data[3]).intValue());
510       break;
511     case MEASURE:
512       String mystatus = (String) data[3];
513       if (mystatus.indexOf("Picked") >= 0
514               || mystatus.indexOf("Sequence") >= 0)
515       {
516         // Picking mode
517         sendConsoleMessage(strInfo);
518       }
519       else if (mystatus.indexOf("Completed") >= 0)
520       {
521         sendConsoleEcho(strInfo.substring(strInfo.lastIndexOf(",") + 2,
522                 strInfo.length() - 1));
523       }
524       break;
525     case MESSAGE:
526       sendConsoleMessage(data == null ? null : strInfo);
527       break;
528     case PICK:
529       sendConsoleMessage(strInfo);
530       break;
531     default:
532       break;
533     }
534   }
535
536   String lastConsoleEcho = "";
537
538   private void sendConsoleEcho(String string)
539   {
540     lastConsoleEcho += string;
541     lastConsoleEcho += "\n";
542   }
543
544   String lastConsoleMessage = "";
545
546   private void sendConsoleMessage(String string)
547   {
548     lastConsoleMessage += string;
549     lastConsoleMessage += "\n";
550   }
551
552   int lastScriptTermination = -1;
553
554   String lastScriptMessage = "";
555
556   private void notifyScriptTermination(String string, int intValue)
557   {
558     lastScriptMessage += string;
559     lastScriptMessage += "\n";
560     lastScriptTermination = intValue;
561   }
562
563   @Override
564   public boolean notifyEnabled(CBK callbackPick)
565   {
566     switch (callbackPick)
567     {
568     case MESSAGE:
569     case SCRIPT:
570     case ECHO:
571     case LOADSTRUCT:
572     case ERROR:
573       return true;
574     default:
575       return false;
576     }
577   }
578
579   /**
580    * Not implemented - returns null
581    */
582   @Override
583   public String eval(String strEval)
584   {
585     return null;
586   }
587
588   /**
589    * Not implemented - returns null
590    */
591   @Override
592   public float[][] functionXY(String functionName, int x, int y)
593   {
594     return null;
595   }
596
597   /**
598    * Not implemented - returns null
599    */
600   @Override
601   public float[][][] functionXYZ(String functionName, int nx, int ny, int nz)
602   {
603     return null;
604   }
605
606   /**
607    * Not implemented - returns null
608    */
609   @Override
610   public String createImage(String fileName, String imageType,
611           Object text_or_bytes, int quality)
612   {
613     return null;
614   }
615
616   /**
617    * Not implemented - returns null
618    */
619   @Override
620   public Map<String, Object> getRegistryInfo()
621   {
622     return null;
623   }
624
625   /**
626    * Not implemented
627    */
628   @Override
629   public void showUrl(String url)
630   {
631   }
632
633   /**
634    * Not implemented - returns null
635    */
636   @Override
637   public int[] resizeInnerPanel(String data)
638   {
639     return null;
640   }
641
642   @Override
643   public Map<String, Object> getJSpecViewProperty(String arg0)
644   {
645     return null;
646   }
647
648   public boolean isPredictSecondaryStructure()
649   {
650     return predictSecondaryStructure;
651   }
652
653   public void setPredictSecondaryStructure(boolean predictSecondaryStructure)
654   {
655     this.predictSecondaryStructure = predictSecondaryStructure;
656   }
657
658   public boolean isVisibleChainAnnotation()
659   {
660     return visibleChainAnnotation;
661   }
662
663   public void setVisibleChainAnnotation(boolean visibleChainAnnotation)
664   {
665     this.visibleChainAnnotation = visibleChainAnnotation;
666   }
667
668 }