2 * Jalview - A Sequence Alignment Editor and Viewer (Version 2.4)
\r
3 * Copyright (C) 2008 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
\r
5 * This program is free software; you can redistribute it and/or
\r
6 * modify it under the terms of the GNU General Public License
\r
7 * as published by the Free Software Foundation; either version 2
\r
8 * of the License, or (at your option) any later version.
\r
10 * This program is distributed in the hope that it will be useful,
\r
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
\r
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
\r
13 * GNU General Public License for more details.
\r
15 * You should have received a copy of the GNU General Public License
\r
16 * along with this program; if not, write to the Free Software
\r
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
\r
19 package jalview.analysis;
\r
21 import java.util.Enumeration;
\r
22 import java.util.Vector;
\r
23 import java.util.Hashtable;
\r
25 import jalview.datamodel.AlignedCodonFrame;
\r
26 import jalview.datamodel.Alignment;
\r
27 import jalview.datamodel.AlignmentI;
\r
28 import jalview.datamodel.DBRefSource;
\r
29 import jalview.datamodel.DBRefEntry;
\r
30 import jalview.datamodel.Sequence;
\r
31 import jalview.datamodel.SequenceI;
\r
32 import jalview.ws.SequenceFetcher;
\r
33 import jalview.ws.seqfetcher.ASequenceFetcher;
\r
36 * Functions for cross-referencing sequence databases. user must first specify
\r
37 * if cross-referencing from protein or dna (set dna==true)
\r
42 public class CrossRef
\r
45 * get the DNA or protein references for a protein or dna sequence
\r
51 public static DBRefEntry[] findXDbRefs(boolean dna, DBRefEntry[] rfs)
\r
55 rfs = jalview.util.DBRefUtils.selectRefs(rfs, DBRefSource.PROTEINDBS);
\r
59 rfs = jalview.util.DBRefUtils.selectRefs(rfs,
\r
60 DBRefSource.DNACODINGDBS); // could attempt to find other cross
\r
61 // refs and return here - ie PDB xrefs
\r
62 // (not dna, not protein seq)
\r
67 public static Hashtable classifyDbRefs(DBRefEntry[] rfs)
\r
69 Hashtable classes = new Hashtable();
\r
70 classes.put(DBRefSource.PROTEINDBS, jalview.util.DBRefUtils.selectRefs(
\r
71 rfs, DBRefSource.PROTEINDBS));
\r
72 classes.put(DBRefSource.DNACODINGDBS, jalview.util.DBRefUtils
\r
73 .selectRefs(rfs, DBRefSource.DNACODINGDBS));
\r
74 classes.put(DBRefSource.DOMAINDBS, jalview.util.DBRefUtils.selectRefs(
\r
75 rfs, DBRefSource.DOMAINDBS));
\r
76 // classes.put(OTHER, )
\r
82 * true if seqs are DNA seqs
\r
84 * @return a list of sequence database cross reference source types
\r
86 public static String[] findSequenceXrefTypes(boolean dna, SequenceI[] seqs)
\r
88 return findSequenceXrefTypes(dna, seqs, null);
\r
92 * Indirect references are references from other sequences from the dataset to
\r
93 * any of the direct DBRefEntrys on the given sequences.
\r
96 * true if seqs are DNA seqs
\r
98 * @return a list of sequence database cross reference source types
\r
100 public static String[] findSequenceXrefTypes(boolean dna,
\r
101 SequenceI[] seqs, AlignmentI dataset)
\r
103 String[] dbrefs = null;
\r
104 Vector refs = new Vector();
\r
105 for (int s = 0; s < seqs.length; s++)
\r
107 SequenceI dss = seqs[s];
\r
108 while (dss.getDatasetSequence() != null)
\r
110 dss = dss.getDatasetSequence();
\r
112 DBRefEntry[] rfs = findXDbRefs(dna, dss.getDBRef());
\r
113 for (int r = 0; rfs != null && r < rfs.length; r++)
\r
115 if (!refs.contains(rfs[r].getSource()))
\r
117 refs.addElement(rfs[r].getSource());
\r
120 if (dataset != null)
\r
122 // search for references to this sequence's direct references.
\r
123 DBRefEntry[] lrfs = CrossRef.findXDbRefs(!dna, seqs[s].getDBRef());
\r
124 Vector rseqs = new Vector();
\r
125 CrossRef.searchDatasetXrefs(seqs[s], !dna, lrfs, dataset, rseqs,
\r
126 null); // don't need to specify codon frame for mapping here
\r
127 Enumeration lr = rseqs.elements();
\r
128 while (lr.hasMoreElements())
\r
130 SequenceI rs = (SequenceI) lr.nextElement();
\r
131 DBRefEntry[] xrs = findXDbRefs(dna, rs.getDBRef());
\r
132 for (int r = 0; rfs != null && r < rfs.length; r++)
\r
134 if (!refs.contains(rfs[r].getSource()))
\r
136 refs.addElement(rfs[r].getSource());
\r
142 if (refs.size() > 0)
\r
144 dbrefs = new String[refs.size()];
\r
145 refs.copyInto(dbrefs);
\r
151 * if (dna) { if (rfs[r].hasMap()) { // most likely this is a protein cross
\r
152 * reference if (!refs.contains(rfs[r].getSource())) {
\r
153 * refs.addElement(rfs[r].getSource()); } } }
\r
155 public static boolean hasCdnaMap(SequenceI[] seqs)
\r
157 String[] reftypes = findSequenceXrefTypes(false, seqs);
\r
158 for (int s = 0; s < reftypes.length; s++)
\r
160 if (reftypes.equals(DBRefSource.EMBLCDS))
\r
169 public static SequenceI[] getCdnaMap(SequenceI[] seqs)
\r
171 Vector cseqs = new Vector();
\r
172 for (int s = 0; s < seqs.length; s++)
\r
174 DBRefEntry[] cdna = findXDbRefs(true, seqs[s].getDBRef());
\r
175 for (int c = 0; c < cdna.length; c++)
\r
177 if (cdna[c].getSource().equals(DBRefSource.EMBLCDS))
\r
179 System.err.println("TODO: unimplemented sequence retrieval for coding region sequence.");
\r
180 // TODO: retrieve CDS dataset sequences
\r
181 // need global dataset sequence retriever/resolver to reuse refs
\r
182 // and construct Mapping entry.
\r
183 // insert gaps in CDS according to peptide gaps.
\r
184 // add gapped sequence to cseqs
\r
188 if (cseqs.size() > 0)
\r
190 SequenceI[] rsqs = new SequenceI[cseqs.size()];
\r
191 cseqs.copyInto(rsqs);
\r
204 public static Alignment findXrefSequences(SequenceI[] seqs, boolean dna,
\r
207 return findXrefSequences(seqs, dna, source, null);
\r
216 * alignment to search for product sequences.
\r
217 * @return products (as dataset sequences)
\r
219 public static Alignment findXrefSequences(SequenceI[] seqs, boolean dna,
\r
220 String source, AlignmentI dataset)
\r
222 Vector rseqs = new Vector();
\r
223 Alignment ral = null;
\r
224 AlignedCodonFrame cf = new AlignedCodonFrame(0); // nominal width
\r
225 for (int s = 0; s < seqs.length; s++)
\r
227 SequenceI dss = seqs[s];
\r
228 while (dss.getDatasetSequence() != null)
\r
230 dss = dss.getDatasetSequence();
\r
232 boolean found = false;
\r
233 DBRefEntry[] xrfs = CrossRef.findXDbRefs(dna, dss.getDBRef());
\r
234 if ((xrfs == null || xrfs.length == 0) && dataset != null)
\r
236 System.out.println("Attempting to find ds Xrefs refs.");
\r
237 DBRefEntry[] lrfs = CrossRef.findXDbRefs(!dna, seqs[s].getDBRef()); // less
\r
245 // filter for desired source xref here
\r
246 found = CrossRef.searchDatasetXrefs(dss, !dna, lrfs, dataset,
\r
249 for (int r = 0; xrfs != null && r < xrfs.length; r++)
\r
251 if (source != null && !source.equals(xrfs[r].getSource()))
\r
253 if (xrfs[r].hasMap())
\r
255 if (xrfs[r].getMap().getTo() != null)
\r
257 Sequence rsq = new Sequence(xrfs[r].getMap().getTo());
\r
258 rseqs.addElement(rsq);
\r
259 if (xrfs[r].getMap().getMap().getFromRatio() != xrfs[r]
\r
260 .getMap().getMap().getToRatio())
\r
262 // get sense of map correct for adding to product alignment.
\r
265 // map is from dna seq to a protein product
\r
266 cf.addMap(dss, rsq, xrfs[r].getMap().getMap());
\r
270 // map should be from protein seq to its coding dna
\r
271 cf.addMap(rsq, dss, xrfs[r].getMap().getMap().getInverse());
\r
279 // do a bit more work - search for sequences with references matching
\r
280 // xrefs on this sequence.
\r
281 if (dataset != null)
\r
283 found |= searchDataset(dss, xrfs[r], dataset, rseqs, cf);
\r
285 xrfs[r] = null; // we've recovered seqs for this one.
\r
291 if (xrfs != null && xrfs.length > 0)
\r
293 // Try and get the sequence reference...
\r
295 * Ideal world - we ask for a sequence fetcher implementation here if
\r
296 * (jalview.io.RunTimeEnvironment.getSequenceFetcher()) (
\r
298 ASequenceFetcher sftch = new SequenceFetcher();
\r
299 SequenceI[] retrieved = null;
\r
300 int l = xrfs.length;
\r
301 for (int r = 0; r < xrfs.length; r++)
\r
303 // filter out any irrelevant or irretrievable references
\r
304 if (xrfs[r] == null
\r
305 || ((source != null && !source.equals(xrfs[r]
\r
306 .getSource())) || !sftch.isFetchable(xrfs[r]
\r
316 .println("Attempting to retrieve cross referenced sequences.");
\r
317 DBRefEntry[] t = new DBRefEntry[l];
\r
319 for (int r = 0; r < xrfs.length; r++)
\r
321 if (xrfs[r] != null)
\r
327 retrieved = sftch.getSequences(xrfs); // problem here is we don't know which of xrfs resulted in which retrieved element
\r
328 } catch (Exception e)
\r
331 .println("Problem whilst retrieving cross references for Sequence : "
\r
332 + seqs[s].getName());
\r
333 e.printStackTrace();
\r
335 if (retrieved != null)
\r
337 for (int rs = 0; rs < retrieved.length; rs++)
\r
339 // TODO: examine each sequence for 'redundancy'
\r
340 jalview.datamodel.DBRefEntry[] dbr = retrieved[rs].getDBRef();
\r
341 if (dbr != null && dbr.length > 0)
\r
343 for (int di = 0; di < dbr.length; di++)
\r
345 // find any entry where we should put in the sequence being cross-referenced into the map
\r
346 jalview.datamodel.Mapping map = dbr[di].getMap();
\r
349 if (map.getTo() != null && map.getMap() != null)
\r
351 // should search the local dataset to find any existing candidates for To !
\r
354 // compare ms with dss and replace with dss in mapping if map is congruent
\r
355 SequenceI ms = map.getTo();
\r
356 int sf = map.getMap().getToLowest();
\r
357 int st = map.getMap().getToHighest();
\r
358 SequenceI mappedrg = ms.getSubSequence(sf, st);
\r
359 SequenceI loc = dss.getSubSequence(sf, st);
\r
360 if (mappedrg.getLength()>0 && mappedrg.getSequenceAsString().equals(
\r
361 loc.getSequenceAsString()))
\r
364 .println("Mapping updated for retrieved crossreference");
\r
365 // method to update all refs of existing To on retrieved sequence with dss and merge any props on To onto dss.
\r
368 } catch (Exception e)
\r
371 .println("Exception when consolidating Mapped sequence set...");
\r
372 e.printStackTrace(System.err);
\r
378 retrieved[rs].updatePDBIds();
\r
379 rseqs.addElement(retrieved[rs]);
\r
386 if (rseqs.size() > 0)
\r
388 SequenceI[] rsqs = new SequenceI[rseqs.size()];
\r
389 rseqs.copyInto(rsqs);
\r
390 ral = new Alignment(rsqs);
\r
391 if (cf != null && cf.getProtMappings() != null)
\r
393 ral.addCodonFrame(cf);
\r
400 * find references to lrfs in the cross-reference set of each sequence in
\r
401 * dataset (that is not equal to sequenceI) Identifies matching DBRefEntry
\r
402 * based on source and accession string only - Map and Version are nulled.
\r
408 * @return true if matches were found.
\r
410 private static boolean searchDatasetXrefs(SequenceI sequenceI,
\r
411 boolean dna, DBRefEntry[] lrfs, AlignmentI dataset, Vector rseqs,
\r
412 AlignedCodonFrame cf)
\r
414 boolean found = false;
\r
417 for (int i = 0; i < lrfs.length; i++)
\r
419 DBRefEntry xref = new DBRefEntry(lrfs[i]);
\r
420 // add in wildcards
\r
421 xref.setVersion(null);
\r
423 found = searchDataset(sequenceI, xref, dataset, rseqs, cf, false, dna);
\r
429 * search a given sequence dataset for references matching cross-references to
\r
430 * the given sequence
\r
436 * set of unique sequences
\r
438 * @return true if one or more unique sequences were found and added
\r
440 public static boolean searchDataset(SequenceI sequenceI, DBRefEntry xrf,
\r
441 AlignmentI dataset, Vector rseqs, AlignedCodonFrame cf)
\r
443 return searchDataset(sequenceI, xrf, dataset, rseqs, cf, true, false);
\r
447 * TODO: generalise to different protein classifications Search dataset for
\r
448 * DBRefEntrys matching the given one (xrf) and add the associated sequence to
\r
456 * search all references or only subset
\r
458 * search dna or protein xrefs (if direct=false)
\r
459 * @return true if relationship found and sequence added.
\r
461 public static boolean searchDataset(SequenceI sequenceI, DBRefEntry xrf,
\r
462 AlignmentI dataset, Vector rseqs, AlignedCodonFrame cf,
\r
463 boolean direct, boolean dna)
\r
465 boolean found = false;
\r
466 SequenceI[] typer=new SequenceI[1];
\r
467 if (dataset == null)
\r
469 if (dataset.getSequences() == null)
\r
471 System.err.println("Empty dataset sequence set - NO VECTOR");
\r
474 Enumeration e = dataset.getSequences().elements();
\r
475 while (e.hasMoreElements())
\r
477 SequenceI nxt = (SequenceI) e.nextElement();
\r
480 if (nxt.getDatasetSequence() != null)
\r
483 .println("Implementation warning: getProducts passed a dataset alignment without dataset sequences in it!");
\r
485 if (nxt != sequenceI && nxt != sequenceI.getDatasetSequence())
\r
487 // check if this is the correct sequence type
\r
490 boolean isDna = jalview.util.Comparison.isNucleotide(typer);
\r
491 if ((direct && isDna == dna) || (!direct && isDna!=dna))
\r
493 // skip this sequence because it is same molecule type
\r
498 // look for direct or indirect references in common
\r
499 DBRefEntry[] poss = null, cands = null;
\r
502 cands = jalview.util.DBRefUtils.searchRefs(poss = nxt
\r
507 cands = jalview.util.DBRefUtils.searchRefs(poss = CrossRef
\r
508 .findXDbRefs(dna, nxt.getDBRef()), xrf);
\r
512 if (!rseqs.contains(nxt))
\r
514 rseqs.addElement(nxt);
\r
515 boolean foundmap = cf != null; // don't search if we aren't given
\r
516 // a codon map object
\r
517 for (int r = 0; foundmap && r < cands.length; r++)
\r
519 if (cands[r].hasMap())
\r
521 if (cands[r].getMap().getTo() != null
\r
522 && cands[r].getMap().getMap().getFromRatio() != cands[r]
\r
523 .getMap().getMap().getToRatio())
\r
526 // get sense of map correct for adding to product alignment.
\r
529 // map is from dna seq to a protein product
\r
530 cf.addMap(sequenceI, nxt, cands[r].getMap().getMap());
\r
534 // map should be from protein seq to its coding dna
\r
535 cf.addMap(nxt, sequenceI, cands[r].getMap().getMap()
\r
541 // TODO: add mapping between sequences if necessary
\r
553 * precalculate different products that can be found for seqs in dataset and
\r
560 * don't actually build lists - just get types
\r
561 * @return public static Object[] buildXProductsList(boolean dna, SequenceI[]
\r
562 * seqs, AlignmentI dataset, boolean fake) { String types[] =
\r
563 * jalview.analysis.CrossRef.findSequenceXrefTypes( dna, seqs,
\r
564 * dataset); if (types != null) { System.out.println("Xref Types for:
\r
565 * "+(dna ? "dna" : "prot")); for (int t = 0; t < types.length; t++) {
\r
566 * System.out.println("Type: " + types[t]); SequenceI[] prod =
\r
567 * jalview.analysis.CrossRef.findXrefSequences(seqs, dna, types[t]);
\r
568 * System.out.println("Found " + ((prod == null) ? "no" : "" +
\r
569 * prod.length) + " products"); if (prod!=null) { for (int p=0; p<prod.length;
\r
570 * p++) { System.out.println("Prod "+p+":
\r
571 * "+prod[p].getDisplayId(true)); } } }
\r
572 * } else { System.out.println("Trying getProducts for
\r
573 * "+al.getSequenceAt(0).getDisplayId(true)); System.out.println("Search DS
\r
574 * Xref for: "+(dna ? "dna" : "prot")); // have a bash at finding the products
\r
575 * amongst all the retrieved sequences. SequenceI[] prod =
\r
576 * jalview.analysis.CrossRef.findXrefSequences(al .getSequencesArray(), dna,
\r
577 * null, ds); System.out.println("Found " + ((prod == null) ? "no" : "" +
\r
578 * prod.length) + " products"); if (prod!=null) { // select non-equivalent
\r
579 * sequences from dataset list for (int p=0; p<prod.length; p++) {
\r
580 * System.out.println("Prod "+p+": "+prod[p].getDisplayId(true)); } }
\r