2 * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3 * Copyright (C) $$Year-Rel$$ The Jalview Authors
5 * This file is part of Jalview.
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.
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.
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.
21 package jalview.analysis;
23 import jalview.datamodel.AlignedCodonFrame;
24 import jalview.datamodel.Alignment;
25 import jalview.datamodel.AlignmentI;
26 import jalview.datamodel.DBRefEntry;
27 import jalview.datamodel.DBRefSource;
28 import jalview.datamodel.Mapping;
29 import jalview.datamodel.Sequence;
30 import jalview.datamodel.SequenceFeature;
31 import jalview.datamodel.SequenceI;
32 import jalview.util.DBRefUtils;
33 import jalview.util.MapList;
34 import jalview.ws.SequenceFetcher;
35 import jalview.ws.seqfetcher.ASequenceFetcher;
37 import java.util.ArrayList;
38 import java.util.List;
39 import java.util.Vector;
42 * Functions for cross-referencing sequence databases. user must first specify
43 * if cross-referencing from protein or dna (set dna==true)
51 * A sub-class that ignores Parent attribute when comparing sequence
52 * features. This avoids 'duplicate' CDS features that only
53 * differ in their parent Transcript ids.
55 class MySequenceFeature extends SequenceFeature
57 private SequenceFeature feat;
59 MySequenceFeature(SequenceFeature sf)
65 public boolean equals(Object o)
67 return feat.equals(o, true);
72 * Select just the DNA or protein references for a protein or dna sequence
75 * if true, select references from DNA (i.e. Protein databases), else
76 * DNA database references
78 * a set of references to select from
81 public static DBRefEntry[] findXDbRefs(boolean fromDna, DBRefEntry[] refs)
83 return DBRefUtils.selectRefs(refs, fromDna ? DBRefSource.PROTEINDBS
84 : DBRefSource.DNACODINGDBS);
85 // could attempt to find other cross
86 // refs here - ie PDB xrefs
87 // (not dna, not protein seq)
92 * true if seqs are DNA seqs
94 * @return a list of sequence database cross reference source types
96 public static String[] findSequenceXrefTypes(boolean dna, SequenceI[] seqs)
98 return findSequenceXrefTypes(dna, seqs, null);
102 * Indirect references are references from other sequences from the dataset to
103 * any of the direct DBRefEntrys on the given sequences.
106 * true if seqs are DNA seqs
108 * @return a list of sequence database cross reference source types
110 public static String[] findSequenceXrefTypes(boolean dna,
111 SequenceI[] seqs, AlignmentI dataset)
113 String[] dbrefs = null;
114 List<String> refs = new ArrayList<String>();
115 for (SequenceI seq : seqs)
120 while (dss.getDatasetSequence() != null)
122 dss = dss.getDatasetSequence();
124 DBRefEntry[] rfs = findXDbRefs(dna, dss.getDBRefs());
127 for (DBRefEntry ref : rfs)
129 if (!refs.contains(ref.getSource()))
131 refs.add(ref.getSource());
137 // search for references to this sequence's direct references.
138 DBRefEntry[] lrfs = CrossRef.findXDbRefs(!dna, seq.getDBRefs());
139 List<SequenceI> rseqs = new ArrayList<SequenceI>();
140 CrossRef.searchDatasetXrefs(seq, !dna, lrfs, dataset, rseqs,
141 null); // don't need to specify codon frame for mapping here
142 for (SequenceI rs : rseqs)
144 DBRefEntry[] xrs = findXDbRefs(dna, rs.getDBRefs());
147 for (DBRefEntry ref : xrs)
149 if (!refs.contains(ref.getSource()))
151 refs.add(ref.getSource());
155 // looks like copy and paste - change rfs to xrs?
156 // for (int r = 0; rfs != null && r < rfs.length; r++)
158 // if (!refs.contains(rfs[r].getSource()))
160 // refs.add(rfs[r].getSource());
169 dbrefs = new String[refs.size()];
170 refs.toArray(dbrefs);
175 public static boolean hasCdnaMap(SequenceI[] seqs)
177 // TODO unused - remove?
178 String[] reftypes = findSequenceXrefTypes(false, seqs);
179 for (int s = 0; s < reftypes.length; s++)
181 if (reftypes.equals(DBRefSource.EMBLCDS))
190 public static SequenceI[] getCdnaMap(SequenceI[] seqs)
192 // TODO unused - remove?
193 Vector cseqs = new Vector();
194 for (int s = 0; s < seqs.length; s++)
196 DBRefEntry[] cdna = findXDbRefs(true, seqs[s].getDBRefs());
197 for (int c = 0; c < cdna.length; c++)
199 if (cdna[c].getSource().equals(DBRefSource.EMBLCDS))
202 .println("TODO: unimplemented sequence retrieval for coding region sequence.");
203 // TODO: retrieve CDS dataset sequences
204 // need global dataset sequence retriever/resolver to reuse refs
205 // and construct Mapping entry.
206 // insert gaps in CDS according to peptide gaps.
207 // add gapped sequence to cseqs
211 if (cseqs.size() > 0)
213 SequenceI[] rsqs = new SequenceI[cseqs.size()];
214 cseqs.copyInto(rsqs);
224 * sequences whose xrefs are being retrieved
226 * true if sequences are nucleotide
229 * alignment to search for cross-referenced sequences (and possibly
232 * a list of sequences to add to if 'peers' to the original sequences
233 * are found e.g. alternative protein products for a protein's gene
234 * @return products (as dataset sequences)
236 public static Alignment findXrefSequences(SequenceI[] seqs,
237 final boolean dna, final String source, AlignmentI al,
238 List<SequenceI> addedPeers)
240 AlignmentI dataset = al.getDataset() == null ? al : al.getDataset();
241 List<SequenceI> rseqs = new ArrayList<SequenceI>();
242 AlignedCodonFrame cf = new AlignedCodonFrame();
243 for (SequenceI seq : seqs)
246 while (dss.getDatasetSequence() != null)
248 dss = dss.getDatasetSequence();
250 boolean found = false;
251 DBRefEntry[] xrfs = CrossRef.findXDbRefs(dna, dss.getDBRefs());
252 if ((xrfs == null || xrfs.length == 0) && dataset != null)
254 System.out.println("Attempting to find ds Xrefs refs.");
255 // FIXME should be dss not seq here?
256 DBRefEntry[] lrfs = CrossRef.findXDbRefs(!dna, seq.getDBRefs());
257 // less ambiguous would be a 'find primary dbRefEntry' method.
258 // filter for desired source xref here
259 found = CrossRef.searchDatasetXrefs(dss, !dna, lrfs, dataset,
262 for (int r = 0; xrfs != null && r < xrfs.length; r++)
264 DBRefEntry xref = xrfs[r];
265 if (source != null && !source.equals(xref.getSource()))
271 if (xref.getMap().getTo() != null)
273 SequenceI rsq = new Sequence(xref.getMap().getTo());
275 if (xref.getMap().getMap().getFromRatio() != xref
276 .getMap().getMap().getToRatio())
278 // get sense of map correct for adding to product alignment.
281 // map is from dna seq to a protein product
282 cf.addMap(dss, rsq, xref.getMap().getMap());
286 // map should be from protein seq to its coding dna
287 cf.addMap(rsq, dss, xref.getMap().getMap().getInverse());
295 // do a bit more work - search for sequences with references matching
296 // xrefs on this sequence.
299 found |= searchDataset(dss, xref, dataset, rseqs, cf, false,
304 xrfs[r] = null; // we've recovered seqs for this one.
311 if (xrfs != null && xrfs.length > 0)
313 // Try and get the sequence reference...
315 * Ideal world - we ask for a sequence fetcher implementation here if
316 * (jalview.io.RunTimeEnvironment.getSequenceFetcher()) (
318 ASequenceFetcher sftch = new SequenceFetcher();
319 SequenceI[] retrieved = null;
321 for (int r = 0; r < xrfs.length; r++)
323 // filter out any irrelevant or irretrievable references
325 || ((source != null && !source.equals(xrfs[r]
326 .getSource())) || !sftch.isFetchable(xrfs[r]
336 .println("Attempting to retrieve cross referenced sequences.");
337 DBRefEntry[] t = new DBRefEntry[l];
339 for (int r = 0; r < xrfs.length; r++)
349 retrieved = sftch.getSequences(xrfs, !dna);
350 // problem here is we don't know which of xrfs resulted in which
352 } catch (Exception e)
355 .println("Problem whilst retrieving cross references for Sequence : "
360 if (retrieved != null)
362 updateDbrefMappings(dna, seq, xrfs, retrieved, cf);
364 SequenceIdMatcher matcher = new SequenceIdMatcher(
365 dataset.getSequences());
366 matcher.addAll(addedPeers);
367 List<SequenceFeature> copiedFeatures = new ArrayList<SequenceFeature>();
368 CrossRef me = new CrossRef();
369 for (int rs = 0; rs < retrieved.length; rs++)
371 // TODO: examine each sequence for 'redundancy'
372 DBRefEntry[] dbr = retrieved[rs].getDBRefs();
373 if (dbr != null && dbr.length > 0)
375 for (int di = 0; di < dbr.length; di++)
377 // find any entry where we should put in the sequence being
378 // cross-referenced into the map
379 Mapping map = dbr[di].getMap();
382 if (map.getTo() != null && map.getMap() != null)
384 SequenceI matched = matcher
385 .findIdMatch(map.getTo());
389 * already got an xref to this sequence; update this
390 * map to point to the same sequence, and add
391 * any new dbrefs to it
393 for (DBRefEntry ref : map.getTo().getDBRefs())
395 matched.addDBRef(ref);
401 matcher.add(map.getTo());
405 // compare ms with dss and replace with dss in mapping
406 // if map is congruent
407 SequenceI ms = map.getTo();
408 int sf = map.getMap().getToLowest();
409 int st = map.getMap().getToHighest();
410 SequenceI mappedrg = ms.getSubSequence(sf, st);
411 // SequenceI loc = dss.getSubSequence(sf, st);
412 if (mappedrg.getLength() > 0
413 && ms.getSequenceAsString().equals(
414 dss.getSequenceAsString()))
415 // && mappedrg.getSequenceAsString().equals(
416 // loc.getSequenceAsString()))
418 String msg = "Mapping updated from "
420 + " to retrieved crossreference "
422 System.out.println(msg);
423 // method to update all refs of existing To on
424 // retrieved sequence with dss and merge any props
428 * copy sequence features as well, avoiding
429 * duplication (e.g. from 2 transcripts)
431 SequenceFeature[] sfs = ms
432 .getSequenceFeatures();
435 for (SequenceFeature feat : sfs)
438 * we override SequenceFeature.equals here (but
439 * not elsewhere) to ignore Parent attribute
440 * TODO not quite working yet!
443 .contains(me.new MySequenceFeature(
446 dss.addSequenceFeature(feat);
447 copiedFeatures.add(feat);
451 cf.addMap(retrieved[rs].getDatasetSequence(),
456 if (!addedPeers.contains(map.getTo()))
458 addedPeers.add(map.getTo());
460 cf.addMap(retrieved[rs].getDatasetSequence(),
461 map.getTo(), map.getMap());
463 } catch (Exception e)
466 .println("Exception when consolidating Mapped sequence set...");
467 e.printStackTrace(System.err);
473 retrieved[rs].updatePDBIds();
474 rseqs.add(retrieved[rs]);
482 Alignment ral = null;
483 if (rseqs.size() > 0)
485 ral = new Alignment(rseqs.toArray(new SequenceI[rseqs.size()]));
486 if (cf != null && !cf.isEmpty())
488 ral.addCodonFrame(cf);
495 * Updates any empty mappings in the cross-references with one to a compatible
496 * retrieved sequence if found, and adds any new mappings to the
505 static void updateDbrefMappings(boolean dna, SequenceI mapFrom,
506 DBRefEntry[] xrefs, SequenceI[] retrieved, AlignedCodonFrame acf)
508 SequenceIdMatcher matcher = new SequenceIdMatcher(retrieved);
509 for (DBRefEntry xref : xrefs)
513 String targetSeqName = xref.getSource() + "|"
514 + xref.getAccessionId();
515 SequenceI[] matches = matcher.findAllIdMatches(targetSeqName);
520 for (SequenceI seq : matches)
522 MapList mapping = null;
525 mapping = AlignmentUtils.mapCdnaToProtein(seq, mapFrom);
529 mapping = AlignmentUtils.mapCdnaToProtein(mapFrom, seq);
532 mapping = mapping.getInverse();
537 xref.setMap(new Mapping(seq, mapping));
540 AlignmentUtils.computeProteinFeatures(mapFrom, seq, mapping);
544 acf.addMap(mapFrom, seq, mapping);
548 acf.addMap(seq, mapFrom, mapping.getInverse());
558 * find references to lrfs in the cross-reference set of each sequence in
559 * dataset (that is not equal to sequenceI) Identifies matching DBRefEntry
560 * based on source and accession string only - Map and Version are nulled.
566 * @return true if matches were found.
568 private static boolean searchDatasetXrefs(SequenceI sequenceI,
569 boolean dna, DBRefEntry[] lrfs, AlignmentI dataset,
570 List<SequenceI> rseqs, AlignedCodonFrame cf)
572 boolean found = false;
577 for (int i = 0; i < lrfs.length; i++)
579 DBRefEntry xref = new DBRefEntry(lrfs[i]);
581 xref.setVersion(null);
583 found = searchDataset(sequenceI, xref, dataset, rseqs, cf, false, dna);
589 * search a given sequence dataset for references matching cross-references to
596 * set of unique sequences
598 * @return true if one or more unique sequences were found and added
600 public static boolean searchDataset(SequenceI sequenceI, DBRefEntry xrf,
601 AlignmentI dataset, List<SequenceI> rseqs, AlignedCodonFrame cf)
603 return searchDataset(sequenceI, xrf, dataset, rseqs, cf, true, false);
607 * TODO: generalise to different protein classifications Search dataset for
608 * DBRefEntrys matching the given one (xrf) and add the associated sequence to
616 * - search all references or only subset
618 * search dna or protein xrefs (if direct=false)
619 * @return true if relationship found and sequence added.
621 public static boolean searchDataset(SequenceI sequenceI, DBRefEntry xrf,
622 AlignmentI dataset, List<SequenceI> rseqs, AlignedCodonFrame cf,
623 boolean direct, boolean dna)
625 boolean found = false;
626 SequenceI[] typer = new SequenceI[1];
631 if (dataset.getSequences() == null)
633 System.err.println("Empty dataset sequence set - NO VECTOR");
637 synchronized (ds = dataset.getSequences())
639 for (SequenceI nxt : ds)
643 if (nxt.getDatasetSequence() != null)
646 .println("Implementation warning: getProducts passed a dataset alignment without dataset sequences in it!");
648 if (nxt != sequenceI && nxt != sequenceI.getDatasetSequence())
650 // check if this is the correct sequence type
653 boolean isDna = jalview.util.Comparison.isNucleotide(typer);
654 if ((direct && isDna == dna) || (!direct && isDna != dna))
656 // skip this sequence because it is same molecule type
661 // look for direct or indirect references in common
662 DBRefEntry[] poss = nxt.getDBRefs(), cands = null;
665 cands = jalview.util.DBRefUtils.searchRefs(poss, xrf);
669 poss = CrossRef.findXDbRefs(dna, poss); //
670 cands = jalview.util.DBRefUtils.searchRefs(poss, xrf);
674 if (!rseqs.contains(nxt))
677 boolean foundmap = cf != null;
678 // don't search if we aren't given a codon map object
679 for (int r = 0; foundmap && r < cands.length; r++)
681 if (cands[r].hasMap())
683 if (cands[r].getMap().getTo() != null
684 && cands[r].getMap().getMap().getFromRatio() != cands[r]
685 .getMap().getMap().getToRatio())
688 // get sense of map correct for adding to product
692 // map is from dna seq to a protein product
693 cf.addMap(sequenceI, nxt, cands[r].getMap()
698 // map should be from protein seq to its coding dna
699 cf.addMap(nxt, sequenceI, cands[r].getMap()
700 .getMap().getInverse());
705 // TODO: add mapping between sequences if necessary
718 * precalculate different products that can be found for seqs in dataset and
725 * - don't actually build lists - just get types
726 * @return public static Object[] buildXProductsList(boolean dna, SequenceI[]
727 * seqs, AlignmentI dataset, boolean fake) { String types[] =
728 * jalview.analysis.CrossRef.findSequenceXrefTypes( dna, seqs,
729 * dataset); if (types != null) { System.out.println("Xref Types for:
730 * "+(dna ? "dna" : "prot")); for (int t = 0; t < types.length; t++) {
731 * System.out.println("Type: " + types[t]); SequenceI[] prod =
732 * jalview.analysis.CrossRef.findXrefSequences(seqs, dna, types[t]);
733 * System.out.println("Found " + ((prod == null) ? "no" : "" +
734 * prod.length) + " products"); if (prod!=null) { for (int p=0;
735 * p<prod.length; p++) { System.out.println("Prod "+p+":
736 * "+prod[p].getDisplayId(true)); } } } } else {
737 * System.out.println("Trying getProducts for
738 * "+al.getSequenceAt(0).getDisplayId(true));
739 * System.out.println("Search DS Xref for: "+(dna ? "dna" : "prot"));
740 * // have a bash at finding the products amongst all the retrieved
741 * sequences. SequenceI[] prod =
742 * jalview.analysis.CrossRef.findXrefSequences(al
743 * .getSequencesArray(), dna, null, ds); System.out.println("Found " +
744 * ((prod == null) ? "no" : "" + prod.length) + " products"); if
745 * (prod!=null) { // select non-equivalent sequences from dataset list
746 * for (int p=0; p<prod.length; p++) { System.out.println("Prod "+p+":
747 * "+prod[p].getDisplayId(true)); } } } }