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