void openFile() throws IOException { final BAMIO.ReaderAndIndex r = BAMIO.openBAMAndExposeIndex(storageClient, filePath, ValidationStringency.DEFAULT_STRINGENCY); reader = r.reader; indexStream = r.index; header = reader.getFileHeader(); hasIndex = reader.hasIndex() && reader.indexing().hasBrowseableIndex(); LOG.info("Has index = " + hasIndex); if (hasIndex) { index = new BAMFileIndexImpl( IOUtil.maybeBufferedSeekableStream(indexStream),header.getSequenceDictionary()); } else { index = null; } }
void openFile() throws IOException { LOG.info("Processing shard " + shard); final SamReader reader = BAMIO.openBAM(storageClient, shard.file, options.getStringency()); iterator = null; if (reader.hasIndex() && reader.indexing() != null) { if (filter == Filter.UNMAPPED_ONLY) { LOG.info("Processing unmapped"); iterator = reader.queryUnmapped(); } else if (shard.span != null) { LOG.info("Processing span for " + shard.contig); iterator = reader.indexing().iterator(shard.span); } else if (shard.contig.referenceName != null && !shard.contig.referenceName.isEmpty()) { LOG.info("Processing all bases for " + shard.contig); iterator = reader.query(shard.contig.referenceName, (int) shard.contig.start, (int) shard.contig.end, false); } } if (iterator == null) { LOG.info("Processing all reads"); iterator = reader.iterator(); } }
public void close() throws IOException { if (reader != null) { reader.close(); } }
private void processUnmapped(SAMFileWriter output, String inputBam) throws IOException { Logger.debug("Processing unmapped reads..."); SamReader reader = SAMRecordUtils.getSamReader(inputBam); // This should give us only read pairs with both ends unmapped Iterator<SAMRecord> iter = reader.queryUnmapped(); while (iter.hasNext()) { SAMRecord read = iter.next(); output.addAlignment(read); } reader.close(); }
void processHeader() { contigsByReference = Maps.newHashMap(); for (Contig contig : requestedContigs) { contigsByReference.put(contig.referenceName != null ? contig.referenceName : "", contig); } if (contigsByReference.size() == 0 || contigsByReference.containsKey("*")) { LOG.info("Outputting unmapped reads shard "); output.output(new BAMShard(filePath, null, new Contig("*", 0, -1))); } allReferences = contigsByReference.size() == 0 || contigsByReference.containsKey(""); LOG.info("All references = " + allReferences); LOG.info("BAM has index = " + reader.hasIndex()); LOG.info("BAM has browseable index = " + reader.indexing().hasBrowseableIndex()); LOG.info("Class for index = " + reader.indexing().getIndex().getClass().getName()); }
public static SAMFileHeader getFileHeader(Path input) throws IOException { FileUtils.checkFile(input); SamReaderFactory srf = SamReaderFactory.make(); srf.validationStringency(ValidationStringency.LENIENT); SamReader reader = srf.open(SamInputResource.of(input.toFile())); SAMFileHeader fileHeader = reader.getFileHeader(); reader.close(); return fileHeader; }
public SAMFileHeader getFileHeader() { if (header == null) { header = reader.getFileHeader(); } return header; }
private int getBAMRecordCount(final File bamFile) throws IOException { final SamReader bamReader = SamReaderFactory.makeDefault() .open(SamInputResource.of(bamFile)); final Iterator<SAMRecord> it = bamReader.iterator(); int recCount = 0; while (it.hasNext()) { it.next(); recCount++; } bamReader.close(); return recCount; }
@BeforeClass public void init() throws IOException { final SamReader reader = SamReaderFactory.makeDefault().enable(SamReaderFactory.Option.CACHE_FILE_BASED_INDEXES).open(bamFile); Assert.assertTrue(reader.hasIndex()); Assert.assertTrue(reader.indexing().hasBrowseableIndex()); bamIndex = new GATKBAMIndexFromDataSource(bamFile, reader.getFileHeader(), reader.indexing().getBrowseableIndex()); reader.close(); }
/** * Convenience method that constructs a downsampling iterator for all the reads available from a SamReader. * See {@link DownsamplingIteratorFactory#make(Iterator, Strategy, double, double, int)} for detailed parameter information. */ public static DownsamplingIterator make(final SamReader reader, final Strategy strategy, final double proportion, final double accuracy, final int seed) { return make(reader.iterator(), strategy, proportion, accuracy, seed); } }
public static long getAlignedReadCount(String bam) throws IOException{ /* ------------------------------------------------------ */ /* This chunk prepares SamReader from local bam or URL bam */ UrlValidator urlValidator = new UrlValidator(); SamReaderFactory srf=SamReaderFactory.make(); srf.validationStringency(ValidationStringency.SILENT); SamReader samReader; if(urlValidator.isValid(bam)){ samReader = SamReaderFactory.makeDefault().open( SamInputResource.of(new URL(bam)).index(new URL(bam + ".bai")) ); } else { samReader= srf.open(new File(bam)); } /* ------------------------------------------------------ */ List<SAMSequenceRecord> sequences = samReader.getFileHeader().getSequenceDictionary().getSequences(); long alnCount= 0; for(SAMSequenceRecord x : sequences){ alnCount += samReader.indexing().getIndex().getMetaData(x.getSequenceIndex()).getAlignedRecordCount(); } samReader.close(); return alnCount; }
@Test(dataProvider = "testSameUnclipped5PrimeOppositeStrandData") public void testSameUnclipped5PrimeOppositeStrand(final File input) throws IOException { final AbstractMarkDuplicatesCommandLineProgramTester tester = new BySumOfBaseQAndInOriginalOrderMDTester(); try (final SamReader reader = SamReaderFactory.makeDefault().open(input)) { tester.setHeader(reader.getFileHeader()); reader.iterator().stream().forEach(tester::addRecord); } tester.setExpectedOpticalDuplicate(0); tester.runTest(); }
@Test(dataProvider="singleIntervalOverlapping") public void testQuerySequenceContainedFalse( final File cramFileName, final File referenceFileName, final QueryInterval interval, final String[] expectedNames) throws IOException { doQueryTest( reader -> reader.query( reader.getFileHeader().getSequence(interval.referenceIndex).getSequenceName(), interval.start, interval.end, false ), cramFileName, referenceFileName, expectedNames ); }
@Test(dataProvider="singleIntervalOverlapping") public void testQueryOverlappingSequence( final File cramFileName, final File referenceFileName, final QueryInterval interval, final String[] expectedNames) throws IOException { doQueryTest( reader -> reader.queryOverlapping( reader.getFileHeader().getSequence(interval.referenceIndex).getSequenceName(), interval.start, interval.end ), cramFileName, referenceFileName, expectedNames ); }
public ReadLocusIterator(SamReader samReader, Feature region, int maxDepth) { this.maxDepth = maxDepth; if (region != null) { samIter = new ForwardShiftInsertIterator(samReader.queryOverlapping(region.getSeqname(), (int) region.getStart(), (int) region.getEnd())); } else { samIter = new ForwardShiftInsertIterator(samReader.iterator()); } }
public static boolean bamHasIndex(String bam) throws IOException{ /* ------------------------------------------------------ */ /* This chunk prepares SamReader from local bam or URL bam */ UrlValidator urlValidator = new UrlValidator(); SamReaderFactory srf=SamReaderFactory.make(); srf.validationStringency(ValidationStringency.SILENT); SamReader samReader; if(urlValidator.isValid(bam)){ samReader = SamReaderFactory.makeDefault().open( SamInputResource.of(new URL(bam)).index(new URL(bam + ".bai")) ); } else { samReader= srf.open(new File(bam)); } /* ------------------------------------------------------ */ // SamReaderFactory srf=SamReaderFactory.make(); // srf.validationStringency(ValidationStringency.SILENT); // SamReader samReader = srf.open(new File(bam)); boolean hasIndex= samReader.hasIndex(); samReader.close(); return hasIndex; }
/** * Prepare to iterate through the given SAM records, skipping non-primary alignments. Do not use * BAM index even if available. * * @param samReader must be coordinate sorted * @param intervalList Either the list of desired intervals, or null. Note that if an intervalList is * passed in that is not coordinate sorted, it will eventually be coordinated sorted by this class. */ public SamLocusIterator(final SamReader samReader, final IntervalList intervalList) { this(samReader, intervalList, samReader.hasIndex()); }
@Test(dataProvider = "SmallCRAMTest") public void CRAMIndexTest(final String inputFile, final String referenceFile, QueryInterval queryInterval, String expectedReadName) throws IOException { final File input = new File(TEST_DATA_DIR, inputFile); final File reference = new File(TEST_DATA_DIR, referenceFile); try(final SamReader reader = SamReaderFactory.makeDefault().referenceSequence(reference).open(input)) { Assert.assertTrue(reader.hasIndex()); final CloseableIterator<SAMRecord> iterator = reader.query(new QueryInterval[]{queryInterval}, false); Assert.assertTrue(iterator.hasNext()); SAMRecord r1 = iterator.next(); Assert.assertEquals(r1.getReadName(), expectedReadName); } }
@Override public SAMRecordIterator query(final QueryInterval[] intervals, final boolean contained) { return new AssertingIterator(this.reader.query(intervals, contained)); }
private long getReadCount(FilterSamReads filterTest) throws Exception { final SamReader samReader = SamReaderFactory.makeDefault().open(filterTest.OUTPUT); long count = StreamSupport.stream(samReader.spliterator(), false) .count(); samReader.close(); return count; } }