private boolean isReadFromNormal(final GATKSAMRecord rec) { return normalSampleName != null && normalSampleName.equals(rec.getReadGroup().getSample()); }
public static Map<String, List<GATKSAMRecord>> splitReadsBySample( final SampleList samplesList, final Collection<GATKSAMRecord> reads ) { final Map<String, List<GATKSAMRecord>> returnMap = new HashMap<>(); final int sampleCount = samplesList.sampleCount(); for (int i = 0; i < sampleCount; i++) returnMap.put(samplesList.sampleAt(i), new ArrayList<GATKSAMRecord>()); for( final GATKSAMRecord read : reads ) returnMap.get(read.getReadGroup().getSample()).add(read); return returnMap; }
private void removeReadsFromAllSamplesExcept(final String targetSample, final ActiveRegion activeRegion) { final Set<GATKSAMRecord> readsToRemove = new LinkedHashSet<>(); for( final GATKSAMRecord rec : activeRegion.getReads() ) { if( !rec.getReadGroup().getSample().equals(targetSample) ) { readsToRemove.add(rec); } } activeRegion.removeAll( readsToRemove ); }
public Collection<String> getSamples() { if (pileupElementTracker instanceof PerSamplePileupElementTracker) { PerSamplePileupElementTracker<PileupElement> tracker = (PerSamplePileupElementTracker<PileupElement>) pileupElementTracker; return new HashSet<String>(tracker.getSamples()); } else { Collection<String> sampleNames = new HashSet<String>(); for (PileupElement p : this) { GATKSAMRecord read = p.getRead(); String sampleName = read.getReadGroup() != null ? read.getReadGroup().getSample() : null; sampleNames.add(sampleName); } return sampleNames; } }
public Integer map(ReferenceContext ref, GATKSAMRecord read, RefMetaDataTracker metaDataTracker) { if ( ! newSampleName.equals(read.getReadGroup().getSample()) ) { throw new IllegalStateException(String.format("Encountered read with the wrong sample name. Expected %s found %s", newSampleName, read.getReadGroup().getSample())); } return 1; }
@Override public Map<String, ReadBackedPileup> getPileupsForSamples(Collection<String> sampleNames) { Map<String, ReadBackedPileup> result = new HashMap<String, ReadBackedPileup>(); if (pileupElementTracker instanceof PerSamplePileupElementTracker) { PerSamplePileupElementTracker<PileupElement> tracker = (PerSamplePileupElementTracker<PileupElement>) pileupElementTracker; for (String sample : sampleNames) { PileupElementTracker<PileupElement> filteredElements = tracker.getElements(sample); if (filteredElements != null) result.put(sample, createNewPileup(loc, filteredElements)); } } else { Map<String, UnifiedPileupElementTracker<PileupElement>> trackerMap = new HashMap<String, UnifiedPileupElementTracker<PileupElement>>(); for (String sample : sampleNames) { // initialize pileups for each sample UnifiedPileupElementTracker<PileupElement> filteredTracker = new UnifiedPileupElementTracker<PileupElement>(); trackerMap.put(sample, filteredTracker); } for (PileupElement p : pileupElementTracker) { // go through all pileup elements only once and add them to the respective sample's pileup GATKSAMRecord read = p.getRead(); if (read.getReadGroup() != null) { String sample = read.getReadGroup().getSample(); UnifiedPileupElementTracker<PileupElement> tracker = trackerMap.get(sample); if (tracker != null) // we only add the pileup the requested samples. Completely ignore the rest tracker.add(p); } } for (Map.Entry<String, UnifiedPileupElementTracker<PileupElement>> entry : trackerMap.entrySet()) // create the ReadBackedPileup for each sample result.put(entry.getKey(), createNewPileup(loc, entry.getValue())); } return result; }
@Override public ReadBackedPileup getPileupForSamples(Collection<String> sampleNames) { if (pileupElementTracker instanceof PerSamplePileupElementTracker) { PerSamplePileupElementTracker<PileupElement> tracker = (PerSamplePileupElementTracker<PileupElement>) pileupElementTracker; PileupElementTracker<PileupElement> filteredElements = tracker.getElements(sampleNames); return filteredElements != null ? createNewPileup(loc, filteredElements) : null; } else { HashSet<String> hashSampleNames = new HashSet<String>(sampleNames); // to speed up the "contains" access in the for loop UnifiedPileupElementTracker<PileupElement> filteredTracker = new UnifiedPileupElementTracker<PileupElement>(); for (PileupElement p : pileupElementTracker) { GATKSAMRecord read = p.getRead(); if (sampleNames != null) { // still checking on sampleNames because hashSampleNames will never be null. And empty means something else. if (read.getReadGroup() != null && hashSampleNames.contains(read.getReadGroup().getSample())) filteredTracker.add(p); } else { if (read.getReadGroup() == null || read.getReadGroup().getSample() == null) filteredTracker.add(p); } } return filteredTracker.size() > 0 ? createNewPileup(loc, filteredTracker) : null; } }
@Override public ReadBackedPileup getPileupForSample(String sampleName) { if (pileupElementTracker instanceof PerSamplePileupElementTracker) { PerSamplePileupElementTracker<PileupElement> tracker = (PerSamplePileupElementTracker<PileupElement>) pileupElementTracker; PileupElementTracker<PileupElement> filteredElements = tracker.getElements(sampleName); return filteredElements != null ? createNewPileup(loc, filteredElements) : null; } else { UnifiedPileupElementTracker<PileupElement> filteredTracker = new UnifiedPileupElementTracker<PileupElement>(); for (PileupElement p : pileupElementTracker) { GATKSAMRecord read = p.getRead(); if (sampleName != null) { if (read.getReadGroup() != null && sampleName.equals(read.getReadGroup().getSample())) filteredTracker.add(p); } else { if (read.getReadGroup() == null || read.getReadGroup().getSample() == null) filteredTracker.add(p); } } return filteredTracker.size() > 0 ? createNewPileup(loc, filteredTracker) : null; } }
/** * Add the given read to the sequence graph. Ultimately the read will get sent through addSequence(), but first * this method ensures we only use high quality bases and accounts for reduced reads, etc. * * @param read a non-null read */ protected void addRead(final GATKSAMRecord read) { final byte[] sequence = read.getReadBases(); final byte[] qualities = read.getBaseQualities(); int lastGood = -1; // the index of the last good base we've seen for( int end = 0; end <= sequence.length; end++ ) { if ( end == sequence.length || ! baseIsUsableForAssembly(sequence[end], qualities[end]) ) { // the first good base is at lastGood, can be -1 if last base was bad final int start = lastGood; // the stop base is end - 1 (if we're not at the end of the sequence) final int len = end - start; if ( start != -1 && len >= kmerSize ) { // if the sequence is long enough to get some value out of, add it to the graph final String name = read.getReadName() + "_" + start + "_" + end; addSequence(name, read.getReadGroup().getSample(), read.getReadBases(), start, end, 1, false); } lastGood = -1; // reset the last good base } else if ( lastGood == -1 ) { lastGood = end; // we're at a good base, the last good one is us } } }