src/jalview/io/StructureFile.java

   1 package jalview.io;
   2
   3 import jalview.analysis.AlignSeq;
   4 import jalview.api.FeatureSettingsModelI;
   5 import jalview.datamodel.Alignment;
   6 import jalview.datamodel.AlignmentAnnotation;
   7 import jalview.datamodel.AlignmentI;
   8 import jalview.datamodel.DBRefEntry;
   9 import jalview.datamodel.DBRefSource;
  10 import jalview.datamodel.PDBEntry;
  11 import jalview.datamodel.PDBEntry.Type;
  12 import jalview.datamodel.SequenceI;
  13 import jalview.structure.StructureImportSettings;
  14
  15 import java.awt.Color;
  16 import java.io.IOException;
  17 import java.lang.reflect.Constructor;
  18 import java.util.Hashtable;
  19 import java.util.List;
  20 import java.util.Vector;
  21
  22 import MCview.PDBChain;
  23
  24 public abstract class StructureFile extends AlignFile
  25 {
  26
  27   private String id;
  28
  29   private PDBEntry.Type dbRefType;
  30
  31   /**
  32    * set to true to add derived sequence annotations (temp factor read from
  33    * file, or computed secondary structure) to the alignment
  34    */
  35   protected boolean visibleChainAnnotation = false;
  36
  37   /**
  38    * Set true to predict secondary structure (using JMol for protein, Annotate3D
  39    * for RNA)
  40    */
  41   protected boolean predictSecondaryStructure = false;
  42
  43   /**
  44    * Set true (with predictSecondaryStructure=true) to predict secondary
  45    * structure using an external service (currently Annotate3D for RNA only)
  46    */
  47   protected boolean externalSecondaryStructure = false;
  48
  49   private Vector<PDBChain> chains;
  50
  51   public StructureFile(String inFile, String type) throws IOException
  52   {
  53     super(inFile, type);
  54   }
  55
  56   public StructureFile(FileParse fp) throws IOException
  57   {
  58     super(fp);
  59   }
  60
  61   public void addSettings(boolean addAlignmentAnnotations,
  62           boolean predictSecondaryStructure, boolean externalSecStr)
  63   {
  64     this.visibleChainAnnotation = addAlignmentAnnotations;
  65     this.predictSecondaryStructure = predictSecondaryStructure;
  66     this.externalSecondaryStructure = externalSecStr;
  67   }
  68
  69   public void xferSettings()
  70   {
  71     this.visibleChainAnnotation = StructureImportSettings
  72             .isVisibleChainAnnotation();
  73     this.predictSecondaryStructure = StructureImportSettings
  74             .isProcessSecondaryStructure();
  75     this.externalSecondaryStructure = StructureImportSettings
  76             .isExternalSecondaryStructure();
  77
  78   }
  79
  80   public StructureFile(boolean parseImmediately, String dataObject,
  81           String type) throws IOException
  82   {
  83     super(parseImmediately, dataObject, type);
  84   }
  85
  86   public StructureFile(boolean a, FileParse fp) throws IOException
  87   {
  88     super(a, fp);
  89   }
  90
  91   public StructureFile()
  92   {
  93   }
  94
  95   @SuppressWarnings("rawtypes")
  96   protected SequenceI postProcessChain(PDBChain chain)
  97   {
  98     SequenceI pdbSequence = chain.sequence;
  99     pdbSequence.setName(getId() + "|" + pdbSequence.getName());
 100     PDBEntry entry = new PDBEntry();
 101     entry.setId(getId());
 102     entry.setType(getStructureFileType());
 103     entry.setProperty(new Hashtable());
 104     if (chain.id != null)
 105     {
 106       entry.setChainCode(String.valueOf(chain.id));
 107     }
 108     if (inFile != null)
 109     {
 110       entry.setFile(inFile.getAbsolutePath());
 111     }
 112     else
 113     {
 114       entry.setFile(getDataName());
 115     }
 116
 117     DBRefEntry sourceDBRef = new DBRefEntry();
 118     sourceDBRef.setAccessionId(getId());
 119     sourceDBRef.setSource(DBRefSource.PDB);
 120     // TODO: specify version for 'PDB' database ref if it is read from a file.
 121     // TODO: decide if jalview.io should be creating primary refs!
 122     sourceDBRef.setVersion("");
 123     pdbSequence.addPDBId(entry);
 124     pdbSequence.addDBRef(sourceDBRef);
 125     SequenceI chainseq = pdbSequence;
 126     seqs.addElement(chainseq);
 127     AlignmentAnnotation[] chainannot = chainseq.getAnnotation();
 128
 129     if (chainannot != null && visibleChainAnnotation)
 130     {
 131       for (int ai = 0; ai < chainannot.length; ai++)
 132       {
 133         chainannot[ai].visible = visibleChainAnnotation;
 134         annotations.addElement(chainannot[ai]);
 135       }
 136     }
 137     return chainseq;
 138   }
 139
 140   /**
 141    * filetype of structure file - default is PDB
 142    */
 143   String structureFileType = PDBEntry.Type.PDB.toString();
 144
 145   protected void setStructureFileType(String structureFileType)
 146   {
 147     this.structureFileType = structureFileType;
 148   }
 149
 150   /**
 151    * filetype of last file processed
 152    *
 153    * @return
 154    */
 155   public String getStructureFileType()
 156   {
 157     return structureFileType;
 158   }
 159
 160   @SuppressWarnings({ "unchecked", "rawtypes" })
 161   protected void processPdbFileWithAnnotate3d(List<SequenceI> rna)
 162           throws Exception
 163   {
 164     // System.out.println("this is a PDB format and RNA sequence");
 165     // note: we use reflection here so that the applet can compile and run
 166     // without the HTTPClient bits and pieces needed for accessing Annotate3D
 167     // web service
 168     try
 169     {
 170       Class cl = Class.forName("jalview.ws.jws1.Annotate3D");
 171       if (cl != null)
 172       {
 173         // TODO: use the PDB ID of the structure if one is available, to save
 174         // bandwidth and avoid uploading the whole structure to the service
 175         Object annotate3d = cl.getConstructor(new Class[] {}).newInstance(
 176                 new Object[] {});
 177         AlignmentI al = ((AlignmentI) cl.getMethod("getRNAMLFor",
 178                 new Class[] { FileParse.class }).invoke(annotate3d,
 179                 new Object[] { new FileParse(getDataName(), type) }));
 180         for (SequenceI sq : al.getSequences())
 181         {
 182           if (sq.getDatasetSequence() != null)
 183           {
 184             if (sq.getDatasetSequence().getAllPDBEntries() != null)
 185             {
 186               sq.getDatasetSequence().getAllPDBEntries().clear();
 187             }
 188           }
 189           else
 190           {
 191             if (sq.getAllPDBEntries() != null)
 192             {
 193               sq.getAllPDBEntries().clear();
 194             }
 195           }
 196         }
 197         replaceAndUpdateChains(rna, al, AlignSeq.DNA, false);
 198       }
 199     } catch (ClassNotFoundException x)
 200     {
 201       // ignore classnotfounds - occurs in applet
 202     }
 203   }
 204
 205   @SuppressWarnings("unchecked")
 206   protected void replaceAndUpdateChains(List<SequenceI> prot,
 207           AlignmentI al, String pep, boolean b)
 208   {
 209     List<List<? extends Object>> replaced = AlignSeq
 210             .replaceMatchingSeqsWith(seqs, annotations, prot, al, pep,
 211                     false);
 212     for (PDBChain ch : getChains())
 213     {
 214       int p = 0;
 215       for (SequenceI sq : (List<SequenceI>) replaced.get(0))
 216       {
 217         p++;
 218         if (sq == ch.sequence || sq.getDatasetSequence() == ch.sequence)
 219         {
 220           p = -p;
 221           break;
 222         }
 223       }
 224       if (p < 0)
 225       {
 226         p = -p - 1;
 227         // set shadow entry for chains
 228         ch.shadow = (SequenceI) replaced.get(1).get(p);
 229         ch.shadowMap = ((AlignSeq) replaced.get(2).get(p))
 230                 .getMappingFromS1(false);
 231       }
 232     }
 233   }
 234
 235   /**
 236    * Predict secondary structure for RNA and/or protein sequences and add as
 237    * annotations
 238    *
 239    * @param rnaSequences
 240    * @param proteinSequences
 241    */
 242   protected void addSecondaryStructure(List<SequenceI> rnaSequences,
 243           List<SequenceI> proteinSequences)
 244   {
 245     /*
 246      * Currently using Annotate3D for RNA, but only if the 'use external
 247      * prediction' flag is set
 248      */
 249     if (externalSecondaryStructure && rnaSequences.size() > 0)
 250     {
 251       try
 252       {
 253         processPdbFileWithAnnotate3d(rnaSequences);
 254       } catch (Exception x)
 255       {
 256         System.err.println("Exceptions when dealing with RNA in pdb file");
 257         x.printStackTrace();
 258
 259       }
 260     }
 261
 262     /*
 263      * Currently using JMol PDB parser for peptide
 264      */
 265     if (proteinSequences.size() > 0)
 266     {
 267       try
 268       {
 269         processWithJmolParser(proteinSequences);
 270       } catch (Exception x)
 271       {
 272         System.err
 273                 .println("Exceptions from Jmol when processing data in pdb file");
 274         x.printStackTrace();
 275       }
 276     }
 277   }
 278
 279   @SuppressWarnings({ "unchecked", "rawtypes" })
 280   private void processWithJmolParser(List<SequenceI> prot) throws Exception
 281   {
 282     try
 283     {
 284
 285       Class cl = Class.forName("jalview.ext.jmol.JmolParser");
 286       if (cl != null)
 287       {
 288         final Constructor constructor = cl
 289                 .getConstructor(new Class[] { FileParse.class });
 290         final Object[] args = new Object[] { new FileParse(getDataName(),
 291                 type) };
 292
 293         StructureImportSettings.setShowSeqFeatures(false);
 294         StructureImportSettings.setVisibleChainAnnotation(false);
 295         StructureImportSettings
 296                 .setProcessSecondaryStructure(predictSecondaryStructure);
 297         StructureImportSettings
 298                 .setExternalSecondaryStructure(externalSecondaryStructure);
 299         Object jmf = constructor.newInstance(args);
 300         AlignmentI al = new Alignment((SequenceI[]) cl.getMethod(
 301                 "getSeqsAsArray", new Class[] {}).invoke(jmf));
 302         cl.getMethod("addAnnotations", new Class[] { AlignmentI.class })
 303                 .invoke(jmf, al);
 304         for (SequenceI sq : al.getSequences())
 305         {
 306           if (sq.getDatasetSequence() != null)
 307           {
 308             sq.getDatasetSequence().getAllPDBEntries().clear();
 309           }
 310           else
 311           {
 312             sq.getAllPDBEntries().clear();
 313           }
 314         }
 315         replaceAndUpdateChains(prot, al, AlignSeq.PEP, false);
 316       }
 317     } catch (ClassNotFoundException q)
 318     {
 319     }
 320     StructureImportSettings.setShowSeqFeatures(true);
 321   }
 322
 323   public PDBChain findChain(String id) throws Exception
 324   {
 325     for (PDBChain chain : getChains())
 326     {
 327       if (chain.id.equals(id))
 328       {
 329         return chain;
 330       }
 331     }
 332     throw new Exception("PDB chain not Found!");
 333   }
 334
 335   public void makeResidueList()
 336   {
 337     for (PDBChain chain : getChains())
 338     {
 339       chain.makeResidueList(visibleChainAnnotation);
 340     }
 341   }
 342
 343   public void makeCaBondList()
 344   {
 345     for (PDBChain chain : getChains())
 346     {
 347       chain.makeCaBondList();
 348     }
 349   }
 350
 351   public void setChargeColours()
 352   {
 353     for (PDBChain chain : getChains())
 354     {
 355       chain.setChargeColours();
 356     }
 357   }
 358
 359   public void setColours(jalview.schemes.ColourSchemeI cs)
 360   {
 361     for (PDBChain chain : getChains())
 362     {
 363       chain.setChainColours(cs);
 364     }
 365   }
 366
 367   public void setChainColours()
 368   {
 369     int i = 0;
 370     for (PDBChain chain : getChains())
 371     {
 372       chain.setChainColours(Color.getHSBColor(1.0f / i++, .4f, 1.0f));
 373     }
 374   }
 375
 376   public static boolean isRNA(SequenceI seq)
 377   {
 378     for (char c : seq.getSequence())
 379     {
 380       if ((c != 'A') && (c != 'C') && (c != 'G') && (c != 'U'))
 381       {
 382         return false;
 383       }
 384     }
 385     return true;
 386   }
 387
 388   /**
 389    * make a friendly ID string.
 390    *
 391    * @param dataName
 392    * @return truncated dataName to after last '/'
 393    */
 394   protected String safeName(String dataName)
 395   {
 396     int p = 0;
 397     while ((p = dataName.indexOf("/")) > -1 && p < dataName.length())
 398     {
 399       dataName = dataName.substring(p + 1);
 400     }
 401     return dataName;
 402   }
 403
 404   public String getId()
 405   {
 406     return id;
 407   }
 408
 409   public void setId(String id)
 410   {
 411     this.id = id;
 412   }
 413
 414   public Vector<PDBChain> getChains()
 415   {
 416     return chains;
 417   }
 418
 419   public void setChains(Vector<PDBChain> chains)
 420   {
 421     this.chains = chains;
 422   }
 423
 424   public Type getDbRefType()
 425   {
 426     return dbRefType;
 427   }
 428
 429   public void setDbRefType(String dbRefType)
 430   {
 431     this.dbRefType = Type.getType(dbRefType);
 432   }
 433
 434   public void setDbRefType(Type dbRefType)
 435   {
 436     this.dbRefType = dbRefType;
 437   }
 438
 439   /**
 440    * Returns a descriptor for suitable feature display settings with
 441    * <ul>
 442    * <li>ResNums or insertions features visible</li>
 443    * <li>insertions features coloured red</li>
 444    * <li>ResNum features coloured by label</li>
 445    * <li>Insertions displayed above (on top of) ResNums</li>
 446    * </ul>
 447    */
 448   @Override
 449   public FeatureSettingsModelI getFeatureColourScheme()
 450   {
 451     return new PDBFeatureSettings();
 452   }
 453 }