private void updateTable(final int[] table, final int alleleIndex, final GATKSAMRecord read) { if (alleleIndex < 0 || (alleleIndex+1)*2 > table.length) return; final int offset = alleleIndex * 2; //Unstranded reads are not meaningful for this annotation, they can be found in the AD annotation if (!read.isStrandless()) { final boolean isFW = !read.getReadNegativeStrandFlag(); table[offset + (isFW ? 0 : 1)]++; } }
final byte[] inconsistency = (byte[]) attr; if (read.getReadNegativeStrandFlag()) { // Negative direction return inconsistency[inconsistency.length - offset - 1] == (byte) 0;
public void addAlignment(GATKSAMRecord read) { output.println("@" + read.getReadName()); if (read.getReadNegativeStrandFlag()) { output.println(ReadUtils.getBasesReverseComplement(read)); output.println("+"); output.println(ReadUtils.convertReadQualToString(invertQuals(read.getBaseQualities()))); } else { output.println(ReadUtils.convertReadBasesToString(read)); output.println("+"); output.println(ReadUtils.convertReadQualToString(read)); } }
private void splitPRALMintoForwardAndReverseReads(final PerReadAlleleLikelihoodMap originalPRALM, final PerReadAlleleLikelihoodMap forwardPRALM, final PerReadAlleleLikelihoodMap reversePRALM) { final Map<GATKSAMRecord, Map<Allele, Double>> origReadAlleleLikelihoodMap = originalPRALM.getLikelihoodReadMap(); for (final GATKSAMRecord read : origReadAlleleLikelihoodMap.keySet()) { if (read.isStrandless()) continue; for (final Map.Entry<Allele, Double> alleleLikelihoodMap : origReadAlleleLikelihoodMap.get(read).entrySet()) { final Allele allele = alleleLikelihoodMap.getKey(); final Double likelihood = alleleLikelihoodMap.getValue(); if (read.getReadNegativeStrandFlag()) reversePRALM.add(read, allele, likelihood); else forwardPRALM.add(read, allele, likelihood); } } } }
private static void updateTable(final int[] table, final Allele allele, final GATKSAMRecord read, final Allele ref, final List<Allele> allAlts) { final boolean matchesRef = allele.equals(ref, true); final boolean matchesAnyAlt = allAlts.contains(allele); if ( matchesRef || matchesAnyAlt ) { final int offset = matchesRef ? 0 : ARRAY_DIM; if ( read.isStrandless() ) { // a strandless read counts as observations on both strand, at 50% weight, with a minimum of 1 // (the 1 is to ensure that a strandless read always counts as an observation on both strands, even // if the read is only seen once, because it's a merged read or other) table[offset]++; table[offset + 1]++; } else { // a normal read with an actual strand final boolean isFW = !read.getReadNegativeStrandFlag(); table[offset + (isFW ? 0 : 1)]++; } } }
/** * is this base inside the adaptor of the read? * * There are two cases to treat here: * * 1) Read is in the negative strand => Adaptor boundary is on the left tail * 2) Read is in the positive strand => Adaptor boundary is on the right tail * * Note: We return false to all reads that are UNMAPPED or have an weird big insert size (probably due to mismapping or bigger event) * * @param read the read to test * @param basePos base position in REFERENCE coordinates (not read coordinates) * @return whether or not the base is in the adaptor */ public static boolean isBaseInsideAdaptor(final GATKSAMRecord read, long basePos) { final int adaptorBoundary = read.getAdaptorBoundary(); if (adaptorBoundary == CANNOT_COMPUTE_ADAPTOR_BOUNDARY || read.getInferredInsertSize() > DEFAULT_ADAPTOR_SIZE) return false; return read.getReadNegativeStrandFlag() ? basePos <= adaptorBoundary : basePos >= adaptorBoundary; }
} else { final boolean isFW = !read.getReadNegativeStrandFlag(); if (isFW) alleleStrandCounts.set(FORWARD, alleleStrandCounts.get(FORWARD)+1);
/** * Checks if a read contains adaptor sequences. If it does, hard clips them out. * * Note: To see how a read is checked for adaptor sequence see {@link ReadUtils::getAdaptorBoundary} * * @return a new read without adaptor sequence */ private GATKSAMRecord hardClipAdaptorSequence () { final int adaptorBoundary = ReadUtils.getAdaptorBoundary(read); if (adaptorBoundary == ReadUtils.CANNOT_COMPUTE_ADAPTOR_BOUNDARY || !ReadUtils.isInsideRead(read, adaptorBoundary)) return read; return read.getReadNegativeStrandFlag() ? hardClipByReferenceCoordinatesLeftTail(adaptorBoundary) : hardClipByReferenceCoordinatesRightTail(adaptorBoundary); } public static GATKSAMRecord hardClipAdaptorSequence (GATKSAMRecord read) {
/** * Convenence function that takes a read and the start / stop clipping positions based on the forward * strand, and returns start/stop values appropriate for the strand of the read. * * @param read * @param start * @param stop * @return */ private Pair<Integer, Integer> strandAwarePositions(GATKSAMRecord read, int start, int stop) { if (read.getReadNegativeStrandFlag()) return new Pair<Integer, Integer>(read.getReadLength() - stop - 1, read.getReadLength() - start - 1); else return new Pair<Integer, Integer>(start, stop); }
Pattern pattern = read.getReadNegativeStrandFlag() ? stc.revPat : stc.fwdPat; String bases = read.getReadString(); Matcher match = pattern.matcher(bases);
int baseIndex = read.getReadNegativeStrandFlag() ? readLen - i - 1 : i; byte qual = quals[baseIndex]; clipSum += (qTrimmingThreshold - qual); int start = read.getReadNegativeStrandFlag() ? 0 : clipPoint; int stop = read.getReadNegativeStrandFlag() ? clipPoint : readLen - 1;
@Test public void testStrandlessReads() { final byte [] bases = {'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A'}; final byte [] quals = {20 , 20 , 20 , 20 , 20 , 20 , 20 , 20 }; GATKSAMRecord read = ArtificialSAMUtils.createArtificialRead(bases, quals, "6M"); Assert.assertEquals(read.isStrandless(), false); read.setReadNegativeStrandFlag(false); Assert.assertEquals(read.isStrandless(), false); Assert.assertEquals(read.getReadNegativeStrandFlag(), false); read.setReadNegativeStrandFlag(true); Assert.assertEquals(read.isStrandless(), false); Assert.assertEquals(read.getReadNegativeStrandFlag(), true); read.setReadNegativeStrandFlag(true); read.setIsStrandless(true); Assert.assertEquals(read.isStrandless(), true); Assert.assertEquals(read.getReadNegativeStrandFlag(), false, "negative strand flag should return false even through its set for a strandless read"); }
continue; // read is non-informative or MQ0 if (a.getAlleleIfInformative().equals(refAllele, true) && el.getKey().getReadPairedFlag()) { if (el.getKey().getReadNegativeStrandFlag() == el.getKey().getFirstOfPairFlag()) REF_F2R1++; else if (el.getKey().getReadNegativeStrandFlag() == el.getKey().getFirstOfPairFlag()) ALT_F2R1++; else
final int index = ( read.getReadNegativeStrandFlag() ? readPos : readPos - 1 ); updateIndel(indel, index, mode, EventType.BASE_DELETION); break; final boolean forwardStrandRead = !read.getReadNegativeStrandFlag(); if( forwardStrandRead ) { updateIndel(indel, readPos - 1, mode, EventType.BASE_INSERTION);
final boolean negativeStrand = clippedRead.getReadNegativeStrandFlag(); byte[] bases = clippedRead.getReadBases(); if (negativeStrand)
if (read.getReadNegativeStrandFlag()) readBases = BaseUtils.simpleReverseComplement(read.getReadBases());
@Override public void recordValues(final GATKSAMRecord read, final ReadCovariates values) { // store the original bases and then write Ns over low quality ones final byte[] originalBases = read.getReadBases().clone(); final boolean negativeStrand = read.getReadNegativeStrandFlag(); byte[] bases = read.getReadBases(); if (negativeStrand) bases = BaseUtils.simpleReverseComplement(bases); // don't record reads with N's if (!BaseUtils.isAllRegularBases(bases)) return; for (int i = 0; i < bases.length; i++) { final Pair<byte[], Integer> res = findTandemRepeatUnits(bases, i); // to merge repeat unit and repeat length to get covariate value: final String repeatID = getCovariateValueFromUnitAndLength(res.first, res.second); final int key = keyForRepeat(repeatID); final int readOffset = (negativeStrand ? bases.length - i - 1 : i); values.addCovariate(key, key, key, readOffset); } // put the original bases back in read.setReadBases(originalBases); }
public ReadBackedPileupImpl getPositiveStrandPileup() { if (pileupElementTracker instanceof PerSamplePileupElementTracker) { PerSamplePileupElementTracker<PileupElement> tracker = (PerSamplePileupElementTracker<PileupElement>) pileupElementTracker; PerSamplePileupElementTracker<PileupElement> filteredTracker = new PerSamplePileupElementTracker<PileupElement>(); for (final String sample : tracker.getSamples()) { PileupElementTracker<PileupElement> perSampleElements = tracker.getElements(sample); ReadBackedPileupImpl pileup = createNewPileup(loc, perSampleElements).getPositiveStrandPileup(); filteredTracker.addElements(sample, pileup.pileupElementTracker); } return createNewPileup(loc, filteredTracker); } else { UnifiedPileupElementTracker<PileupElement> tracker = (UnifiedPileupElementTracker<PileupElement>) pileupElementTracker; UnifiedPileupElementTracker<PileupElement> filteredTracker = new UnifiedPileupElementTracker<PileupElement>(); for (PileupElement p : tracker) { if (!p.getRead().getReadNegativeStrandFlag()) { filteredTracker.add(p); } } return createNewPileup(loc, filteredTracker); } }
/** * Gets the pileup consisting of only reads on the negative strand. * * @return A read-backed pileup consisting only of reads on the negative strand. */ public ReadBackedPileupImpl getNegativeStrandPileup() { if (pileupElementTracker instanceof PerSamplePileupElementTracker) { PerSamplePileupElementTracker<PileupElement> tracker = (PerSamplePileupElementTracker<PileupElement>) pileupElementTracker; PerSamplePileupElementTracker<PileupElement> filteredTracker = new PerSamplePileupElementTracker<PileupElement>(); for (final String sample : tracker.getSamples()) { PileupElementTracker<PileupElement> perSampleElements = tracker.getElements(sample); ReadBackedPileupImpl pileup = createNewPileup(loc, perSampleElements).getNegativeStrandPileup(); filteredTracker.addElements(sample, pileup.pileupElementTracker); } return createNewPileup(loc, filteredTracker); } else { UnifiedPileupElementTracker<PileupElement> tracker = (UnifiedPileupElementTracker<PileupElement>) pileupElementTracker; UnifiedPileupElementTracker<PileupElement> filteredTracker = new UnifiedPileupElementTracker<PileupElement>(); for (PileupElement p : tracker) { if (p.getRead().getReadNegativeStrandFlag()) { filteredTracker.add(p); } } return createNewPileup(loc, filteredTracker); } }
final int increment; int cycle; if (read.getReadNegativeStrandFlag()) { cycle = readLength * readOrderFactor; increment = -1 * readOrderFactor; if (!read.getReadNegativeStrandFlag()) { // Forward direction int iii = 0; while (iii < readLength) {