+ for (PDBChain chain : chains)
+ {
+ SequenceI chainseq = postProcessChain(chain);
+ if (isRNA(chainseq))
+ {
+ rna.add(chainseq);
+ }
+ else
+ {
+ prot.add(chainseq);
+ }
+ }
+ if (predictSecondaryStructure)
+ {
+ predictSecondaryStructure(rna, prot);
+ }
+ } catch (OutOfMemoryError er)
+ {
+ System.out.println("OUT OF MEMORY LOADING PDB FILE");
+ throw new IOException(
+ MessageManager
+ .getString("exception.outofmemory_loading_pdb_file"));
+ } catch (NumberFormatException ex)
+ {
+ if (line != null)
+ {
+ System.err.println("Couldn't read number from line:");
+ System.err.println(line);
+ }
+ }
+ markCalcIds();
+ }
+
+ /**
+ * Predict secondary structure for RNA and/or protein sequences and add as
+ * annotations
+ *
+ * @param rnaSequences
+ * @param proteinSequences
+ */
+ protected void predictSecondaryStructure(List<SequenceI> rnaSequences,
+ List<SequenceI> proteinSequences)
+ {
+ /*
+ * Currently using Annotate3D for RNA, but only if the 'use external
+ * prediction' flag is set
+ */
+ if (externalSecondaryStructure && rnaSequences.size() > 0)
+ {
+ try
+ {
+ processPdbFileWithAnnotate3d(rnaSequences);
+ } catch (Exception x)
+ {
+ System.err
+ .println("Exceptions when dealing with RNA in pdb file");
+ x.printStackTrace();
+
+ }
+ }
+
+ /*
+ * Currently using JMol PDB parser for peptide
+ */
+ if (proteinSequences.size() > 0)
+ {
+ try
+ {
+ processPdbFileWithJmol(proteinSequences);
+ } catch (Exception x)
+ {
+ System.err
+ .println("Exceptions from Jmol when processing data in pdb file");
+ x.printStackTrace();
+ }
+ }
+ }
+
+ /**
+ * Process a parsed chain to construct and return a Sequence, and add it to
+ * the list of sequences parsed.
+ *
+ * @param chain
+ * @return
+ */
+ protected SequenceI postProcessChain(PDBChain chain)
+ {
+ SequenceI dataset = chain.sequence;
+ dataset.setName(id + "|" + dataset.getName());
+ PDBEntry entry = new PDBEntry();
+ entry.setId(id);
+ entry.setType(PDBEntry.Type.PDB);
+ entry.setProperty(new Hashtable());
+ if (chain.id != null)
+ {
+ // entry.getProperty().put("CHAIN", chains.elementAt(i).id);
+ entry.setChainCode(String.valueOf(chain.id));
+ }
+ if (inFile != null)
+ {
+ entry.setFile(inFile.getAbsolutePath());
+ }
+ else
+ {
+ // TODO: decide if we should dump the datasource to disk
+ entry.setFile(getDataName());
+ }
+ dataset.addPDBId(entry);
+ // PDBChain objects maintain reference to dataset
+ SequenceI chainseq = dataset.deriveSequence();
+ seqs.addElement(chainseq);
+
+ AlignmentAnnotation[] chainannot = chainseq.getAnnotation();
+
+ if (chainannot != null && visibleChainAnnotation)
+ {
+ for (int ai = 0; ai < chainannot.length; ai++)
+ {
+ chainannot[ai].visible = visibleChainAnnotation;
+ annotations.addElement(chainannot[ai]);
+ }
+ }
+ return chainseq;
+ }
+
+ public static boolean isCalcIdHandled(String calcId)
+ {
+ return calcId != null && (CALC_ID_PREFIX.equals(calcId));
+ }
+
+ public static boolean isCalcIdForFile(AlignmentAnnotation alan,
+ String pdbFile)
+ {
+ return alan.getCalcId() != null
+ && CALC_ID_PREFIX.equals(alan.getCalcId())
+ && pdbFile.equals(alan.getProperty("PDBID"));
+ }
+
+ public static String relocateCalcId(String calcId,
+ Hashtable<String, String> alreadyLoadedPDB) throws Exception
+ {
+ int s = CALC_ID_PREFIX.length(), end = calcId.indexOf(CALC_ID_PREFIX, s);
+ String between = calcId.substring(s, end - 1);
+ return CALC_ID_PREFIX + alreadyLoadedPDB.get(between) + ":"
+ + calcId.substring(end);
+ }
+
+ private void markCalcIds()
+ {
+ for (SequenceI sq : seqs)
+ {
+ if (sq.getAnnotation() != null)
+ {
+ for (AlignmentAnnotation aa : sq.getAnnotation())
+ {
+ String oldId = aa.getCalcId();
+ if (oldId == null)
+ {
+ oldId = "";
+ }
+ aa.setCalcId(CALC_ID_PREFIX);
+ aa.setProperty("PDBID", id);
+ aa.setProperty("oldCalcId", oldId);
+ }
+ }
+ }
+ }
+
+ private void processPdbFileWithJmol(List<SequenceI> prot)
+ throws Exception
+ {
+ try
+ {
+ Class cl = Class.forName("jalview.ext.jmol.PDBFileWithJmol");
+ if (cl != null)
+ {
+ final Constructor constructor = cl.getConstructor(new Class[]
+ { FileParse.class });
+ final Object[] args = new Object[]
+ { new FileParse(getDataName(), type) };
+ Object jmf = constructor.newInstance(args);
+ AlignmentI al = new Alignment((SequenceI[]) cl.getMethod(
+ "getSeqsAsArray", new Class[]
+ {}).invoke(jmf));
+ cl.getMethod("addAnnotations", new Class[]
+ { AlignmentI.class }).invoke(jmf, al);
+ for (SequenceI sq : al.getSequences())
+ {
+ if (sq.getDatasetSequence() != null)
+ {
+ sq.getDatasetSequence().getAllPDBEntries().clear();
+ }
+ else
+ {
+ sq.getAllPDBEntries().clear();
+ }
+ }
+ replaceAndUpdateChains(prot, al, AlignSeq.PEP, false);
+ }
+ } catch (ClassNotFoundException q)
+ {
+ }
+ }
+
+ private void replaceAndUpdateChains(List<SequenceI> prot,
+ AlignmentI al, String pep, boolean b)
+ {
+ List<List<? extends Object>> replaced = AlignSeq
+ .replaceMatchingSeqsWith(seqs, annotations, prot, al, pep,
+ false);
+ for (PDBChain ch : chains)
+ {
+ int p = 0;
+ for (SequenceI sq : (List<SequenceI>) replaced.get(0))
+ {
+ p++;
+ if (sq == ch.sequence || sq.getDatasetSequence() == ch.sequence)