X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2Fjalview%2Fanalysis%2FCrossRef.java;h=05814c2784e5a0da1be2c4a21907c41de8e9f269;hb=a7591fdadf3edeb556d1417967787a5bfdb1da32;hp=9fd87dfbab9db8e02129966025fae5243cbcd982;hpb=8474e47dc878f83b9b3f45ef6b04eb64ad733e2a;p=jalview.git diff --git a/src/jalview/analysis/CrossRef.java b/src/jalview/analysis/CrossRef.java index 9fd87df..05814c2 100644 --- a/src/jalview/analysis/CrossRef.java +++ b/src/jalview/analysis/CrossRef.java @@ -28,7 +28,6 @@ import jalview.datamodel.Mapping; import jalview.datamodel.Sequence; import jalview.datamodel.SequenceFeature; import jalview.datamodel.SequenceI; -import jalview.util.Comparison; import jalview.util.DBRefUtils; import jalview.util.MapList; import jalview.ws.SequenceFetcherFactory; @@ -54,17 +53,21 @@ public class CrossRef private AlignmentI dataset; /* - * true if we are searching for cross-references from nucleotide, - * i.e. for protein sequences, false if the reverse - */ - private boolean fromDna; - - /* * the sequences for which we are seeking cross-references */ private SequenceI[] fromSeqs; /** + * matcher built from dataset + */ + SequenceIdMatcher matcher; + + /** + * sequences found by cross-ref searches to fromSeqs + */ + List rseqs; + + /** * Constructor * * @param seqs @@ -76,7 +79,6 @@ public class CrossRef public CrossRef(SequenceI[] seqs, AlignmentI ds) { fromSeqs = seqs; - fromDna = ds.isNucleotide(); dataset = ds.getDataset() == null ? ds : ds.getDataset(); } @@ -88,16 +90,20 @@ public class CrossRef * reference from another sequence in the dataset which has a cross-reference * to a direct DBRefEntry on the given sequence * + * + * @param dna + * - when true, cross-references *from* dna returned. When false, + * cross-references *from* protein are returned * @return */ - public List findXrefSourcesForSequences() + public List findXrefSourcesForSequences(boolean dna) { List sources = new ArrayList(); for (SequenceI seq : fromSeqs) { if (seq != null) { - findXrefSourcesForSequence(seq, sources); + findXrefSourcesForSequence(seq, dna, sources); } } return sources; @@ -114,10 +120,14 @@ public class CrossRef * * @param seq * the sequence whose dbrefs we are searching against + * @param fromDna + * when true, context is DNA - so sources identifying protein + * products will be returned. * @param sources * a list of sources to add matches to */ - void findXrefSourcesForSequence(SequenceI seq, List sources) + void findXrefSourcesForSequence(SequenceI seq, boolean fromDna, + List sources) { /* * first find seq's xrefs (dna-to-peptide or peptide-to-dna) @@ -130,18 +140,18 @@ public class CrossRef * find sequence's direct (dna-to-dna, peptide-to-peptide) xrefs */ DBRefEntry[] lrfs = DBRefUtils.selectDbRefs(fromDna, seq.getDBRefs()); - List rseqs = new ArrayList(); + List foundSeqs = new ArrayList(); /* * find sequences in the alignment which xref one of these DBRefs * i.e. is xref-ed to a common sequence identifier */ - searchDatasetXrefs(seq, lrfs, rseqs, null); + searchDatasetXrefs(fromDna, seq, lrfs, foundSeqs, null); /* * add those sequences' (dna-to-peptide or peptide-to-dna) dbref sources */ - for (SequenceI rs : rseqs) + for (SequenceI rs : foundSeqs) { DBRefEntry[] xrs = DBRefUtils .selectDbRefs(!fromDna, rs.getDBRefs()); @@ -194,12 +204,12 @@ public class CrossRef * @param source * @return cross-referenced sequences (as dataset sequences) */ - public Alignment findXrefSequences(String source) + public Alignment findXrefSequences(String source, boolean fromDna) { - List rseqs = new ArrayList(); + rseqs = new ArrayList(); AlignedCodonFrame cf = new AlignedCodonFrame(); - SequenceIdMatcher matcher = new SequenceIdMatcher( + matcher = new SequenceIdMatcher( dataset.getSequences()); for (SequenceI seq : fromSeqs) @@ -212,6 +222,9 @@ public class CrossRef boolean found = false; DBRefEntry[] xrfs = DBRefUtils .selectDbRefs(!fromDna, dss.getDBRefs()); + // ENST & ENSP comes in to both Protein and nucleotide, so we need to + // filter them + // out later. if ((xrfs == null || xrfs.length == 0) && dataset != null) { /* @@ -226,7 +239,7 @@ public class CrossRef * which have a dbref to an accession id for this sequence, * and add them to the results */ - found = searchDatasetXrefs(dss, lrfs, rseqs, cf); + found = searchDatasetXrefs(fromDna, dss, lrfs, rseqs, cf); } if (xrfs == null && !found) { @@ -239,11 +252,15 @@ public class CrossRef List sourceRefs = DBRefUtils.searchRefsForSource(xrfs, source); Iterator refIterator = sourceRefs.iterator(); + // At this point, if we are retrieving Ensembl, we still don't filter out + // ENST when looking for protein crossrefs. while (refIterator.hasNext()) { DBRefEntry xref = refIterator.next(); found = false; - if (xref.hasMap()) + // we're only interested in coding cross-references, not + // locus->transcript + if (xref.hasMap() && xref.getMap().getMap().isTripletMap()) { SequenceI mappedTo = xref.getMap().getTo(); if (mappedTo != null) @@ -261,6 +278,18 @@ public class CrossRef * but findInDataset() matches ENSP when looking for Uniprot... */ SequenceI matchInDataset = findInDataset(xref); + if (matchInDataset != null && xref.getMap().getTo() != null + && matchInDataset != xref.getMap().getTo()) + { + System.err + .println("Implementation problem (reopen JAL-2154): CrossRef.findInDataset seems to have recovered a different sequence than the one explicitly mapped for xref." + + "Found:" + + matchInDataset + + "\nExpected:" + + xref.getMap().getTo() + + "\nFor xref:" + + xref); + } /*matcher.findIdMatch(mappedTo);*/ if (matchInDataset != null) { @@ -268,24 +297,47 @@ public class CrossRef { rseqs.add(matchInDataset); } + // even if rseqs contained matchInDataset - check mappings between + // these seqs are added + // need to try harder to only add unique mappings + if (xref.getMap().getMap().isTripletMap() + && dataset.getMapping(seq, matchInDataset) == null + && cf.getMappingBetween(seq, matchInDataset) == null) + { + // materialise a mapping for highlighting between these + // sequences + if (fromDna) + { + cf.addMap(dss, matchInDataset, xref.getMap().getMap(), + xref.getMap().getMappedFromId()); + } + else + { + cf.addMap(matchInDataset, dss, xref.getMap().getMap() + .getInverse(), xref.getMap().getMappedFromId()); + } + } + refIterator.remove(); continue; } + // TODO: need to determine if this should be a deriveSequence SequenceI rsq = new Sequence(mappedTo); rseqs.add(rsq); - if (xref.getMap().getMap().getFromRatio() != xref.getMap() - .getMap().getToRatio()) + if (xref.getMap().getMap().isTripletMap()) { // get sense of map correct for adding to product alignment. if (fromDna) { // map is from dna seq to a protein product - cf.addMap(dss, rsq, xref.getMap().getMap()); + cf.addMap(dss, rsq, xref.getMap().getMap(), xref.getMap() + .getMappedFromId()); } else { // map should be from protein seq to its coding dna - cf.addMap(rsq, dss, xref.getMap().getMap().getInverse()); + cf.addMap(rsq, dss, xref.getMap().getMap().getInverse(), + xref.getMap().getMappedFromId()); } } } @@ -295,9 +347,11 @@ public class CrossRef { SequenceI matchedSeq = matcher.findIdMatch(xref.getSource() + "|" + xref.getAccessionId()); - if (matchedSeq != null) + // if there was a match, check it's at least the right type of + // molecule! + if (matchedSeq != null && matchedSeq.isProtein() == fromDna) { - if (constructMapping(seq, matchedSeq, xref, cf)) + if (constructMapping(seq, matchedSeq, xref, cf, fromDna)) { found = true; } @@ -308,7 +362,7 @@ public class CrossRef { // do a bit more work - search for sequences with references matching // xrefs on this sequence. - found = searchDataset(dss, xref, rseqs, cf, false); + found = searchDataset(fromDna, dss, xref, rseqs, cf, false); } if (found) { @@ -321,153 +375,215 @@ public class CrossRef */ if (!sourceRefs.isEmpty()) { - ASequenceFetcher sftch = SequenceFetcherFactory - .getSequenceFetcher(); - SequenceI[] retrieved = null; - try - { - retrieved = sftch.getSequences(sourceRefs, !fromDna); - } catch (Exception e) + retrieveCrossRef(sourceRefs, seq, xrfs, fromDna, cf); + } + } + + Alignment ral = null; + if (rseqs.size() > 0) + { + ral = new Alignment(rseqs.toArray(new SequenceI[rseqs.size()])); + if (!cf.isEmpty()) + { + dataset.addCodonFrame(cf); + } + } + return ral; + } + + private void retrieveCrossRef(List sourceRefs, SequenceI seq, + DBRefEntry[] xrfs, boolean fromDna, AlignedCodonFrame cf) + { + ASequenceFetcher sftch = SequenceFetcherFactory.getSequenceFetcher(); + SequenceI[] retrieved = null; + SequenceI dss = seq.getDatasetSequence() == null ? seq : seq + .getDatasetSequence(); + // first filter in case we are retrieving crossrefs that have already been + // retrieved. this happens for cases where a database record doesn't yield + // protein products for CDS + removeAlreadyRetrievedSeqs(sourceRefs, fromDna); + if (sourceRefs.size() == 0) + { + // no more work to do! We already had all requested sequence records in + // the dataset. + return; + } + try + { + retrieved = sftch.getSequences(sourceRefs, !fromDna); + } catch (Exception e) + { + System.err + .println("Problem whilst retrieving cross references for Sequence : " + + seq.getName()); + e.printStackTrace(); + } + + if (retrieved != null) + { + updateDbrefMappings(seq, xrfs, retrieved, cf, fromDna); + for (SequenceI retrievedSequence : retrieved) + { + // dataset gets contaminated ccwith non-ds sequences. why ??! + // try: Ensembl -> Nuc->Ensembl, Nuc->Uniprot-->Protein->EMBL-> + SequenceI retrievedDss = retrievedSequence.getDatasetSequence() == null ? retrievedSequence + : retrievedSequence.getDatasetSequence(); + DBRefEntry[] dbr = retrievedSequence.getDBRefs(); + if (dbr != null) + + /** + * Search dataset for sequences with a primary reference contained in + * sourceRefs. + * + * @param sourceRefs + * - list of references to filter. + * @param fromDna + * - type of sequence to search for matching primary reference. + */ + private void removeAlreadyRetrievedSeqs(List sourceRefs, + boolean fromDna) + { + DBRefEntry[] dbrSourceSet = sourceRefs.toArray(new DBRefEntry[0]); + for (SequenceI sq : dataset.getSequences()) + { + boolean dupeFound = false; + // !fromDna means we are looking only for nucleotide sequences, not + // protein + if (sq.isProtein() == fromDna) + { + for (DBRefEntry dbr : sq.getPrimaryDBRefs()) { - System.err - .println("Problem whilst retrieving cross references for Sequence : " - + seq.getName()); - e.printStackTrace(); + for (DBRefEntry found : DBRefUtils.searchRefs(dbrSourceSet, dbr)) + { + sourceRefs.remove(found); + dupeFound = true; + } } + } + if (dupeFound) + { + dbrSourceSet = sourceRefs.toArray(new DBRefEntry[0]); + } + } + } - if (retrieved != null) { - updateDbrefMappings(seq, xrfs, retrieved, cf); - for (SequenceI retrievedSequence : retrieved) + for (DBRefEntry dbref : dbr) { - SequenceI retrievedDss = retrievedSequence.getDatasetSequence() == null ? retrievedSequence - : retrievedSequence.getDatasetSequence(); - DBRefEntry[] dbr = retrievedSequence.getDBRefs(); - if (dbr != null) + // find any entry where we should put in the sequence being + // cross-referenced into the map + Mapping map = dbref.getMap(); + if (map != null) { - for (DBRefEntry dbref : dbr) + if (map.getTo() != null && map.getMap() != null) { - // find any entry where we should put in the sequence being - // cross-referenced into the map - Mapping map = dbref.getMap(); - if (map != null) + // TODO findInDataset requires exact sequence match but + // 'congruent' test is only for the mapped part + // maybe not a problem in practice since only ENA provide a + // mapping and it is to the full protein translation of CDS + SequenceI matched = findInDataset(dbref); + // matcher.findIdMatch(map.getTo()); + if (matched != null) { - if (map.getTo() != null && map.getMap() != null) + /* + * already got an xref to this sequence; update this + * map to point to the same sequence, and add + * any new dbrefs to it + */ + DBRefEntry[] toRefs = map.getTo().getDBRefs(); + if (toRefs != null) { - // TODO findInDataset requires exact sequence match but - // 'congruent' test is only for the mapped part - // maybe not a problem in practice since only ENA provide a - // mapping and it is to the full protein translation of CDS - SequenceI matched = findInDataset(dbref); - // matcher.findIdMatch(map.getTo()); - if (matched != null) - { - /* - * already got an xref to this sequence; update this - * map to point to the same sequence, and add - * any new dbrefs to it - */ - DBRefEntry[] toRefs = map.getTo().getDBRefs(); - if (toRefs != null) - { - for (DBRefEntry ref : toRefs) - { - matched.addDBRef(ref); // add or update mapping - } - } - map.setTo(matched); - } - else + for (DBRefEntry ref : toRefs) { - matcher.add(map.getTo()); + matched.addDBRef(ref); // add or update mapping } - try + } + map.setTo(matched); + } + else + { + if (dataset.findIndex(map.getTo()) == -1) + { + dataset.addSequence(map.getTo()); + matcher.add(map.getTo()); + } + } + try + { + // compare ms with dss and replace with dss in mapping + // if map is congruent + SequenceI ms = map.getTo(); + int sf = map.getMap().getToLowest(); + int st = map.getMap().getToHighest(); + SequenceI mappedrg = ms.getSubSequence(sf, st); + // SequenceI loc = dss.getSubSequence(sf, st); + if (mappedrg.getLength() > 0 + && ms.getSequenceAsString().equals( + dss.getSequenceAsString())) + // && mappedrg.getSequenceAsString().equals( + // loc.getSequenceAsString())) + { + String msg = "Mapping updated from " + ms.getName() + + " to retrieved crossreference " + + dss.getName(); + System.out.println(msg); + map.setTo(dss); + + /* + * give the reverse reference the inverse mapping + * (if it doesn't have one already) + */ + setReverseMapping(dss, dbref, cf); + + /* + * copy sequence features as well, avoiding + * duplication (e.g. same variation from two + * transcripts) + */ + SequenceFeature[] sfs = ms.getSequenceFeatures(); + if (sfs != null) { - // compare ms with dss and replace with dss in mapping - // if map is congruent - SequenceI ms = map.getTo(); - int sf = map.getMap().getToLowest(); - int st = map.getMap().getToHighest(); - SequenceI mappedrg = ms.getSubSequence(sf, st); - // SequenceI loc = dss.getSubSequence(sf, st); - if (mappedrg.getLength() > 0 - && ms.getSequenceAsString().equals( - dss.getSequenceAsString())) - // && mappedrg.getSequenceAsString().equals( - // loc.getSequenceAsString())) + for (SequenceFeature feat : sfs) { - String msg = "Mapping updated from " + ms.getName() - + " to retrieved crossreference " - + dss.getName(); - System.out.println(msg); - map.setTo(dss); - - /* - * give the reverse reference the inverse mapping - * (if it doesn't have one already) - */ - setReverseMapping(dss, dbref, cf); - /* - * copy sequence features as well, avoiding - * duplication (e.g. same variation from two - * transcripts) + * make a flyweight feature object which ignores Parent + * attribute in equality test; this avoids creating many + * otherwise duplicate exon features on genomic sequence */ - SequenceFeature[] sfs = ms.getSequenceFeatures(); - if (sfs != null) + SequenceFeature newFeature = new SequenceFeature( + feat) { - for (SequenceFeature feat : sfs) + @Override + public boolean equals(Object o) { - /* - * make a flyweight feature object which ignores Parent - * attribute in equality test; this avoids creating many - * otherwise duplicate exon features on genomic sequence - */ - SequenceFeature newFeature = new SequenceFeature( - feat) - { - @Override - public boolean equals(Object o) - { - return super.equals(o, true); - } - }; - dss.addSequenceFeature(newFeature); + return super.equals(o, true); } - } + }; + dss.addSequenceFeature(newFeature); } - cf.addMap(retrievedDss, map.getTo(), map.getMap()); - } catch (Exception e) - { - System.err - .println("Exception when consolidating Mapped sequence set..."); - e.printStackTrace(System.err); } } + cf.addMap(retrievedDss, map.getTo(), map.getMap()); + } catch (Exception e) + { + System.err + .println("Exception when consolidating Mapped sequence set..."); + e.printStackTrace(System.err); } } } - retrievedSequence.updatePDBIds(); - rseqs.add(retrievedDss); - dataset.addSequence(retrievedDss); - matcher.add(retrievedDss); } } + retrievedSequence.updatePDBIds(); + rseqs.add(retrievedDss); + if (dataset.findIndex(retrievedDss) == -1) + { + dataset.addSequence(retrievedDss); + matcher.add(retrievedDss); + } } } - - Alignment ral = null; - if (rseqs.size() > 0) - { - ral = new Alignment(rseqs.toArray(new SequenceI[rseqs.size()])); - if (!cf.isEmpty()) - { - dataset.addCodonFrame(cf); - } - } - return ral; } - /** * Sets the inverse sequence mapping in the corresponding dbref of the mapped * to sequence (if any). This is used after fetching a cross-referenced @@ -526,6 +642,12 @@ public class CrossRef String name2 = xref.getSource() + "|" + name; SequenceI dss = mapsTo.getDatasetSequence() == null ? mapsTo : mapsTo .getDatasetSequence(); + // first check ds if ds is directly referenced + if (dataset.findIndex(dss) > -1) + { + return dss; + } + ; for (SequenceI seq : dataset.getSequences()) { /* @@ -595,24 +717,24 @@ public class CrossRef * @param retrieved * @param acf */ - void updateDbrefMappings(SequenceI mapFrom, - DBRefEntry[] xrefs, SequenceI[] retrieved, AlignedCodonFrame acf) + void updateDbrefMappings(SequenceI mapFrom, DBRefEntry[] xrefs, + SequenceI[] retrieved, AlignedCodonFrame acf, boolean fromDna) { - SequenceIdMatcher matcher = new SequenceIdMatcher(retrieved); + SequenceIdMatcher idMatcher = new SequenceIdMatcher(retrieved); for (DBRefEntry xref : xrefs) { if (!xref.hasMap()) { String targetSeqName = xref.getSource() + "|" + xref.getAccessionId(); - SequenceI[] matches = matcher.findAllIdMatches(targetSeqName); + SequenceI[] matches = idMatcher.findAllIdMatches(targetSeqName); if (matches == null) { return; } for (SequenceI seq : matches) { - constructMapping(mapFrom, seq, xref, acf); + constructMapping(mapFrom, seq, xref, acf, fromDna); } } } @@ -639,27 +761,31 @@ public class CrossRef * @return */ boolean constructMapping(SequenceI mapFrom, SequenceI mapTo, - DBRefEntry xref, AlignedCodonFrame mappings) + DBRefEntry xref, AlignedCodonFrame mappings, boolean fromDna) { MapList mapping = null; - + SequenceI dsmapFrom = mapFrom.getDatasetSequence() == null ? mapFrom + : mapFrom.getDatasetSequence(); + SequenceI dsmapTo = mapTo.getDatasetSequence() == null ? mapTo + : mapTo.getDatasetSequence(); /* - * look for a reverse mapping, if found make its inverse + * look for a reverse mapping, if found make its inverse. + * Note - we do this on dataset sequences only. */ - if (mapTo.getDBRefs() != null) + if (dsmapTo.getDBRefs() != null) { - for (DBRefEntry dbref : mapTo.getDBRefs()) + for (DBRefEntry dbref : dsmapTo.getDBRefs()) { String name = dbref.getSource() + "|" + dbref.getAccessionId(); - if (dbref.hasMap() && mapFrom.getName().startsWith(name)) + if (dbref.hasMap() && dsmapFrom.getName().startsWith(name)) { /* * looks like we've found a map from 'mapTo' to 'mapFrom' * - invert it to make the mapping the other way */ MapList reverse = dbref.getMap().getMap().getInverse(); - xref.setMap(new Mapping(mapTo, reverse)); - mappings.addMap(mapFrom, mapTo, reverse); + xref.setMap(new Mapping(dsmapTo, reverse)); + mappings.addMap(mapFrom, dsmapTo, reverse); return true; } } @@ -682,6 +808,22 @@ public class CrossRef return false; } xref.setMap(new Mapping(mapTo, mapping)); + + /* + * and add a reverse DbRef with the inverse mapping + */ + if (mapFrom.getDatasetSequence() != null && false) + // && mapFrom.getDatasetSequence().getSourceDBRef() != null) + { + // possible need to search primary references... except, why doesn't xref + // == getSourceDBRef ?? + // DBRefEntry dbref = new DBRefEntry(mapFrom.getDatasetSequence() + // .getSourceDBRef()); + // dbref.setMap(new Mapping(mapFrom.getDatasetSequence(), mapping + // .getInverse())); + // mapTo.addDBRef(dbref); + } + if (fromDna) { AlignmentUtils.computeProteinFeatures(mapFrom, mapTo, mapping); @@ -700,13 +842,16 @@ public class CrossRef * dataset (that is not equal to sequenceI) Identifies matching DBRefEntry * based on source and accession string only - Map and Version are nulled. * + * @param fromDna + * - true if context was searching from Dna sequences, false if + * context was searching from Protein sequences * @param sequenceI * @param lrfs - * @param rseqs + * @param foundSeqs * @return true if matches were found. */ - private boolean searchDatasetXrefs(SequenceI sequenceI, - DBRefEntry[] lrfs, List rseqs, AlignedCodonFrame cf) + private boolean searchDatasetXrefs(boolean fromDna, SequenceI sequenceI, + DBRefEntry[] lrfs, List foundSeqs, AlignedCodonFrame cf) { boolean found = false; if (lrfs == null) @@ -719,7 +864,7 @@ public class CrossRef // add in wildcards xref.setVersion(null); xref.setMap(null); - found |= searchDataset(sequenceI, xref, rseqs, cf, false); + found |= searchDataset(fromDna, sequenceI, xref, foundSeqs, cf, false); } return found; } @@ -728,20 +873,33 @@ public class CrossRef * Searches dataset for DBRefEntrys matching the given one (xrf) and adds the * associated sequence to rseqs * - * @param sequenceI + * @param fromDna + * true if context was searching for refs *from* dna sequence, false + * if context was searching for refs *from* protein sequence + * @param fromSeq * a sequence to ignore (start point of search) * @param xrf * a cross-reference to try to match - * @param rseqs + * @param foundSeqs * result list to add to - * @param cf + * @param mappings * a set of sequence mappings to add to * @param direct - * - search all references or only subset + * - indicates the type of relationship between returned sequences, + * xrf, and sequenceI that is required. + *
    + *
  • direct implies xrf is a primary reference for sequenceI AND + * the sequences to be located (eg a uniprot ID for a protein + * sequence, and a uniprot ref on a transcript sequence).
    • + *
  • indirect means xrf is a cross reference with respect to + * sequenceI or all the returned sequences (eg a genomic reference + * associated with a locus and one or more transcripts)
    • + *
* @return true if relationship found and sequence added. */ - boolean searchDataset(SequenceI sequenceI, DBRefEntry xrf, - List rseqs, AlignedCodonFrame cf, boolean direct) + boolean searchDataset(boolean fromDna, SequenceI fromSeq, DBRefEntry xrf, + List foundSeqs, AlignedCodonFrame mappings, + boolean direct) { boolean found = false; if (dataset == null) @@ -763,9 +921,13 @@ public class CrossRef if (nxt.getDatasetSequence() != null) { System.err - .println("Implementation warning: getProducts passed a dataset alignment without dataset sequences in it!"); + .println("Implementation warning: CrossRef initialised with a dataset alignment with non-dataset sequences in it! (" + + nxt.getDisplayId(true) + + " has ds reference " + + nxt.getDatasetSequence().getDisplayId(true) + + ")"); } - if (nxt == sequenceI || nxt == sequenceI.getDatasetSequence()) + if (nxt == fromSeq || nxt == fromSeq.getDatasetSequence()) { continue; } @@ -774,8 +936,7 @@ public class CrossRef * complementary type if !direct */ { - boolean isDna = Comparison - .isNucleotide(new SequenceI[] { nxt }); + boolean isDna = !nxt.isProtein(); if (direct ? (isDna != fromDna) : (isDna == fromDna)) { // skip this sequence because it is wrong molecule type @@ -786,56 +947,54 @@ public class CrossRef // look for direct or indirect references in common DBRefEntry[] poss = nxt.getDBRefs(); List cands = null; - /* - * TODO does this make any sense? - * if 'direct', search the dbrefs for xrf - * else, filter the dbrefs by type and then search for xrf - * - the result is the same isn't it? - */ - if (direct) - { - cands = DBRefUtils.searchRefs(poss, xrf); - } - else - { - poss = DBRefUtils.selectDbRefs(!fromDna, poss); - cands = DBRefUtils.searchRefs(poss, xrf); - } + + // todo: indirect specifies we select either direct references to nxt + // that match xrf which is indirect to sequenceI, or indirect + // references to nxt that match xrf which is direct to sequenceI + cands = DBRefUtils.searchRefs(poss, xrf); + // else + // { + // poss = DBRefUtils.selectDbRefs(nxt.isProtein()!fromDna, poss); + // cands = DBRefUtils.searchRefs(poss, xrf); + // } if (!cands.isEmpty()) { - if (!rseqs.contains(nxt)) + if (foundSeqs.contains(nxt)) { - found = true; - rseqs.add(nxt); - if (cf != null) + continue; + } + found = true; + foundSeqs.add(nxt); + if (mappings != null && !direct) + { + /* + * if the matched sequence has mapped dbrefs to + * protein product / cdna, add equivalent mappings to + * our source sequence + */ + for (DBRefEntry candidate : cands) { - // don't search if we aren't given a codon map object - for (DBRefEntry candidate : cands) + Mapping mapping = candidate.getMap(); + if (mapping != null) { - Mapping mapping = candidate.getMap(); - if (mapping != null) + MapList map = mapping.getMap(); + if (mapping.getTo() != null + && map.getFromRatio() != map.getToRatio()) { - MapList map = mapping.getMap(); - if (mapping.getTo() != null - && map.getFromRatio() != map.getToRatio()) + /* + * add a mapping, as from dna to peptide sequence + */ + if (map.getFromRatio() == 3) { - // get sense of map correct for adding to product - // alignment. - if (fromDna) - { - // map is from dna seq to a protein product - cf.addMap(sequenceI, nxt, map); - } - else - { - // map should be from protein seq to its coding dna - cf.addMap(nxt, sequenceI, map.getInverse()); - } + mappings.addMap(nxt, fromSeq, map); + } + else + { + mappings.addMap(nxt, fromSeq, map.getInverse()); } } } } - // TODO: add mapping between sequences if necessary } } }