*/
package jalview.analysis;
+import static jalview.io.gff.GffConstants.CLINICAL_SIGNIFICANCE;
+
import jalview.datamodel.AlignedCodon;
import jalview.datamodel.AlignedCodonFrame;
+import jalview.datamodel.AlignedCodonFrame.SequenceToSequenceMapping;
import jalview.datamodel.Alignment;
import jalview.datamodel.AlignmentAnnotation;
import jalview.datamodel.AlignmentI;
import jalview.datamodel.DBRefEntry;
-import jalview.datamodel.DBRefSource;
-import jalview.datamodel.FeatureProperties;
import jalview.datamodel.IncompleteCodonException;
import jalview.datamodel.Mapping;
-import jalview.datamodel.SearchResults;
import jalview.datamodel.Sequence;
import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceGroup;
import jalview.util.MappingUtils;
import jalview.util.StringUtils;
+import java.io.UnsupportedEncodingException;
+import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
public class AlignmentUtils
{
+ private static final int CODON_LENGTH = 3;
+
+ private static final String SEQUENCE_VARIANT = "sequence_variant:";
+
+ private static final String ID = "ID";
+
+ /**
+ * A data model to hold the 'normal' base value at a position, and an optional
+ * sequence variant feature
+ */
+ static final class DnaVariant
+ {
+ final String base;
+
+ SequenceFeature variant;
+
+ DnaVariant(String nuc)
+ {
+ base = nuc;
+ variant = null;
+ }
+
+ DnaVariant(String nuc, SequenceFeature var)
+ {
+ base = nuc;
+ variant = var;
+ }
+
+ public String getSource()
+ {
+ return variant == null ? null : variant.getFeatureGroup();
+ }
+ }
+
/**
* given an existing alignment, create a new alignment including all, or up to
* flankSize additional symbols from each sequence's dataset sequence
/*
* cdnaStart/End, proteinStartEnd are base 1 (for dataset sequence mapping)
*/
- final int mappedLength = 3 * aaSeqChars.length;
+ final int mappedLength = CODON_LENGTH * aaSeqChars.length;
int cdnaLength = cdnaSeqChars.length;
int cdnaStart = cdnaSeq.getStart();
int cdnaEnd = cdnaSeq.getEnd();
*/
if (cdnaLength != mappedLength && cdnaLength > 2)
{
- String lastCodon = String.valueOf(cdnaSeqChars, cdnaLength - 3, 3)
- .toUpperCase();
+ String lastCodon = String.valueOf(cdnaSeqChars,
+ cdnaLength - CODON_LENGTH, CODON_LENGTH).toUpperCase();
for (String stop : ResidueProperties.STOP)
{
if (lastCodon.equals(stop))
{
- cdnaEnd -= 3;
- cdnaLength -= 3;
+ cdnaEnd -= CODON_LENGTH;
+ cdnaLength -= CODON_LENGTH;
break;
}
}
int startOffset = 0;
if (cdnaLength != mappedLength
&& cdnaLength > 2
- && String.valueOf(cdnaSeqChars, 0, 3).toUpperCase()
+ && String.valueOf(cdnaSeqChars, 0, CODON_LENGTH).toUpperCase()
.equals(ResidueProperties.START))
{
- startOffset += 3;
- cdnaStart += 3;
- cdnaLength -= 3;
+ startOffset += CODON_LENGTH;
+ cdnaStart += CODON_LENGTH;
+ cdnaLength -= CODON_LENGTH;
}
if (translatesAs(cdnaSeqChars, startOffset, aaSeqChars))
* protein is translation of dna (+/- start/stop codons)
*/
MapList map = new MapList(new int[] { cdnaStart, cdnaEnd }, new int[]
- { proteinStart, proteinEnd }, 3, 1);
+ { proteinStart, proteinEnd }, CODON_LENGTH, 1);
return map;
}
int aaPos = 0;
int dnaPos = cdnaStart;
- for (; dnaPos < cdnaSeqChars.length - 2
- && aaPos < aaSeqChars.length; dnaPos += 3, aaPos++)
+ for (; dnaPos < cdnaSeqChars.length - 2 && aaPos < aaSeqChars.length; dnaPos += CODON_LENGTH, aaPos++)
{
- String codon = String.valueOf(cdnaSeqChars, dnaPos, 3);
+ String codon = String.valueOf(cdnaSeqChars, dnaPos, CODON_LENGTH);
final String translated = ResidueProperties.codonTranslate(codon);
/*
{
return true;
}
- if (dnaPos == cdnaSeqChars.length - 3)
+ if (dnaPos == cdnaSeqChars.length - CODON_LENGTH)
{
- String codon = String.valueOf(cdnaSeqChars, dnaPos, 3);
+ String codon = String.valueOf(cdnaSeqChars, dnaPos, CODON_LENGTH);
if ("STOP".equals(ResidueProperties.codonTranslate(codon)))
{
return true;
AlignedCodonFrame mapping = null;
for (AlignedCodonFrame mp : mappings)
{
- alignFrom = mp.findAlignedSequence(seq.getDatasetSequence(), al);
+ alignFrom = mp.findAlignedSequence(seq, al);
if (alignFrom != null)
{
mapping = mp;
}
/**
- * Returns a list of sequences mapped from the given sequences and aligned
- * (gapped) in the same way. For example, the cDNA for aligned protein, where
- * a single gap in protein generates three gaps in cDNA.
+ * Realigns the given protein to match the alignment of the dna, using codon
+ * mappings to translate aligned codon positions to protein residues.
*
- * @param sequences
- * @param gapCharacter
- * @param mappings
- * @return
+ * @param protein
+ * the alignment whose sequences are realigned by this method
+ * @param dna
+ * the dna alignment whose alignment we are 'copying'
+ * @return the number of sequences that were realigned
*/
- public static List<SequenceI> getAlignedTranslation(
- List<SequenceI> sequences, char gapCharacter,
- Set<AlignedCodonFrame> mappings)
+ public static int alignProteinAsDna(AlignmentI protein, AlignmentI dna)
{
- List<SequenceI> alignedSeqs = new ArrayList<SequenceI>();
-
- for (SequenceI seq : sequences)
+ if (protein.isNucleotide() || !dna.isNucleotide())
{
- List<SequenceI> mapped = getAlignedTranslation(seq, gapCharacter,
- mappings);
- alignedSeqs.addAll(mapped);
+ System.err.println("Wrong alignment type in alignProteinAsDna");
+ return 0;
}
- return alignedSeqs;
+ List<SequenceI> unmappedProtein = new ArrayList<SequenceI>();
+ Map<AlignedCodon, Map<SequenceI, AlignedCodon>> alignedCodons = buildCodonColumnsMap(
+ protein, dna, unmappedProtein);
+ return alignProteinAs(protein, alignedCodons, unmappedProtein);
}
/**
- * Returns sequences aligned 'like' the source sequence, as mapped by the
- * given mappings. Normally we expect zero or one 'mapped' sequences, but this
- * will support 1-to-many as well.
+ * Realigns the given dna to match the alignment of the protein, using codon
+ * mappings to translate aligned peptide positions to codons.
*
- * @param seq
- * @param gapCharacter
- * @param mappings
- * @return
+ * Always produces a padded CDS alignment.
+ *
+ * @param dna
+ * the alignment whose sequences are realigned by this method
+ * @param protein
+ * the protein alignment whose alignment we are 'copying'
+ * @return the number of sequences that were realigned
*/
- protected static List<SequenceI> getAlignedTranslation(SequenceI seq,
- char gapCharacter, Set<AlignedCodonFrame> mappings)
+ public static int alignCdsAsProtein(AlignmentI dna, AlignmentI protein)
{
- List<SequenceI> result = new ArrayList<SequenceI>();
- for (AlignedCodonFrame mapping : mappings)
+ if (protein.isNucleotide() || !dna.isNucleotide())
+ {
+ System.err.println("Wrong alignment type in alignProteinAsDna");
+ return 0;
+ }
+ // todo: implement this
+ List<AlignedCodonFrame> mappings = protein.getCodonFrames();
+ int alignedCount = 0;
+ int width = 0; // alignment width for padding CDS
+ for (SequenceI dnaSeq : dna.getSequences())
{
- if (mapping.involvesSequence(seq))
+ if (alignCdsSequenceAsProtein(dnaSeq, protein, mappings,
+ dna.getGapCharacter()))
{
- SequenceI mapped = getAlignedTranslation(seq, gapCharacter, mapping);
- if (mapped != null)
- {
- result.add(mapped);
- }
+ alignedCount++;
}
+ width = Math.max(dnaSeq.getLength(), width);
}
- return result;
+ int oldwidth;
+ int diff;
+ for (SequenceI dnaSeq : dna.getSequences())
+ {
+ oldwidth = dnaSeq.getLength();
+ diff = width - oldwidth;
+ if (diff > 0)
+ {
+ dnaSeq.insertCharAt(oldwidth, diff, dna.getGapCharacter());
+ }
+ }
+ return alignedCount;
}
/**
- * Returns the translation of 'seq' (as held in the mapping) with
- * corresponding alignment (gaps).
+ * Helper method to align (if possible) the dna sequence to match the
+ * alignment of a mapped protein sequence. This is currently limited to
+ * handling coding sequence only.
*
- * @param seq
- * @param gapCharacter
- * @param mapping
+ * @param cdsSeq
+ * @param protein
+ * @param mappings
+ * @param gapChar
* @return
*/
- protected static SequenceI getAlignedTranslation(SequenceI seq,
- char gapCharacter, AlignedCodonFrame mapping)
+ static boolean alignCdsSequenceAsProtein(SequenceI cdsSeq,
+ AlignmentI protein, List<AlignedCodonFrame> mappings, char gapChar)
{
- String gap = String.valueOf(gapCharacter);
- boolean toDna = false;
- int fromRatio = 1;
- SequenceI mapTo = mapping.getDnaForAaSeq(seq);
- if (mapTo != null)
- {
- // mapping is from protein to nucleotide
- toDna = true;
- // should ideally get gap count ratio from mapping
- gap = String.valueOf(new char[] { gapCharacter, gapCharacter,
- gapCharacter });
- }
- else
+ SequenceI cdsDss = cdsSeq.getDatasetSequence();
+ if (cdsDss == null)
{
- // mapping is from nucleotide to protein
- mapTo = mapping.getAaForDnaSeq(seq);
- fromRatio = 3;
+ System.err
+ .println("alignCdsSequenceAsProtein needs aligned sequence!");
+ return false;
}
- StringBuilder newseq = new StringBuilder(seq.getLength()
- * (toDna ? 3 : 1));
- int residueNo = 0; // in seq, base 1
- int[] phrase = new int[fromRatio];
- int phraseOffset = 0;
- int gapWidth = 0;
- boolean first = true;
- final Sequence alignedSeq = new Sequence("", "");
-
- for (char c : seq.getSequence())
+ List<AlignedCodonFrame> dnaMappings = MappingUtils
+ .findMappingsForSequence(cdsSeq, mappings);
+ for (AlignedCodonFrame mapping : dnaMappings)
{
- if (c == gapCharacter)
- {
- gapWidth++;
- if (gapWidth >= fromRatio)
- {
- newseq.append(gap);
- gapWidth = 0;
- }
- }
- else
+ SequenceI peptide = mapping.findAlignedSequence(cdsSeq, protein);
+ if (peptide != null)
{
- phrase[phraseOffset++] = residueNo + 1;
- if (phraseOffset == fromRatio)
+ int peptideLength = peptide.getLength();
+ Mapping map = mapping.getMappingBetween(cdsSeq, peptide);
+ if (map != null)
{
+ MapList mapList = map.getMap();
+ if (map.getTo() == peptide.getDatasetSequence())
+ {
+ mapList = mapList.getInverse();
+ }
+ int cdsLength = cdsDss.getLength();
+ int mappedFromLength = MappingUtils.getLength(mapList
+ .getFromRanges());
+ int mappedToLength = MappingUtils
+ .getLength(mapList.getToRanges());
+ boolean addStopCodon = (cdsLength == mappedFromLength
+ * CODON_LENGTH + CODON_LENGTH)
+ || (peptide.getDatasetSequence().getLength() == mappedFromLength - 1);
+ if (cdsLength != mappedToLength && !addStopCodon)
+ {
+ System.err
+ .println(String
+ .format("Can't align cds as protein (length mismatch %d/%d): %s",
+ cdsLength, mappedToLength,
+ cdsSeq.getName()));
+ }
+
+ /*
+ * pre-fill the aligned cds sequence with gaps
+ */
+ char[] alignedCds = new char[peptideLength * CODON_LENGTH
+ + (addStopCodon ? CODON_LENGTH : 0)];
+ Arrays.fill(alignedCds, gapChar);
+
/*
- * Have read a whole codon (or protein residue), now translate: map
- * source phrase to positions in target sequence add characters at
- * these positions to newseq Note mapping positions are base 1, our
- * sequence positions base 0.
+ * walk over the aligned peptide sequence and insert mapped
+ * codons for residues in the aligned cds sequence
*/
- SearchResults sr = new SearchResults();
- for (int pos : phrase)
+ char[] alignedPeptide = peptide.getSequence();
+ char[] nucleotides = cdsDss.getSequence();
+ int copiedBases = 0;
+ int cdsStart = cdsDss.getStart();
+ int proteinPos = peptide.getStart() - 1;
+ int cdsCol = 0;
+ for (char residue : alignedPeptide)
{
- mapping.markMappedRegion(seq, pos, sr);
+ if (Comparison.isGap(residue))
+ {
+ cdsCol += CODON_LENGTH;
+ }
+ else
+ {
+ proteinPos++;
+ int[] codon = mapList.locateInTo(proteinPos, proteinPos);
+ if (codon == null)
+ {
+ // e.g. incomplete start codon, X in peptide
+ cdsCol += CODON_LENGTH;
+ }
+ else
+ {
+ for (int j = codon[0]; j <= codon[1]; j++)
+ {
+ char mappedBase = nucleotides[j - cdsStart];
+ alignedCds[cdsCol++] = mappedBase;
+ copiedBases++;
+ }
+ }
+ }
}
- newseq.append(sr.getCharacters());
- if (first)
+
+ /*
+ * append stop codon if not mapped from protein,
+ * closing it up to the end of the mapped sequence
+ */
+ if (copiedBases == nucleotides.length - CODON_LENGTH)
{
- first = false;
- // Hack: Copy sequence dataset, name and description from
- // SearchResults.match[0].sequence
- // TODO? carry over sequence names from original 'complement'
- // alignment
- SequenceI mappedTo = sr.getResultSequence(0);
- alignedSeq.setName(mappedTo.getName());
- alignedSeq.setDescription(mappedTo.getDescription());
- alignedSeq.setDatasetSequence(mappedTo);
+ for (int i = alignedCds.length - 1; i >= 0; i--)
+ {
+ if (!Comparison.isGap(alignedCds[i]))
+ {
+ cdsCol = i + 1; // gap just after end of sequence
+ break;
+ }
+ }
+ for (int i = nucleotides.length - CODON_LENGTH; i < nucleotides.length; i++)
+ {
+ alignedCds[cdsCol++] = nucleotides[i];
+ }
}
- phraseOffset = 0;
+ cdsSeq.setSequence(new String(alignedCds));
+ return true;
}
- residueNo++;
}
}
- alignedSeq.setSequence(newseq.toString());
- return alignedSeq;
- }
-
- /**
- * Realigns the given protein to match the alignment of the dna, using codon
- * mappings to translate aligned codon positions to protein residues.
- *
- * @param protein
- * the alignment whose sequences are realigned by this method
- * @param dna
- * the dna alignment whose alignment we are 'copying'
- * @return the number of sequences that were realigned
- */
- public static int alignProteinAsDna(AlignmentI protein, AlignmentI dna)
- {
- List<SequenceI> unmappedProtein = new ArrayList<SequenceI>();
- Map<AlignedCodon, Map<SequenceI, AlignedCodon>> alignedCodons = buildCodonColumnsMap(
- protein, dna, unmappedProtein);
- return alignProteinAs(protein, alignedCodons, unmappedProtein);
+ return false;
}
/**
{
for (AlignedCodonFrame mapping : mappings)
{
- SequenceI prot = mapping.findAlignedSequence(
- dnaSeq.getDatasetSequence(), protein);
+ SequenceI prot = mapping.findAlignedSequence(dnaSeq, protein);
if (prot != null)
{
Mapping seqMap = mapping.getMappingForSequence(dnaSeq);
* Finally add any unmapped peptide start residues (e.g. for incomplete
* codons) as if at the codon position before the second residue
*/
+ // TODO resolve JAL-2022 so this fudge can be removed
int mappedSequenceCount = protein.getHeight() - unmappedProtein.size();
addUnmappedPeptideStarts(alignedCodons, mappedSequenceCount);
-
+
return alignedCodons;
}
Collection<String> types, List<SequenceI> forSequences,
boolean anyType, boolean doShow)
{
- for (AlignmentAnnotation aa : al.getAlignmentAnnotation())
+ AlignmentAnnotation[] anns = al.getAlignmentAnnotation();
+ if (anns != null)
{
- if (anyType || types.contains(aa.label))
+ for (AlignmentAnnotation aa : anns)
{
- if ((aa.sequenceRef != null)
- && (forSequences == null || forSequences
- .contains(aa.sequenceRef)))
+ if (anyType || types.contains(aa.label))
{
- aa.visible = doShow;
+ if ((aa.sequenceRef != null)
+ && (forSequences == null || forSequences
+ .contains(aa.sequenceRef)))
+ {
+ aa.visible = doShow;
+ }
}
}
}
/**
* Constructs an alignment consisting of the mapped (CDS) regions in the given
- * nucleotide sequences, and updates mappings to match. The new sequences are
- * aligned as per the original sequence, with entirely gapped columns (codon
- * interrupted by intron) omitted.
+ * nucleotide sequences, and updates mappings to match. The CDS sequences are
+ * added to the original alignment's dataset, which is shared by the new
+ * alignment. Mappings from nucleotide to CDS, and from CDS to protein, are
+ * added to the alignment dataset.
*
* @param dna
- * aligned dna sequences
- * @param mappings
- * from dna to protein; these are replaced with new mappings
- * @param al
+ * aligned nucleotide (dna or cds) sequences
+ * @param dataset
+ * the alignment dataset the sequences belong to
+ * @param products
+ * (optional) to restrict results to CDS that map to specified
+ * protein products
* @return an alignment whose sequences are the cds-only parts of the dna
* sequences (or null if no mappings are found)
*/
public static AlignmentI makeCdsAlignment(SequenceI[] dna,
- List<AlignedCodonFrame> mappings, AlignmentI al)
+ AlignmentI dataset, SequenceI[] products)
{
- List<int[]> cdsColumns = findCdsColumns(dna);
-
- /*
- * create CDS sequences and new mappings
- * (from cdna to cds, and cds to peptide)
- */
- List<AlignedCodonFrame> newMappings = new ArrayList<AlignedCodonFrame>();
- List<SequenceI> cdsSequences = new ArrayList<SequenceI>();
- char gap = al.getGapCharacter();
-
- for (SequenceI dnaSeq : dna)
+ if (dataset == null || dataset.getDataset() != null)
{
- final SequenceI ds = dnaSeq.getDatasetSequence();
- List<AlignedCodonFrame> seqMappings = MappingUtils
- .findMappingsForSequence(ds, mappings);
- for (AlignedCodonFrame acf : seqMappings)
+ throw new IllegalArgumentException(
+ "IMPLEMENTATION ERROR: dataset.getDataset() must be null!");
+ }
+ List<SequenceI> foundSeqs = new ArrayList<SequenceI>();
+ List<SequenceI> cdsSeqs = new ArrayList<SequenceI>();
+ List<AlignedCodonFrame> mappings = dataset.getCodonFrames();
+ HashSet<SequenceI> productSeqs = null;
+ if (products != null)
+ {
+ productSeqs = new HashSet<SequenceI>();
+ for (SequenceI seq : products)
{
- AlignedCodonFrame newMapping = new AlignedCodonFrame();
- final List<SequenceI> mappedCds = makeCdsSequences(dnaSeq, acf,
- cdsColumns, newMapping, gap);
- if (!mappedCds.isEmpty())
- {
- cdsSequences.addAll(mappedCds);
- newMappings.add(newMapping);
- }
+ productSeqs.add(seq.getDatasetSequence() == null ? seq : seq
+ .getDatasetSequence());
}
}
- AlignmentI newAl = new Alignment(
- cdsSequences.toArray(new SequenceI[cdsSequences.size()]));
/*
- * add new sequences to the shared dataset, set it on the new alignment
+ * Construct CDS sequences from mappings on the alignment dataset.
+ * The logic is:
+ * - find the protein product(s) mapped to from each dna sequence
+ * - if the mapping covers the whole dna sequence (give or take start/stop
+ * codon), take the dna as the CDS sequence
+ * - else search dataset mappings for a suitable dna sequence, i.e. one
+ * whose whole sequence is mapped to the protein
+ * - if no sequence found, construct one from the dna sequence and mapping
+ * (and add it to dataset so it is found if this is repeated)
*/
- List<SequenceI> dsseqs = al.getDataset().getSequences();
- for (SequenceI seq : newAl.getSequences())
+ for (SequenceI dnaSeq : dna)
{
- if (!dsseqs.contains(seq.getDatasetSequence()))
+ SequenceI dnaDss = dnaSeq.getDatasetSequence() == null ? dnaSeq
+ : dnaSeq.getDatasetSequence();
+
+ List<AlignedCodonFrame> seqMappings = MappingUtils
+ .findMappingsForSequence(dnaSeq, mappings);
+ for (AlignedCodonFrame mapping : seqMappings)
{
- dsseqs.add(seq.getDatasetSequence());
+ List<Mapping> mappingsFromSequence = mapping
+ .getMappingsFromSequence(dnaSeq);
+
+ for (Mapping aMapping : mappingsFromSequence)
+ {
+ MapList mapList = aMapping.getMap();
+ if (mapList.getFromRatio() == 1)
+ {
+ /*
+ * not a dna-to-protein mapping (likely dna-to-cds)
+ */
+ continue;
+ }
+
+ /*
+ * skip if mapping is not to one of the target set of proteins
+ */
+ SequenceI proteinProduct = aMapping.getTo();
+ if (productSeqs != null && !productSeqs.contains(proteinProduct))
+ {
+ continue;
+ }
+
+ /*
+ * try to locate the CDS from the dataset mappings;
+ * guard against duplicate results (for the case that protein has
+ * dbrefs to both dna and cds sequences)
+ */
+ SequenceI cdsSeq = findCdsForProtein(mappings, dnaSeq,
+ seqMappings, aMapping);
+ if (cdsSeq != null)
+ {
+ if (!foundSeqs.contains(cdsSeq))
+ {
+ foundSeqs.add(cdsSeq);
+ SequenceI derivedSequence = cdsSeq.deriveSequence();
+ cdsSeqs.add(derivedSequence);
+ if (!dataset.getSequences().contains(cdsSeq))
+ {
+ dataset.addSequence(cdsSeq);
+ }
+ }
+ continue;
+ }
+
+ /*
+ * didn't find mapped CDS sequence - construct it and add
+ * its dataset sequence to the dataset
+ */
+ cdsSeq = makeCdsSequence(dnaSeq.getDatasetSequence(), aMapping,
+ dataset).deriveSequence();
+ // cdsSeq has a name constructed as CDS|<dbref>
+ // <dbref> will be either the accession for the coding sequence,
+ // marked in the /via/ dbref to the protein product accession
+ // or it will be the original nucleotide accession.
+ SequenceI cdsSeqDss = cdsSeq.getDatasetSequence();
+
+ cdsSeqs.add(cdsSeq);
+
+ if (!dataset.getSequences().contains(cdsSeqDss))
+ {
+ // check if this sequence is a newly created one
+ // so needs adding to the dataset
+ dataset.addSequence(cdsSeqDss);
+ }
+
+ /*
+ * add a mapping from CDS to the (unchanged) mapped to range
+ */
+ List<int[]> cdsRange = Collections.singletonList(new int[] { 1,
+ cdsSeq.getLength() });
+ MapList cdsToProteinMap = new MapList(cdsRange,
+ mapList.getToRanges(), mapList.getFromRatio(),
+ mapList.getToRatio());
+ AlignedCodonFrame cdsToProteinMapping = new AlignedCodonFrame();
+ cdsToProteinMapping.addMap(cdsSeqDss, proteinProduct,
+ cdsToProteinMap);
+
+ /*
+ * guard against duplicating the mapping if repeating this action
+ */
+ if (!mappings.contains(cdsToProteinMapping))
+ {
+ mappings.add(cdsToProteinMapping);
+ }
+
+ propagateDBRefsToCDS(cdsSeqDss, dnaSeq.getDatasetSequence(),
+ proteinProduct, aMapping);
+ /*
+ * add another mapping from original 'from' range to CDS
+ */
+ AlignedCodonFrame dnaToCdsMapping = new AlignedCodonFrame();
+ MapList dnaToCdsMap = new MapList(mapList.getFromRanges(),
+ cdsRange, 1, 1);
+ dnaToCdsMapping.addMap(dnaSeq.getDatasetSequence(), cdsSeqDss,
+ dnaToCdsMap);
+ if (!mappings.contains(dnaToCdsMapping))
+ {
+ mappings.add(dnaToCdsMapping);
+ }
+
+ /*
+ * add DBRef with mapping from protein to CDS
+ * (this enables Get Cross-References from protein alignment)
+ * This is tricky because we can't have two DBRefs with the
+ * same source and accession, so need a different accession for
+ * the CDS from the dna sequence
+ */
+
+ // specific use case:
+ // Genomic contig ENSCHR:1, contains coding regions for ENSG01,
+ // ENSG02, ENSG03, with transcripts and products similarly named.
+ // cannot add distinct dbrefs mapping location on ENSCHR:1 to ENSG01
+
+ // JBPNote: ?? can't actually create an example that demonstrates we
+ // need to
+ // synthesize an xref.
+
+ for (DBRefEntry primRef : dnaDss.getPrimaryDBRefs())
+ {
+ // creates a complementary cross-reference to the source sequence's
+ // primary reference.
+
+ DBRefEntry cdsCrossRef = new DBRefEntry(primRef.getSource(),
+ primRef.getSource() + ":" + primRef.getVersion(),
+ primRef.getAccessionId());
+ cdsCrossRef
+ .setMap(new Mapping(dnaDss, new MapList(dnaToCdsMap)));
+ cdsSeqDss.addDBRef(cdsCrossRef);
+
+ // problem here is that the cross-reference is synthesized -
+ // cdsSeq.getName() may be like 'CDS|dnaaccession' or
+ // 'CDS|emblcdsacc'
+ // assuming cds version same as dna ?!?
+
+ DBRefEntry proteinToCdsRef = new DBRefEntry(
+ primRef.getSource(), primRef.getVersion(),
+ cdsSeq.getName());
+ //
+ proteinToCdsRef.setMap(new Mapping(cdsSeqDss, cdsToProteinMap
+ .getInverse()));
+ proteinProduct.addDBRef(proteinToCdsRef);
+ }
+
+ /*
+ * transfer any features on dna that overlap the CDS
+ */
+ transferFeatures(dnaSeq, cdsSeq, dnaToCdsMap, null,
+ SequenceOntologyI.CDS);
+ }
}
}
- newAl.setDataset(al.getDataset());
- /*
- * Replace the old mappings with the new ones
- */
- mappings.clear();
- mappings.addAll(newMappings);
+ AlignmentI cds = new Alignment(cdsSeqs.toArray(new SequenceI[cdsSeqs
+ .size()]));
+ cds.setDataset(dataset);
- return newAl;
+ return cds;
}
/**
- * Returns a consolidated list of column ranges where at least one sequence
- * has a CDS feature. This assumes CDS features are on genomic sequence i.e.
- * are for contiguous CDS ranges (no gaps).
+ * A helper method that finds a CDS sequence in the alignment dataset that is
+ * mapped to the given protein sequence, and either is, or has a mapping from,
+ * the given dna sequence.
*
- * @param seqs
+ * @param mappings
+ * set of all mappings on the dataset
+ * @param dnaSeq
+ * a dna (or cds) sequence we are searching from
+ * @param seqMappings
+ * the set of mappings involving dnaSeq
+ * @param aMapping
+ * an initial candidate from seqMappings
* @return
*/
- public static List<int[]> findCdsColumns(SequenceI[] seqs)
+ static SequenceI findCdsForProtein(List<AlignedCodonFrame> mappings,
+ SequenceI dnaSeq, List<AlignedCodonFrame> seqMappings,
+ Mapping aMapping)
{
- // TODO use refactored code from AlignViewController
- // markColumnsContainingFeatures, not reinvent the wheel!
+ /*
+ * TODO a better dna-cds-protein mapping data representation to allow easy
+ * navigation; until then this clunky looping around lists of mappings
+ */
+ SequenceI seqDss = dnaSeq.getDatasetSequence() == null ? dnaSeq
+ : dnaSeq.getDatasetSequence();
+ SequenceI proteinProduct = aMapping.getTo();
- List<int[]> result = new ArrayList<int[]>();
- for (SequenceI seq : seqs)
+ /*
+ * is this mapping from the whole dna sequence (i.e. CDS)?
+ * allowing for possible stop codon on dna but not peptide
+ */
+ int mappedFromLength = MappingUtils.getLength(aMapping.getMap()
+ .getFromRanges());
+ int dnaLength = seqDss.getLength();
+ if (mappedFromLength == dnaLength
+ || mappedFromLength == dnaLength - CODON_LENGTH)
{
- result.addAll(findCdsColumns(seq));
+ return seqDss;
}
/*
- * sort and compact the list into ascending, non-overlapping ranges
+ * looks like we found the dna-to-protein mapping; search for the
+ * corresponding cds-to-protein mapping
*/
- Collections.sort(result, new Comparator<int[]>()
- {
- @Override
- public int compare(int[] o1, int[] o2)
- {
- return Integer.compare(o1[0], o2[0]);
- }
- });
- result = MapList.coalesceRanges(result);
-
- return result;
- }
-
- public static List<int[]> findCdsColumns(SequenceI seq)
- {
- List<int[]> result = new ArrayList<int[]>();
- SequenceOntologyI so = SequenceOntologyFactory.getInstance();
- SequenceFeature[] sfs = seq.getSequenceFeatures();
- if (sfs != null)
+ List<AlignedCodonFrame> mappingsToPeptide = MappingUtils
+ .findMappingsForSequence(proteinProduct, mappings);
+ for (AlignedCodonFrame acf : mappingsToPeptide)
{
- for (SequenceFeature sf : sfs)
+ for (SequenceToSequenceMapping map : acf.getMappings())
{
- if (so.isA(sf.getType(), SequenceOntologyI.CDS))
+ Mapping mapping = map.getMapping();
+ if (mapping != aMapping
+ && mapping.getMap().getFromRatio() == CODON_LENGTH
+ && proteinProduct == mapping.getTo()
+ && seqDss != map.getFromSeq())
{
- int colStart = seq.findIndex(sf.getBegin());
- int colEnd = seq.findIndex(sf.getEnd());
- result.add(new int[] { colStart, colEnd });
+ mappedFromLength = MappingUtils.getLength(mapping.getMap()
+ .getFromRanges());
+ if (mappedFromLength == map.getFromSeq().getLength())
+ {
+ /*
+ * found a 3:1 mapping to the protein product which covers
+ * the whole dna sequence i.e. is from CDS; finally check it
+ * is from the dna start sequence
+ */
+ SequenceI cdsSeq = map.getFromSeq();
+ List<AlignedCodonFrame> dnaToCdsMaps = MappingUtils
+ .findMappingsForSequence(cdsSeq, seqMappings);
+ if (!dnaToCdsMaps.isEmpty())
+ {
+ return cdsSeq;
+ }
+ }
}
}
}
- return result;
+ return null;
}
/**
- * Answers true if all sequences have a gap at (or do not extend to) the
- * specified column position (base 1)
+ * Helper method that makes a CDS sequence as defined by the mappings from the
+ * given sequence i.e. extracts the 'mapped from' ranges (which may be on
+ * forward or reverse strand).
*
- * @param seqs
- * @param col
- * @return
+ * @param seq
+ * @param mapping
+ * @param dataset
+ * - existing dataset. We check for sequences that look like the CDS
+ * we are about to construct, if one exists already, then we will
+ * just return that one.
+ * @return CDS sequence (as a dataset sequence)
*/
- public static boolean isGappedColumn(List<SequenceI> seqs, int col)
+ static SequenceI makeCdsSequence(SequenceI seq, Mapping mapping,
+ AlignmentI dataset)
{
- if (seqs != null)
+ char[] seqChars = seq.getSequence();
+ List<int[]> fromRanges = mapping.getMap().getFromRanges();
+ int cdsWidth = MappingUtils.getLength(fromRanges);
+ char[] newSeqChars = new char[cdsWidth];
+
+ int newPos = 0;
+ for (int[] range : fromRanges)
{
- for (SequenceI seq : seqs)
+ if (range[0] <= range[1])
+ {
+ // forward strand mapping - just copy the range
+ int length = range[1] - range[0] + 1;
+ System.arraycopy(seqChars, range[0] - 1, newSeqChars, newPos,
+ length);
+ newPos += length;
+ }
+ else
{
- if (!Comparison.isGap(seq.getCharAt(col - 1)))
+ // reverse strand mapping - copy and complement one by one
+ for (int i = range[0]; i >= range[1]; i--)
{
- return false;
+ newSeqChars[newPos++] = Dna.getComplement(seqChars[i - 1]);
}
}
}
- return true;
- }
- /**
- * Returns the column ranges (base 1) of each aligned sequence that are
- * involved in any mapping. This is a helper method for aligning protein
- * products of aligned transcripts.
- *
- * @param mappedSequences
- * (possibly gapped) dna sequences
- * @param mappings
- * @return
- */
- protected static List<List<int[]>> getMappedColumns(
- List<SequenceI> mappedSequences, List<AlignedCodonFrame> mappings)
- {
- List<List<int[]>> result = new ArrayList<List<int[]>>();
- for (SequenceI seq : mappedSequences)
+ /*
+ * assign 'from id' held in the mapping if set (e.g. EMBL protein_id),
+ * else generate a sequence name
+ */
+ String mapFromId = mapping.getMappedFromId();
+ String seqId = "CDS|" + (mapFromId != null ? mapFromId : seq.getName());
+ SequenceI newSeq = new Sequence(seqId, newSeqChars, 1, newPos);
+ if (dataset != null)
{
- List<int[]> columns = new ArrayList<int[]>();
- List<AlignedCodonFrame> seqMappings = MappingUtils
- .findMappingsForSequence(seq, mappings);
- for (AlignedCodonFrame mapping : seqMappings)
+ SequenceI[] matches = dataset.findSequenceMatch(newSeq.getName());
+ if (matches != null)
{
- List<Mapping> maps = mapping.getMappingsForSequence(seq);
- for (Mapping map : maps)
+ boolean matched = false;
+ for (SequenceI mtch : matches)
{
- /*
- * Get the codon regions as { [2, 5], [7, 12], [14, 14] etc }
- * Find and add the overall aligned column range for each
- */
- for (int[] cdsRange : map.getMap().getFromRanges())
+ if (mtch.getStart() != newSeq.getStart())
+ {
+ continue;
+ }
+ if (mtch.getEnd() != newSeq.getEnd())
+ {
+ continue;
+ }
+ if (!Arrays.equals(mtch.getSequence(), newSeq.getSequence()))
{
- int startPos = cdsRange[0];
- int endPos = cdsRange[1];
- int startCol = seq.findIndex(startPos);
- int endCol = seq.findIndex(endPos);
- columns.add(new int[] { startCol, endCol });
+ continue;
+ }
+ if (!matched)
+ {
+ matched = true;
+ newSeq = mtch;
+ }
+ else
+ {
+ System.err
+ .println("JAL-2154 regression: warning - found (and ignnored a duplicate CDS sequence):"
+ + mtch.toString());
}
}
}
- result.add(columns);
}
- return result;
+ // newSeq.setDescription(mapFromId);
+
+ return newSeq;
}
/**
- * Helper method to make cds-only sequences and populate their mappings to
- * protein products
- * <p>
- * For example, if ggCCaTTcGAg has mappings [3, 4, 6, 7, 9, 10] to protein
- * then generate a sequence CCTTGA with mapping [1, 6] to the same protein
- * residues
- * <p>
- * Typically eukaryotic dna will include cds encoding for a single peptide
- * sequence i.e. return a single result. Bacterial dna may have overlapping
- * cds mappings coding for multiple peptides so return multiple results
- * (example EMBL KF591215).
+ * add any DBRefEntrys to cdsSeq from contig that have a Mapping congruent to
+ * the given mapping.
*
- * @param dnaSeq
- * a dna aligned sequence
+ * @param cdsSeq
+ * @param contig
* @param mapping
- * containing one or more mappings of the sequence to protein
- * @param ungappedCdsColumns
- * @param newMappings
- * the new mapping to populate, from the cds-only sequences to their
- * mapped protein sequences
- * @return
+ * @return list of DBRefEntrys added.
*/
- protected static List<SequenceI> makeCdsSequences(SequenceI dnaSeq,
- AlignedCodonFrame mapping, List<int[]> ungappedCdsColumns,
- AlignedCodonFrame newMappings, char gapChar)
+ public static List<DBRefEntry> propagateDBRefsToCDS(SequenceI cdsSeq,
+ SequenceI contig, SequenceI proteinProduct, Mapping mapping)
{
- List<SequenceI> cdsSequences = new ArrayList<SequenceI>();
- List<Mapping> seqMappings = mapping.getMappingsForSequence(dnaSeq);
- for (Mapping seqMapping : seqMappings)
+ // gather direct refs from contig congrent with mapping
+ List<DBRefEntry> direct = new ArrayList<DBRefEntry>();
+ HashSet<String> directSources = new HashSet<String>();
+ if (contig.getDBRefs() != null)
{
- SequenceI cds = makeCdsSequence(dnaSeq, seqMapping,
- ungappedCdsColumns, gapChar);
- cds.createDatasetSequence();
- cdsSequences.add(cds);
-
- /*
- * add new mappings, from dna to cds, and from cds to peptide
- */
- MapList dnaToCds = addCdsMappings(dnaSeq.getDatasetSequence(), cds,
- seqMapping, newMappings);
-
- /*
- * transfer any features on dna that overlap the CDS
- */
- transferFeatures(dnaSeq, cds, dnaToCds, null, SequenceOntologyI.CDS);
+ for (DBRefEntry dbr : contig.getDBRefs())
+ {
+ if (dbr.hasMap() && dbr.getMap().getMap().isTripletMap())
+ {
+ MapList map = dbr.getMap().getMap();
+ // check if map is the CDS mapping
+ if (mapping.getMap().equals(map))
+ {
+ direct.add(dbr);
+ directSources.add(dbr.getSource());
+ }
+ }
+ }
+ }
+ DBRefEntry[] onSource = DBRefUtils.selectRefs(
+ proteinProduct.getDBRefs(),
+ directSources.toArray(new String[0]));
+ List<DBRefEntry> propagated = new ArrayList<DBRefEntry>();
+
+ // and generate appropriate mappings
+ for (DBRefEntry cdsref : direct)
+ {
+ // clone maplist and mapping
+ MapList cdsposmap = new MapList(Arrays.asList(new int[][] { new int[]
+ { cdsSeq.getStart(), cdsSeq.getEnd() } }), cdsref.getMap().getMap()
+ .getToRanges(), 3, 1);
+ Mapping cdsmap = new Mapping(cdsref.getMap().getTo(), cdsref.getMap()
+ .getMap());
+
+ // create dbref
+ DBRefEntry newref = new DBRefEntry(cdsref.getSource(),
+ cdsref.getVersion(), cdsref.getAccessionId(), new Mapping(
+ cdsmap.getTo(), cdsposmap));
+
+ // and see if we can map to the protein product for this mapping.
+ // onSource is the filtered set of accessions on protein that we are
+ // tranferring, so we assume accession is the same.
+ if (cdsmap.getTo() == null && onSource != null)
+ {
+ List<DBRefEntry> sourceRefs = DBRefUtils.searchRefs(onSource,
+ cdsref.getAccessionId());
+ if (sourceRefs != null)
+ {
+ for (DBRefEntry srcref : sourceRefs)
+ {
+ if (srcref.getSource().equalsIgnoreCase(cdsref.getSource()))
+ {
+ // we have found a complementary dbref on the protein product, so
+ // update mapping's getTo
+ newref.getMap().setTo(proteinProduct);
+ }
+ }
+ }
+ }
+ cdsSeq.addDBRef(newref);
+ propagated.add(newref);
}
- return cdsSequences;
+ return propagated;
}
/**
}
/**
- * Creates and adds mappings
- * <ul>
- * <li>from cds to peptide</li>
- * <li>from dna to cds</li>
- * </ul>
- * and returns the dna-to-cds mapping
- *
- * @param dnaSeq
- * @param cdsSeq
- * @param dnaMapping
- * @param newMappings
- * @return
- */
- protected static MapList addCdsMappings(SequenceI dnaSeq,
- SequenceI cdsSeq, Mapping dnaMapping,
- AlignedCodonFrame newMappings)
- {
- cdsSeq.createDatasetSequence();
-
- /*
- * CDS to peptide is just a contiguous 3:1 mapping, with
- * the peptide ranges taken unchanged from the dna mapping
- */
- List<int[]> cdsRanges = new ArrayList<int[]>();
- SequenceI cdsDataset = cdsSeq.getDatasetSequence();
- cdsRanges.add(new int[] { 1, cdsDataset.getLength() });
- MapList cdsToPeptide = new MapList(cdsRanges, dnaMapping.getMap()
- .getToRanges(), 3, 1);
- newMappings.addMap(cdsDataset, dnaMapping.getTo(), cdsToPeptide);
-
- /*
- * dna 'from' ranges map 1:1 to the contiguous extracted CDS
- */
- MapList dnaToCds = new MapList(dnaMapping.getMap().getFromRanges(),
- cdsRanges, 1, 1);
- newMappings.addMap(dnaSeq, cdsDataset, dnaToCds);
- return dnaToCds;
- }
-
- /**
- * Makes and returns a CDS-only sequence, where the CDS regions are identified
- * as the 'from' ranges of the mapping on the dna.
- *
- * @param dnaSeq
- * nucleotide sequence
- * @param seqMapping
- * mappings from CDS regions of nucleotide
- * @param ungappedCdsColumns
- * @return
- */
- protected static SequenceI makeCdsSequence(SequenceI dnaSeq,
- Mapping seqMapping, List<int[]> ungappedCdsColumns, char gapChar)
- {
- int cdsWidth = MappingUtils.getLength(ungappedCdsColumns);
-
- /*
- * populate CDS columns with the aligned
- * column character if that column is mapped (which may be a gap
- * if an intron interrupts a codon), else with a gap
- */
- List<int[]> fromRanges = seqMapping.getMap().getFromRanges();
- char[] cdsChars = new char[cdsWidth];
- int pos = 0;
- for (int[] columns : ungappedCdsColumns)
- {
- for (int i = columns[0]; i <= columns[1]; i++)
- {
- char dnaChar = dnaSeq.getCharAt(i - 1);
- if (Comparison.isGap(dnaChar))
- {
- cdsChars[pos] = gapChar;
- }
- else
- {
- int seqPos = dnaSeq.findPosition(i - 1);
- if (MappingUtils.contains(fromRanges, seqPos))
- {
- cdsChars[pos] = dnaChar;
- }
- else
- {
- cdsChars[pos] = gapChar;
- }
- }
- pos++;
- }
- }
- SequenceI cdsSequence = new Sequence(dnaSeq.getName(),
- String.valueOf(cdsChars));
-
- transferDbRefs(seqMapping.getTo(), cdsSequence);
-
- return cdsSequence;
- }
-
- /**
- * Locate any xrefs to CDS databases on the protein product and attach to the
- * CDS sequence. Also add as a sub-token of the sequence name.
- *
- * @param from
- * @param to
- */
- protected static void transferDbRefs(SequenceI from, SequenceI to)
- {
- String cdsAccId = FeatureProperties.getCodingFeature(DBRefSource.EMBL);
- DBRefEntry[] cdsRefs = DBRefUtils.selectRefs(from.getDBRefs(),
- DBRefSource.CODINGDBS);
- if (cdsRefs != null)
- {
- for (DBRefEntry cdsRef : cdsRefs)
- {
- to.addDBRef(new DBRefEntry(cdsRef));
- cdsAccId = cdsRef.getAccessionId();
- }
- }
- if (!to.getName().contains(cdsAccId))
- {
- to.setName(to.getName() + "|" + cdsAccId);
- }
- }
-
- /**
* Returns a mapping from dna to protein by inspecting sequence features of
* type "CDS" on the dna.
*
{
List<int[]> ranges = findCdsPositions(dnaSeq);
int mappedDnaLength = MappingUtils.getLength(ranges);
-
+
int proteinLength = proteinSeq.getLength();
int proteinStart = proteinSeq.getStart();
int proteinEnd = proteinSeq.getEnd();
-
+
/*
* incomplete start codon may mean X at start of peptide
* we ignore both for mapping purposes
proteinLength--;
}
List<int[]> proteinRange = new ArrayList<int[]>();
-
+
/*
* dna length should map to protein (or protein plus stop codon)
*/
- int codesForResidues = mappedDnaLength / 3;
+ int codesForResidues = mappedDnaLength / CODON_LENGTH;
if (codesForResidues == (proteinLength + 1))
{
// assuming extra codon is for STOP and not in peptide
if (codesForResidues == proteinLength)
{
proteinRange.add(new int[] { proteinStart, proteinEnd });
- return new MapList(ranges, proteinRange, 3, 1);
+ return new MapList(ranges, proteinRange, CODON_LENGTH, 1);
}
return null;
}
/**
* Returns a list of CDS ranges found (as sequence positions base 1), i.e. of
* start/end positions of sequence features of type "CDS" (or a sub-type of
- * CDS in the Sequence Ontology)
+ * CDS in the Sequence Ontology). The ranges are sorted into ascending start
+ * position order, so this method is only valid for linear CDS in the same
+ * sense as the protein product.
*
* @param dnaSeq
* @return
{
return result;
}
+
SequenceOntologyI so = SequenceOntologyFactory.getInstance();
+ int startPhase = 0;
+
for (SequenceFeature sf : sfs)
{
/*
if (so.isA(sf.getType(), SequenceOntologyI.CDS))
{
int phase = 0;
- try {
+ try
+ {
phase = Integer.parseInt(sf.getPhase());
} catch (NumberFormatException e)
{
int end = sf.getEnd();
if (result.isEmpty())
{
- // TODO JAL-2022 support start phase > 0
begin += phase;
if (begin > end)
{
- continue; // shouldn't happen?
+ // shouldn't happen!
+ System.err
+ .println("Error: start phase extends beyond start CDS in "
+ + dnaSeq.getName());
}
}
result.add(new int[] { begin, end });
}
}
+
+ /*
+ * remove 'startPhase' positions (usually 0) from the first range
+ * so we begin at the start of a complete codon
+ */
+ if (!result.isEmpty())
+ {
+ // TODO JAL-2022 correctly model start phase > 0
+ result.get(0)[0] += startPhase;
+ }
+
+ /*
+ * Finally sort ranges by start position. This avoids a dependency on
+ * keeping features in order on the sequence (if they are in order anyway,
+ * the sort will have almost no work to do). The implicit assumption is CDS
+ * ranges are assembled in order. Other cases should not use this method,
+ * but instead construct an explicit mapping for CDS (e.g. EMBL parsing).
+ */
+ Collections.sort(result, new Comparator<int[]>()
+ {
+ @Override
+ public int compare(int[] o1, int[] o2)
+ {
+ return Integer.compare(o1[0], o2[0]);
+ }
+ });
return result;
}
{
peptide = peptide.getDatasetSequence();
}
-
- transferFeatures(dnaSeq, peptide, dnaToProtein,
- SequenceOntologyI.EXON);
-
- LinkedHashMap<Integer, String[][]> variants = buildDnaVariantsMap(
+
+ transferFeatures(dnaSeq, peptide, dnaToProtein, SequenceOntologyI.EXON);
+
+ /*
+ * compute protein variants from dna variants and codon mappings;
+ * NB - alternatively we could retrieve this using the REST service e.g.
+ * http://rest.ensembl.org/overlap/translation
+ * /ENSP00000288602?feature=transcript_variation;content-type=text/xml
+ * which would be a bit slower but possibly more reliable
+ */
+
+ /*
+ * build a map with codon variations for each potentially varying peptide
+ */
+ LinkedHashMap<Integer, List<DnaVariant>[]> variants = buildDnaVariantsMap(
dnaSeq, dnaToProtein);
-
+
/*
* scan codon variations, compute peptide variants and add to peptide sequence
*/
int count = 0;
- for (Entry<Integer, String[][]> variant : variants.entrySet())
+ for (Entry<Integer, List<DnaVariant>[]> variant : variants.entrySet())
{
int peptidePos = variant.getKey();
- String[][] codonVariants = variant.getValue();
- String residue = String.valueOf(peptide.getCharAt(peptidePos - 1)); // 0-based
- List<String> peptideVariants = computePeptideVariants(codonVariants,
- residue);
- if (!peptideVariants.isEmpty())
- {
- String desc = StringUtils.listToDelimitedString(peptideVariants,
- ", ");
- SequenceFeature sf = new SequenceFeature(
- SequenceOntologyI.SEQUENCE_VARIANT, desc, peptidePos,
- peptidePos, 0f, null);
- peptide.addSequenceFeature(sf);
- count++;
- }
- }
-
+ List<DnaVariant>[] codonVariants = variant.getValue();
+ count += computePeptideVariants(peptide, peptidePos, codonVariants);
+ }
+
/*
- * ugly sort to get sequence features in start position order
- * - would be better to store in Sequence as a TreeSet instead?
+ * sort to get sequence features in start position order
+ * - would be better to store in Sequence as a TreeSet or NCList?
*/
- Arrays.sort(peptide.getSequenceFeatures(),
- new Comparator<SequenceFeature>()
- {
- @Override
- public int compare(SequenceFeature o1, SequenceFeature o2)
+ if (peptide.getSequenceFeatures() != null)
+ {
+ Arrays.sort(peptide.getSequenceFeatures(),
+ new Comparator<SequenceFeature>()
{
- int c = Integer.compare(o1.getBegin(), o2.getBegin());
- return c == 0 ? Integer.compare(o1.getEnd(), o2.getEnd())
- : c;
- }
- });
+ @Override
+ public int compare(SequenceFeature o1, SequenceFeature o2)
+ {
+ int c = Integer.compare(o1.getBegin(), o2.getBegin());
+ return c == 0 ? Integer.compare(o1.getEnd(), o2.getEnd())
+ : c;
+ }
+ });
+ }
return count;
}
/**
- * Builds a map whose key is position in the protein sequence, and value is an
- * array of all variants for the coding codon positions
+ * Computes non-synonymous peptide variants from codon variants and adds them
+ * as sequence_variant features on the protein sequence (one feature per
+ * allele variant). Selected attributes (variant id, clinical significance)
+ * are copied over to the new features.
+ *
+ * @param peptide
+ * the protein sequence
+ * @param peptidePos
+ * the position to compute peptide variants for
+ * @param codonVariants
+ * a list of dna variants per codon position
+ * @return the number of features added
+ */
+ static int computePeptideVariants(SequenceI peptide, int peptidePos,
+ List<DnaVariant>[] codonVariants)
+ {
+ String residue = String.valueOf(peptide.getCharAt(peptidePos - 1));
+ int count = 0;
+ String base1 = codonVariants[0].get(0).base;
+ String base2 = codonVariants[1].get(0).base;
+ String base3 = codonVariants[2].get(0).base;
+
+ /*
+ * variants in first codon base
+ */
+ for (DnaVariant var : codonVariants[0])
+ {
+ if (var.variant != null)
+ {
+ String alleles = (String) var.variant.getValue("alleles");
+ if (alleles != null)
+ {
+ for (String base : alleles.split(","))
+ {
+ String codon = base + base2 + base3;
+ if (addPeptideVariant(peptide, peptidePos, residue, var, codon))
+ {
+ count++;
+ }
+ }
+ }
+ }
+ }
+
+ /*
+ * variants in second codon base
+ */
+ for (DnaVariant var : codonVariants[1])
+ {
+ if (var.variant != null)
+ {
+ String alleles = (String) var.variant.getValue("alleles");
+ if (alleles != null)
+ {
+ for (String base : alleles.split(","))
+ {
+ String codon = base1 + base + base3;
+ if (addPeptideVariant(peptide, peptidePos, residue, var, codon))
+ {
+ count++;
+ }
+ }
+ }
+ }
+ }
+
+ /*
+ * variants in third codon base
+ */
+ for (DnaVariant var : codonVariants[2])
+ {
+ if (var.variant != null)
+ {
+ String alleles = (String) var.variant.getValue("alleles");
+ if (alleles != null)
+ {
+ for (String base : alleles.split(","))
+ {
+ String codon = base1 + base2 + base;
+ if (addPeptideVariant(peptide, peptidePos, residue, var, codon))
+ {
+ count++;
+ }
+ }
+ }
+ }
+ }
+
+ return count;
+ }
+
+ /**
+ * Helper method that adds a peptide variant feature, provided the given codon
+ * translates to a value different to the current residue (is a non-synonymous
+ * variant). ID and clinical_significance attributes of the dna variant (if
+ * present) are copied to the new feature.
+ *
+ * @param peptide
+ * @param peptidePos
+ * @param residue
+ * @param var
+ * @param codon
+ * @return true if a feature was added, else false
+ */
+ static boolean addPeptideVariant(SequenceI peptide, int peptidePos,
+ String residue, DnaVariant var, String codon)
+ {
+ /*
+ * get peptide translation of codon e.g. GAT -> D
+ * note that variants which are not single alleles,
+ * e.g. multibase variants or HGMD_MUTATION etc
+ * are currently ignored here
+ */
+ String trans = codon.contains("-") ? "-"
+ : (codon.length() > CODON_LENGTH ? null : ResidueProperties
+ .codonTranslate(codon));
+ if (trans != null && !trans.equals(residue))
+ {
+ String residue3Char = StringUtils
+ .toSentenceCase(ResidueProperties.aa2Triplet.get(residue));
+ String trans3Char = StringUtils
+ .toSentenceCase(ResidueProperties.aa2Triplet.get(trans));
+ String desc = "p." + residue3Char + peptidePos + trans3Char;
+ // set score to 0f so 'graduated colour' option is offered! JAL-2060
+ SequenceFeature sf = new SequenceFeature(
+ SequenceOntologyI.SEQUENCE_VARIANT, desc, peptidePos,
+ peptidePos, 0f, var.getSource());
+ StringBuilder attributes = new StringBuilder(32);
+ String id = (String) var.variant.getValue(ID);
+ if (id != null)
+ {
+ if (id.startsWith(SEQUENCE_VARIANT))
+ {
+ id = id.substring(SEQUENCE_VARIANT.length());
+ }
+ sf.setValue(ID, id);
+ attributes.append(ID).append("=").append(id);
+ // TODO handle other species variants JAL-2064
+ StringBuilder link = new StringBuilder(32);
+ try
+ {
+ link.append(desc)
+ .append(" ")
+ .append(id)
+ .append("|http://www.ensembl.org/Homo_sapiens/Variation/Summary?v=")
+ .append(URLEncoder.encode(id, "UTF-8"));
+ sf.addLink(link.toString());
+ } catch (UnsupportedEncodingException e)
+ {
+ // as if
+ }
+ }
+ String clinSig = (String) var.variant.getValue(CLINICAL_SIGNIFICANCE);
+ if (clinSig != null)
+ {
+ sf.setValue(CLINICAL_SIGNIFICANCE, clinSig);
+ attributes.append(";").append(CLINICAL_SIGNIFICANCE).append("=")
+ .append(clinSig);
+ }
+ peptide.addSequenceFeature(sf);
+ if (attributes.length() > 0)
+ {
+ sf.setAttributes(attributes.toString());
+ }
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Builds a map whose key is position in the protein sequence, and value is a
+ * list of the base and all variants for each corresponding codon position
*
* @param dnaSeq
* @param dnaToProtein
* @return
*/
- static LinkedHashMap<Integer, String[][]> buildDnaVariantsMap(
+ @SuppressWarnings("unchecked")
+ static LinkedHashMap<Integer, List<DnaVariant>[]> buildDnaVariantsMap(
SequenceI dnaSeq, MapList dnaToProtein)
{
/*
- * map from peptide position to all variant features of the codon for it
- * LinkedHashMap ensures we add the peptide features in sequence order
+ * map from peptide position to all variants of the codon which codes for it
+ * LinkedHashMap ensures we keep the peptide features in sequence order
*/
- LinkedHashMap<Integer, String[][]> variants = new LinkedHashMap<Integer, String[][]>();
+ LinkedHashMap<Integer, List<DnaVariant>[]> variants = new LinkedHashMap<Integer, List<DnaVariant>[]>();
SequenceOntologyI so = SequenceOntologyFactory.getInstance();
-
+
SequenceFeature[] dnaFeatures = dnaSeq.getSequenceFeatures();
if (dnaFeatures == null)
{
return variants;
}
-
+
int dnaStart = dnaSeq.getStart();
int[] lastCodon = null;
int lastPeptidePostion = 0;
-
+
/*
* build a map of codon variations for peptides
*/
continue;
}
int peptidePosition = mapsTo[0];
- String[][] codonVariants = variants.get(peptidePosition);
+ List<DnaVariant>[] codonVariants = variants.get(peptidePosition);
if (codonVariants == null)
{
- codonVariants = new String[3][];
+ codonVariants = new ArrayList[CODON_LENGTH];
+ codonVariants[0] = new ArrayList<DnaVariant>();
+ codonVariants[1] = new ArrayList<DnaVariant>();
+ codonVariants[2] = new ArrayList<DnaVariant>();
variants.put(peptidePosition, codonVariants);
}
-
+
/*
* extract dna variants to a string array
*/
{
alleles[i++] = allele.trim(); // lose any space characters "A, G"
}
-
+
/*
* get this peptide's codon positions e.g. [3, 4, 5] or [4, 7, 10]
*/
peptidePosition, peptidePosition));
lastPeptidePostion = peptidePosition;
lastCodon = codon;
-
+
/*
- * save nucleotide (and this variant) for each codon position
+ * save nucleotide (and any variant) for each codon position
*/
- for (int codonPos = 0; codonPos < 3; codonPos++)
+ for (int codonPos = 0; codonPos < CODON_LENGTH; codonPos++)
{
String nucleotide = String.valueOf(
dnaSeq.getCharAt(codon[codonPos] - dnaStart))
.toUpperCase();
- if (codonVariants[codonPos] == null)
+ List<DnaVariant> codonVariant = codonVariants[codonPos];
+ if (codon[codonPos] == dnaCol)
{
- /*
- * record current dna base
- */
- codonVariants[codonPos] = new String[] { nucleotide };
+ if (!codonVariant.isEmpty()
+ && codonVariant.get(0).variant == null)
+ {
+ /*
+ * already recorded base value, add this variant
+ */
+ codonVariant.get(0).variant = sf;
+ }
+ else
+ {
+ /*
+ * add variant with base value
+ */
+ codonVariant.add(new DnaVariant(nucleotide, sf));
+ }
}
- if (codon[codonPos] == dnaCol)
+ else if (codonVariant.isEmpty())
{
/*
- * add alleles to dna base (and any previously found alleles)
+ * record (possibly non-varying) base value
*/
- String[] known = codonVariants[codonPos];
- String[] dnaVariants = new String[alleles.length + known.length];
- System.arraycopy(known, 0, dnaVariants, 0, known.length);
- System.arraycopy(alleles, 0, dnaVariants, known.length,
- alleles.length);
- codonVariants[codonPos] = dnaVariants;
+ codonVariant.add(new DnaVariant(nucleotide));
}
}
}
}
/**
- * Returns a sorted, non-redundant list of all peptide translations generated
- * by the given dna variants, excluding the current residue value
+ * Makes an alignment with a copy of the given sequences, adding in any
+ * non-redundant sequences which are mapped to by the cross-referenced
+ * sequences.
*
- * @param codonVariants
- * an array of base values (acgtACGT) for codon positions 1, 2, 3
- * @param residue
- * the current residue translation
+ * @param seqs
+ * @param xrefs
+ * @param dataset
+ * the alignment dataset shared by the new copy
* @return
*/
- static List<String> computePeptideVariants(
- String[][] codonVariants, String residue)
+ public static AlignmentI makeCopyAlignment(SequenceI[] seqs,
+ SequenceI[] xrefs, AlignmentI dataset)
{
- List<String> result = new ArrayList<String>();
- for (String base1 : codonVariants[0])
+ AlignmentI copy = new Alignment(new Alignment(seqs));
+ copy.setDataset(dataset);
+ boolean isProtein = !copy.isNucleotide();
+ SequenceIdMatcher matcher = new SequenceIdMatcher(seqs);
+ if (xrefs != null)
{
- for (String base2 : codonVariants[1])
+ for (SequenceI xref : xrefs)
{
- for (String base3 : codonVariants[2])
+ DBRefEntry[] dbrefs = xref.getDBRefs();
+ if (dbrefs != null)
{
- String codon = base1 + base2 + base3;
- /*
- * get peptide translation of codon e.g. GAT -> D
- * note that variants which are not single alleles,
- * e.g. multibase variants or HGMD_MUTATION etc
- * are ignored here
- */
- String peptide = codon.contains("-") ? "-"
- : (codon.length() > 3 ? null : ResidueProperties
- .codonTranslate(codon));
- if (peptide != null && !result.contains(peptide)
- && !peptide.equalsIgnoreCase(residue))
+ for (DBRefEntry dbref : dbrefs)
{
- result.add(peptide);
+ if (dbref.getMap() == null || dbref.getMap().getTo() == null
+ || dbref.getMap().getTo().isProtein() != isProtein)
+ {
+ continue;
+ }
+ SequenceI mappedTo = dbref.getMap().getTo();
+ SequenceI match = matcher.findIdMatch(mappedTo);
+ if (match == null)
+ {
+ matcher.add(mappedTo);
+ copy.addSequence(mappedTo);
+ }
}
}
}
}
-
+ return copy;
+ }
+
+ /**
+ * Try to align sequences in 'unaligned' to match the alignment of their
+ * mapped regions in 'aligned'. For example, could use this to align CDS
+ * sequences which are mapped to their parent cDNA sequences.
+ *
+ * This method handles 1:1 mappings (dna-to-dna or protein-to-protein). For
+ * dna-to-protein or protein-to-dna use alternative methods.
+ *
+ * @param unaligned
+ * sequences to be aligned
+ * @param aligned
+ * holds aligned sequences and their mappings
+ * @return
+ */
+ public static int alignAs(AlignmentI unaligned, AlignmentI aligned)
+ {
+ /*
+ * easy case - aligning a copy of aligned sequences
+ */
+ if (alignAsSameSequences(unaligned, aligned))
+ {
+ return unaligned.getHeight();
+ }
+
/*
- * sort alphabetically with STOP at the end
+ * fancy case - aligning via mappings between sequences
*/
- Collections.sort(result, new Comparator<String>()
+ List<SequenceI> unmapped = new ArrayList<SequenceI>();
+ Map<Integer, Map<SequenceI, Character>> columnMap = buildMappedColumnsMap(
+ unaligned, aligned, unmapped);
+ int width = columnMap.size();
+ char gap = unaligned.getGapCharacter();
+ int realignedCount = 0;
+ // TODO: verify this loop scales sensibly for very wide/high alignments
+
+ for (SequenceI seq : unaligned.getSequences())
{
-
- @Override
- public int compare(String o1, String o2)
+ if (!unmapped.contains(seq))
{
- if ("STOP".equals(o1))
+ char[] newSeq = new char[width];
+ Arrays.fill(newSeq, gap); // JBPComment - doubt this is faster than the
+ // Integer iteration below
+ int newCol = 0;
+ int lastCol = 0;
+
+ /*
+ * traverse the map to find columns populated
+ * by our sequence
+ */
+ for (Integer column : columnMap.keySet())
{
- return 1;
+ Character c = columnMap.get(column).get(seq);
+ if (c != null)
+ {
+ /*
+ * sequence has a character at this position
+ *
+ */
+ newSeq[newCol] = c;
+ lastCol = newCol;
+ }
+ newCol++;
}
- else if ("STOP".equals(o2))
+
+ /*
+ * trim trailing gaps
+ */
+ if (lastCol < width)
{
- return -1;
+ char[] tmp = new char[lastCol + 1];
+ System.arraycopy(newSeq, 0, tmp, 0, lastCol + 1);
+ newSeq = tmp;
}
- else
+ // TODO: optimise SequenceI to avoid char[]->String->char[]
+ seq.setSequence(String.valueOf(newSeq));
+ realignedCount++;
+ }
+ }
+ return realignedCount;
+ }
+
+ /**
+ * If unaligned and aligned sequences share the same dataset sequences, then
+ * simply copies the aligned sequences to the unaligned sequences and returns
+ * true; else returns false
+ *
+ * @param unaligned
+ * - sequences to be aligned based on aligned
+ * @param aligned
+ * - 'guide' alignment containing sequences derived from same dataset
+ * as unaligned
+ * @return
+ */
+ static boolean alignAsSameSequences(AlignmentI unaligned,
+ AlignmentI aligned)
+ {
+ if (aligned.getDataset() == null || unaligned.getDataset() == null)
+ {
+ return false; // should only pass alignments with datasets here
+ }
+
+ // map from dataset sequence to alignment sequence(s)
+ Map<SequenceI, List<SequenceI>> alignedDatasets = new HashMap<SequenceI, List<SequenceI>>();
+ for (SequenceI seq : aligned.getSequences())
+ {
+ SequenceI ds = seq.getDatasetSequence();
+ if (alignedDatasets.get(ds) == null)
+ {
+ alignedDatasets.put(ds, new ArrayList<SequenceI>());
+ }
+ alignedDatasets.get(ds).add(seq);
+ }
+
+ /*
+ * first pass - check whether all sequences to be aligned share a dataset
+ * sequence with an aligned sequence
+ */
+ for (SequenceI seq : unaligned.getSequences())
+ {
+ if (!alignedDatasets.containsKey(seq.getDatasetSequence()))
+ {
+ return false;
+ }
+ }
+
+ /*
+ * second pass - copy aligned sequences;
+ * heuristic rule: pair off sequences in order for the case where
+ * more than one shares the same dataset sequence
+ */
+ for (SequenceI seq : unaligned.getSequences())
+ {
+ List<SequenceI> alignedSequences = alignedDatasets.get(seq
+ .getDatasetSequence());
+ // TODO: getSequenceAsString() will be deprecated in the future
+ // TODO: need to leave to SequenceI implementor to update gaps
+ seq.setSequence(alignedSequences.get(0).getSequenceAsString());
+ if (alignedSequences.size() > 0)
+ {
+ // pop off aligned sequences (except the last one)
+ alignedSequences.remove(0);
+ }
+ }
+
+ return true;
+ }
+
+ /**
+ * Returns a map whose key is alignment column number (base 1), and whose
+ * values are a map of sequence characters in that column.
+ *
+ * @param unaligned
+ * @param aligned
+ * @param unmapped
+ * @return
+ */
+ static Map<Integer, Map<SequenceI, Character>> buildMappedColumnsMap(
+ AlignmentI unaligned, AlignmentI aligned, List<SequenceI> unmapped)
+ {
+ /*
+ * Map will hold, for each aligned column position, a map of
+ * {unalignedSequence, characterPerSequence} at that position.
+ * TreeMap keeps the entries in ascending column order.
+ */
+ Map<Integer, Map<SequenceI, Character>> map = new TreeMap<Integer, Map<SequenceI, Character>>();
+
+ /*
+ * record any sequences that have no mapping so can't be realigned
+ */
+ unmapped.addAll(unaligned.getSequences());
+
+ List<AlignedCodonFrame> mappings = aligned.getCodonFrames();
+
+ for (SequenceI seq : unaligned.getSequences())
+ {
+ for (AlignedCodonFrame mapping : mappings)
+ {
+ SequenceI fromSeq = mapping.findAlignedSequence(seq, aligned);
+ if (fromSeq != null)
{
- return o1.compareTo(o2);
+ Mapping seqMap = mapping.getMappingBetween(fromSeq, seq);
+ if (addMappedPositions(seq, fromSeq, seqMap, map))
+ {
+ unmapped.remove(seq);
+ }
}
}
- });
- return result;
+ }
+ return map;
+ }
+
+ /**
+ * Helper method that adds to a map the mapped column positions of a sequence. <br>
+ * For example if aaTT-Tg-gAAA is mapped to TTTAAA then the map should record
+ * that columns 3,4,6,10,11,12 map to characters T,T,T,A,A,A of the mapped to
+ * sequence.
+ *
+ * @param seq
+ * the sequence whose column positions we are recording
+ * @param fromSeq
+ * a sequence that is mapped to the first sequence
+ * @param seqMap
+ * the mapping from 'fromSeq' to 'seq'
+ * @param map
+ * a map to add the column positions (in fromSeq) of the mapped
+ * positions of seq
+ * @return
+ */
+ static boolean addMappedPositions(SequenceI seq, SequenceI fromSeq,
+ Mapping seqMap, Map<Integer, Map<SequenceI, Character>> map)
+ {
+ if (seqMap == null)
+ {
+ return false;
+ }
+
+ /*
+ * invert mapping if it is from unaligned to aligned sequence
+ */
+ if (seqMap.getTo() == fromSeq.getDatasetSequence())
+ {
+ seqMap = new Mapping(seq.getDatasetSequence(), seqMap.getMap()
+ .getInverse());
+ }
+
+ char[] fromChars = fromSeq.getSequence();
+ int toStart = seq.getStart();
+ char[] toChars = seq.getSequence();
+
+ /*
+ * traverse [start, end, start, end...] ranges in fromSeq
+ */
+ for (int[] fromRange : seqMap.getMap().getFromRanges())
+ {
+ for (int i = 0; i < fromRange.length - 1; i += 2)
+ {
+ boolean forward = fromRange[i + 1] >= fromRange[i];
+
+ /*
+ * find the range mapped to (sequence positions base 1)
+ */
+ int[] range = seqMap.locateMappedRange(fromRange[i],
+ fromRange[i + 1]);
+ if (range == null)
+ {
+ System.err.println("Error in mapping " + seqMap + " from "
+ + fromSeq.getName());
+ return false;
+ }
+ int fromCol = fromSeq.findIndex(fromRange[i]);
+ int mappedCharPos = range[0];
+
+ /*
+ * walk over the 'from' aligned sequence in forward or reverse
+ * direction; when a non-gap is found, record the column position
+ * of the next character of the mapped-to sequence; stop when all
+ * the characters of the range have been counted
+ */
+ while (mappedCharPos <= range[1] && fromCol <= fromChars.length
+ && fromCol >= 0)
+ {
+ if (!Comparison.isGap(fromChars[fromCol - 1]))
+ {
+ /*
+ * mapped from sequence has a character in this column
+ * record the column position for the mapped to character
+ */
+ Map<SequenceI, Character> seqsMap = map.get(fromCol);
+ if (seqsMap == null)
+ {
+ seqsMap = new HashMap<SequenceI, Character>();
+ map.put(fromCol, seqsMap);
+ }
+ seqsMap.put(seq, toChars[mappedCharPos - toStart]);
+ mappedCharPos++;
+ }
+ fromCol += (forward ? 1 : -1);
+ }
+ }
+ }
+ return true;
+ }
+
+ // strictly temporary hack until proper criteria for aligning protein to cds
+ // are in place; this is so Ensembl -> fetch xrefs Uniprot aligns the Uniprot
+ public static boolean looksLikeEnsembl(AlignmentI alignment)
+ {
+ for (SequenceI seq : alignment.getSequences())
+ {
+ String name = seq.getName();
+ if (!name.startsWith("ENSG") && !name.startsWith("ENST"))
+ {
+ return false;
+ }
+ }
+ return true;
}
}