protected void createSamFileWriter(final SAMFileHeader header) { out = new SAMFileWriterFactory().makeSAMOrBAMWriter(header, header.getSortOrder() == SortOrder.queryname, OUTPUT); }
@Override public boolean pre() { if (this.input.toFile().exists()) { SAMFileHeader samFileHeader = AlignmentConverter.buildSAMFileHeader(reader.getHeader()); writer = new SAMFileWriterFactory().makeBAMWriter(samFileHeader, true, this.input.toFile()); super.pre(); return true; } else { return false; } }
private void addWriter(SAMReaderID id , String outName, SAMFileHeader.SortOrder order, boolean presorted, boolean indexOnTheFly, boolean generateMD5, SAMProgramRecord programRecord) { File f = new File(outName); SAMFileHeader header = setupWriter(toolkit.getSAMFileHeader(id), programRecord); SAMFileWriterFactory factory = new SAMFileWriterFactory(); factory.setCreateIndex(indexOnTheFly); factory.setCreateMd5File(generateMD5); SAMFileWriter sw = factory.makeSAMOrBAMWriter(header, presorted, f); writerMap.put(id,sw); }
/** * Create a BAMFileWriter that is ready to receive SAMRecords. Uses default compression level. * * @param header entire header. Sort order is determined by the sortOrder property of this arg. * @param presorted if true, SAMRecords must be added to the SAMFileWriter in order that agrees with header.sortOrder. * @param outputPath where to write the output. */ public SAMFileWriter makeBAMWriter(final SAMFileHeader header, final boolean presorted, final Path outputPath) { return makeBAMWriter(header, presorted, outputPath, this.getCompressionLevel()); }
public int writeToFile(File outFile, Iterator<PicardAlignment> alignments, boolean createIndex) { SAMFileWriterFactory factory = new SAMFileWriterFactory(); factory.setCreateIndex(createIndex); SAMFileWriter writer = factory.makeSAMOrBAMWriter(header, true, outFile); return writeAlignments(writer, alignments); }
public SAMFileWriterFactory getSamFileWriterFactory(boolean sorted) { return new SAMFileWriterFactory() .setTempDirectory(fsContext.getTemporaryDirectory()) .setCreateIndex(sorted); // also covered by -Dcreate_index=true }
private void createBAM(final List<GATKSAMRecord> reads) throws IOException { testBAM = createTempFile("TraverseActiveRegionsUnitTest", ".bam"); SAMFileWriter out = new SAMFileWriterFactory().setCreateIndex(true).makeBAMWriter(reads.get(0).getHeader(), true, testBAM); for (GATKSAMRecord read : reads ) { out.addAlignment(read); } out.close(); new File(testBAM.getAbsolutePath().replace(".bam", ".bai")).deleteOnExit(); new File(testBAM.getAbsolutePath() + ".bai").deleteOnExit(); }
private void createSmallBamToOutputStream(final OutputStream outputStream,boolean binary) { final SAMFileWriterFactory factory = new SAMFileWriterFactory(); factory.setCreateIndex(false); factory.setCreateMd5File(false); final SAMFileHeader header = new SAMFileHeader(); // index only created if coordinate sorted header.setSortOrder(SAMFileHeader.SortOrder.coordinate); header.addSequence(new SAMSequenceRecord("chr1", 123)); try (final SAMFileWriter writer = (binary? factory.makeBAMWriter(header, false, outputStream): factory.makeSAMWriter(header, false, outputStream) )) { fillSmallBam(writer); } }
private void writeRecordsToFile ( final List<SAMRecord> recs, final File targetFile, final File referenceFile, final SAMFileHeader samHeader) { // NOTE: even when the input is coord-sorted, using assumePresorted=false will cause some // tests to fail since it can change the order of some unmapped reads - AFAICT this is allowed // by the spec since the order is arbitrary for unmapped try (final SAMFileWriter writer = new SAMFileWriterFactory() .makeWriter(samHeader, true, targetFile, referenceFile)) { for (SAMRecord rec : recs) { writer.addAlignment(rec); } } }
@Test(description="check that factory settings are propagated to writer") public void testFactorySettings() throws Exception { final SAMFileWriterFactory factory = new SAMFileWriterFactory(); factory.setCreateIndex(false); factory.setCreateMd5File(false); final File wontBeUsed = new File("wontBeUsed.tmp"); final int maxRecsInRam = 271828; factory.setMaxRecordsInRam(maxRecsInRam); factory.setTempDirectory(wontBeUsed); final SAMFileHeader header = new SAMFileHeader(); header.setSortOrder(SAMFileHeader.SortOrder.coordinate); header.addSequence(new SAMSequenceRecord("chr1", 123)); try (final SAMFileWriter writer = factory.makeBAMWriter(header, false, new ByteArrayOutputStream())) { Assert.assertEquals(maxRecsInRam, ((SAMFileWriterImpl) writer).getMaxRecordsInRam()); Assert.assertEquals(wontBeUsed, ((SAMFileWriterImpl) writer).getTempDirectory()); } try (final SAMFileWriter writer = factory.makeSAMWriter(header, false, new ByteArrayOutputStream())) { Assert.assertEquals(maxRecsInRam, ((SAMFileWriterImpl) writer).getMaxRecordsInRam()); Assert.assertEquals(wontBeUsed, ((SAMFileWriterImpl) writer).getTempDirectory()); } }
/** * create an artificial sam file * * @param filename the filename to write to * @param numberOfChromosomes the number of chromosomes * @param startingChromosome where to start counting * @param chromosomeSize how large each chromosome is * @param readsPerChomosome how many reads to make in each chromosome. They'll be aligned from position 1 to x (which is the number of reads) */ public static void createArtificialSamFile(String filename, int numberOfChromosomes, int startingChromosome, int chromosomeSize, int readsPerChomosome) { SAMFileHeader header = createArtificialSamHeader(numberOfChromosomes, startingChromosome, chromosomeSize); File outFile = new File(filename); SAMFileWriter out = new SAMFileWriterFactory().makeSAMWriter(header, false, outFile); for (int x = startingChromosome; x < startingChromosome + numberOfChromosomes; x++) { for (int readNumber = 1; readNumber <= readsPerChomosome; readNumber++) { out.addAlignment(createArtificialRead(header, "Read_" + readNumber, x - startingChromosome, readNumber, 100)); } } out.close(); }
/** * Creates samFileReader from the data in instance of this class * * @return SamReader */ public SamReader getSamReader() { final File tempFile; try { tempFile = File.createTempFile("temp", this.useBamFile ? ".bam" : ".sam"); tempFile.deleteOnExit(); } catch (final IOException e) { throw new RuntimeIOException("problems creating tempfile", e); } this.header.setAttribute("VN", "1.0"); try(final SAMFileWriter w = this.useBamFile ? new SAMFileWriterFactory().makeBAMWriter(this.header, true, tempFile) : new SAMFileWriterFactory().makeSAMWriter(this.header, true, tempFile)) { for (final SAMRecord r : this.getRecords()) { w.addAlignment(r); } } return SamReaderFactory.makeDefault().validationStringency(ValidationStringency.SILENT).open(tempFile); }
/** * filters a SAM using a reads file */ @Test(dataProvider = "dataTestReadFilter") public void testReadFilters(final FilterSamReads.Filter filterType, final List<String> readList, final int expectNumber) throws Exception { final File inputSam = File.createTempFile("testSam", ".sam", new File(TEST_DIR)); inputSam.deleteOnExit(); final File sortedSamIdx = new File(TEST_DIR, inputSam.getName() + ".idx"); sortedSamIdx.deleteOnExit(); try (final SAMFileWriter writer = new SAMFileWriterFactory() .setCreateIndex(true).makeSAMWriter(builder.getHeader(), false, inputSam)) { for (final SAMRecord record : builder) { writer.addAlignment(record); } } final File reads = File.createTempFile(TEST_DIR, "reads"); reads.deleteOnExit(); try (final FileWriter writer = new FileWriter(reads)) { writer.write(String.join("\n", readList)); } catch (IOException e) { e.printStackTrace(); } FilterSamReads filterTest = setupProgram(reads, inputSam, filterType); Assert.assertEquals(filterTest.doWork(), 0); long count = getReadCount(filterTest); Assert.assertEquals(count, expectNumber); }
public SAMFileWriterStorage( SAMFileWriterStub stub, File file ) { this.referenceFasta = stub.getReferenceFile(); this.file = file; SAMFileWriterFactory factory = new SAMFileWriterFactory(); factory.setCreateIndex(true); if (stub.getGenerateMD5()) factory.setCreateMd5File(true); factory.setMaxRecordsInRam(stub.getMaxRecordsInRam()); this.writer = factory.makeSAMWriter( stub.getFileHeader(), stub.isPresorted(), stub.getOutputStream());
switch (format) { case SAM: w = new SAMFileWriterFactory().makeSAMWriter(header, false, baos); break; case BAM: w = new SAMFileWriterFactory().makeBAMWriter(header, false, baos); break; case CRAM: w = new SAMFileWriterFactory().makeCRAMWriter(header, baos, (File) null); break; default:
SAMFileWriterFactory samFileWriterFactory = new SAMFileWriterFactory(); samFileWriterFactory.setAsyncOutputBufferSize(params.asyncBamBuffer); samFileWriterFactory.setCreateIndex(false); samFileWriterFactory.setCreateMd5File(false); samFileWriterFactory.setUseAsyncIo(params.syncBamOutput);
@Test(dataProvider = "getEmptyArraysAndExtensions") public void testWriteSamWithEmptyArray(Object emptyArray, Class<?> arrayClass, String fileExtension) throws IOException { Assert.assertEquals(emptyArray.getClass(), arrayClass); Assert.assertEquals(Array.getLength(emptyArray), 0); final SAMRecordSetBuilder samRecords = new SAMRecordSetBuilder(); samRecords.addFrag("Read", 0, 100, false); final SAMRecord record = samRecords.getRecords().iterator().next(); record.setAttribute(ARRAY_TAG, emptyArray); checkArrayIsEmpty(ARRAY_TAG, record, arrayClass); final Path tmp = Files.createTempFile("tmp", fileExtension); IOUtil.deleteOnExit(tmp); final SAMFileWriterFactory writerFactory = new SAMFileWriterFactory() .setCreateMd5File(false) .setCreateIndex(false); final Path reference = IOUtil.getPath("src/test/resources/htsjdk/samtools/one-contig.fasta"); try (final SAMFileWriter samFileWriter = writerFactory.makeWriter(samRecords.getHeader(), false, tmp, reference)) { samFileWriter.addAlignment(record); } try (final SamReader reader = SamReaderFactory.makeDefault() .referenceSequence(reference) .open(tmp)) { final SAMRecordIterator iterator = reader.iterator(); Assert.assertTrue(iterator.hasNext()); final SAMRecord recordFromDisk = iterator.next(); checkArrayIsEmpty(ARRAY_TAG, recordFromDisk, arrayClass); } }
SAMRecordIterator iterator = reader.iterator(); SAMFileWriterFactory writerFactory = new SAMFileWriterFactory(); SAMFileWriter writer = null; OutputStream os = new BufferedOutputStream(new FileOutputStream(params.outputFile)); switch (params.outputFormat) { case BAM: writer = writerFactory.makeBAMWriter(reader.getFileHeader(), reader.getFileHeader().getSortOrder() == SortOrder.coordinate, os); break; case CRAM: writer = writerFactory.makeCRAMWriter(reader.getFileHeader(), os, params.reference); break;
private SAMFileWriterFactory createWriterFactoryWithOptions(SAMFileHeader header) { final SAMFileWriterFactory factory = new SAMFileWriterFactory(); factory.setCreateIndex(true); factory.setCreateMd5File(true); // index only created if coordinate sorted header.setSortOrder(SAMFileHeader.SortOrder.coordinate); header.addSequence(new SAMSequenceRecord("chr1", 123)); header.addReadGroup(new SAMReadGroupRecord("1")); return factory; }
/** * Create either a SAM or a BAM writer based on examination of the outputFile extension. * @param header entire header. Sort order is determined by the sortOrder property of this arg. * @param presorted presorted if true, SAMRecords must be added to the SAMFileWriter in order that agrees with header.sortOrder. * @param outputFile where to write the output. Must end with .sam or .bam. * @return SAM or BAM writer based on file extension of outputFile. */ public SAMFileWriter makeSAMOrBAMWriter(final SAMFileHeader header, final boolean presorted, final File outputFile) { final String filename = outputFile.getName(); if (filename.endsWith(BamFileIoUtils.BAM_FILE_EXTENSION)) { return makeBAMWriter(header, presorted, outputFile); } if (filename.endsWith(".sam")) { return makeSAMWriter(header, presorted, outputFile); } return makeBAMWriter(header, presorted, outputFile); } }