@Override public int compareTo(final PileupElement pileupElement) { if (offset < pileupElement.offset) return -1; else if (offset > pileupElement.offset) return 1; else if (read.getAlignmentStart() < pileupElement.read.getAlignmentStart()) return -1; else if (read.getAlignmentStart() > pileupElement.read.getAlignmentStart()) return 1; else return 0; }
public int getAlignmentStart() { return (newStart != -1 ? newStart : read.getAlignmentStart()); }
public int getOriginalAlignmentStart() { return read.getAlignmentStart(); }
/** * Does read start at the same position as described by currentContextIndex and currentAlignmentStart? * * @param read the read we want to test * @param currentContigIndex the contig index (from the read's getReferenceIndex) of the reads in this state manager * @param currentAlignmentStart the alignment start of the of the left-most position on the * genome of the reads in this read state manager * @return true if read has contig index and start equal to the current ones */ private boolean readStartsAtCurrentPosition(final GATKSAMRecord read, final int currentContigIndex, final int currentAlignmentStart) { return read.getAlignmentStart() == currentAlignmentStart && read.getReferenceIndex() == currentContigIndex; }
/** * Is a base inside a read? * * @param read the read to evaluate * @param referenceCoordinate the reference coordinate of the base to test * @return true if it is inside the read, false otherwise. */ public static boolean isInsideRead(final GATKSAMRecord read, final int referenceCoordinate) { return referenceCoordinate >= read.getAlignmentStart() && referenceCoordinate <= read.getAlignmentEnd(); }
/** * Test that the reads are ordered by their alignment starts * @return true if well ordered, false otherwise */ private boolean readStartsAreWellOrdered() { int lastStart = -1; for ( final AlignmentStateMachine machine : readStatesByAlignmentStart ) { if ( lastStart > machine.getRead().getAlignmentStart() ) return false; lastStart = machine.getRead().getAlignmentStart(); } return true; }
private boolean useSoftClippedBases(GATKSAMRecord read, long eventStartPos, int eventLength) { return !((read.getAlignmentStart() >= eventStartPos-eventLength && read.getAlignmentStart() <= eventStartPos+1) || (read.getAlignmentEnd() >= eventStartPos && read.getAlignmentEnd() <= eventStartPos + eventLength)); }
private void verifySortednessOfReads( final List<GATKSAMRecord> reads) { int lastStart = -1; for ( GATKSAMRecord read : reads ) { Assert.assertTrue(lastStart <= read.getAlignmentStart(), "Reads should be sorted but weren't. Found read with start " + read.getAlignmentStart() + " while last was " + lastStart); lastStart = read.getAlignmentStart(); } } }
/** * Get the position (1-based as standard) of the current alignment on the genome w.r.t. the read's alignment start * @return the position on the genome of the current state in absolute coordinates */ @Ensures("result > 0") public int getGenomePosition() { return read.getAlignmentStart() + getGenomeOffset(); }
/** * Hard clip the read to the variable region (from refStart to refStop) * * @param read the read to be clipped * @param refStart the beginning of the variant region (inclusive) * @param refStop the end of the variant region (inclusive) * @return the read hard clipped to the variant region */ public static GATKSAMRecord hardClipToRegion( final GATKSAMRecord read, final int refStart, final int refStop ) { final int start = read.getAlignmentStart(); final int stop = read.getAlignmentEnd(); return hardClipToRegion(read, refStart, refStop,start,stop); }
@Override public int compare(PileupElement element1, PileupElement element2) { final int difference = element1.getRead().getAlignmentStart() - element2.getRead().getAlignmentStart(); return difference != 0 ? difference : element1.getRead().getReadName().compareTo(element2.getRead().getReadName()); } });
@Test(enabled = !DEBUG) public void testRevertEntirelySoftclippedReads() { GATKSAMRecord read = ReadClipperTestUtils.makeReadFromCigar("2H1S3H", 0); GATKSAMRecord clippedRead = ReadClipper.revertSoftClippedBases(read); Assert.assertEquals(clippedRead.getAlignmentStart(), read.getSoftStart()); }
private void AssertWellOrderedPileup(final ReadBackedPileup pileup) { if ( ! pileup.isEmpty() ) { int leftMostPos = -1; for ( final PileupElement pe : pileup ) { Assert.assertTrue(pileup.getLocation().getContig().equals(pe.getRead().getReferenceName()), "ReadBackedPileup contains an element " + pe + " that's on a different contig than the pileup itself"); Assert.assertTrue(pe.getRead().getAlignmentStart() >= leftMostPos, "ReadBackedPileup contains an element " + pe + " whose read's alignment start " + pe.getRead().getAlignmentStart() + " occurs before the leftmost position we've seen previously " + leftMostPos); } } }
@Test(enabled = !DEBUG) public void testHardClipByReferenceCoordinatesLeftTail() { for (Cigar cigar : cigarList) { GATKSAMRecord read = ReadClipperTestUtils.makeReadFromCigar(cigar, 0); int alnStart = read.getAlignmentStart(); int alnEnd = read.getAlignmentEnd(); if (read.getSoftStart() == alnStart) { // we can't test left clipping if the read has hanging soft clips on the left side for (int i = alnStart; i <= alnEnd; i++) { GATKSAMRecord clipLeft = ReadClipper.hardClipByReferenceCoordinatesLeftTail(read, i); if (!clipLeft.isEmpty()) { Assert.assertTrue(clipLeft.getAlignmentStart() >= i + 1, String.format("Clipped alignment start (%d) is less the expected (%d): %s -> %s", clipLeft.getAlignmentStart(), i + 1, read.getCigarString(), clipLeft.getCigarString())); assertUnclippedLimits(read, clipLeft); } } } } }
@Test( ) public void testCreationFromSAMRecordUnmappedButOnGenome() { final GATKSAMRecord read = ArtificialSAMUtils.createArtificialRead(header, "foo", 0, 1, 5); read.setReadUnmappedFlag(true); read.setCigarString("*"); final GenomeLoc loc = genomeLocParser.createGenomeLoc(read); Assert.assertEquals(loc.getContig(), read.getReferenceName()); Assert.assertEquals(loc.getContigIndex(), (int)read.getReferenceIndex()); Assert.assertEquals(loc.getStart(), read.getAlignmentStart()); Assert.assertEquals(loc.getStop(), read.getAlignmentStart()); }
@Test(enabled = !DEBUG) public void testHardClipBothEndsByReferenceCoordinates() { for (Cigar cigar : cigarList) { GATKSAMRecord read = ReadClipperTestUtils.makeReadFromCigar(cigar, 0); int alnStart = read.getAlignmentStart(); int alnEnd = read.getAlignmentEnd(); int readLength = alnStart - alnEnd; for (int i = 0; i < readLength / 2; i++) { GATKSAMRecord clippedRead = ReadClipper.hardClipBothEndsByReferenceCoordinates(read, alnStart + i, alnEnd - i); Assert.assertTrue(clippedRead.getAlignmentStart() >= alnStart + i, String.format("Clipped alignment start is less than original read (minus %d): %s -> %s", i, read.getCigarString(), clippedRead.getCigarString())); Assert.assertTrue(clippedRead.getAlignmentEnd() <= alnEnd + i, String.format("Clipped alignment end is greater than original read (minus %d): %s -> %s", i, read.getCigarString(), clippedRead.getCigarString())); assertUnclippedLimits(read, clippedRead); } } }
private boolean doNotTryToClean(GATKSAMRecord read) { return read.getReadUnmappedFlag() || read.getNotPrimaryAlignmentFlag() || read.getReadFailsVendorQualityCheckFlag() || read.getMappingQuality() == 0 || read.getAlignmentStart() == SAMRecord.NO_ALIGNMENT_START || ConstrainedMateFixingManager.iSizeTooBigToMove(read, MAX_ISIZE_FOR_MOVEMENT) || ReadUtils.is454Read(read) || ReadUtils.isIonRead(read); // TODO -- it would be nice if we could use indels from 454/Ion reads as alternate consenses }
@Test(dataProvider = "ComplexReadAlignedToRef", enabled = !DEBUG) public void testReadAlignedToRefComplexAlignment(final int testIndex, final GATKSAMRecord read, final String reference, final Haplotype haplotype, final int expectedMaxMismatches) throws Exception { final HaplotypeBAMWriter writer = new CalledHaplotypeBAMWriter(new MockDestination()); final GATKSAMRecord alignedRead = AlignmentUtils.createReadAlignedToRef(read, haplotype, new Haplotype(reference.getBytes(),true), 1, true); if ( alignedRead != null ) { final int mismatches = AlignmentUtils.getMismatchCount(alignedRead, reference.getBytes(), alignedRead.getAlignmentStart() - 1).numMismatches; Assert.assertTrue(mismatches <= expectedMaxMismatches, "Alignment of read to ref looks broken. Expected at most " + expectedMaxMismatches + " but saw " + mismatches + " for readBases " + new String(read.getReadBases()) + " with cigar " + read.getCigar() + " reference " + reference + " haplotype " + haplotype + " with cigar " + haplotype.getCigar() + " aligned read cigar " + alignedRead.getCigarString() + " @ " + alignedRead.getAlignmentStart()); } } }
@Test( ) public void testCreationFromSAMRecord() { final GATKSAMRecord read = ArtificialSAMUtils.createArtificialRead(header, "foo", 0, 1, 5); final GenomeLoc loc = genomeLocParser.createGenomeLoc(read); Assert.assertEquals(loc.getContig(), read.getReferenceName()); Assert.assertEquals(loc.getContigIndex(), (int)read.getReferenceIndex()); Assert.assertEquals(loc.getStart(), read.getAlignmentStart()); Assert.assertEquals(loc.getStop(), read.getAlignmentEnd()); }
@Test(enabled = !DEBUG) public void testHardClipByReferenceCoordinatesRightTail() { for (Cigar cigar : cigarList) { GATKSAMRecord read = ReadClipperTestUtils.makeReadFromCigar(cigar, 0); int alnStart = read.getAlignmentStart(); int alnEnd = read.getAlignmentEnd(); if (read.getSoftEnd() == alnEnd) { // we can't test right clipping if the read has hanging soft clips on the right side for (int i = alnStart; i <= alnEnd; i++) { GATKSAMRecord clipRight = ReadClipper.hardClipByReferenceCoordinatesRightTail(read, i); if (!clipRight.isEmpty() && clipRight.getAlignmentStart() <= clipRight.getAlignmentEnd()) { // alnStart > alnEnd if the entire read is a soft clip now. We can't test those. Assert.assertTrue(clipRight.getAlignmentEnd() <= i - 1, String.format("Clipped alignment end (%d) is greater than expected (%d): %s -> %s", clipRight.getAlignmentEnd(), i - 1, read.getCigarString(), clipRight.getCigarString())); assertUnclippedLimits(read, clipRight); } } } } }