/** * Set or unset option depending on the boolean given * @param option the option to modify * @param setIt true to set the option, false to unset it. * @return this <code>VariantContextWriterBuilder</code> */ public VariantContextWriterBuilder modifyOption(final Options option, final boolean setIt) { return (setIt) ? this.setOption(option) : this.unsetOption(option); }
/** * Set or unset option depending on the boolean given * @param option the option to modify * @param setIt true to set the option, false to unset it. * @return this <code>VariantContextWriterBuilder</code> */ public VariantContextWriterBuilder modifyOption(final Options option, final boolean setIt) { return (setIt) ? this.setOption(option) : this.unsetOption(option); }
public static void main(final String[] args) throws IOException { if (args.length < 1) { System.out.println("Usage: " + PrintVariantsExample.class.getCanonicalName() + " inFile [outFile]"); System.exit(1); } final File inputFile = new File(args[0]); final File outputFile = args.length >= 2 ? new File(args[1]) : null; final long start = System.currentTimeMillis(); log.info("Start with args:" + Arrays.toString(args)); printConfigurationInfo(); try (final VariantContextWriter writer = outputFile == null ? null : new VariantContextWriterBuilder().setOutputFile(outputFile).setOutputFileType(VariantContextWriterBuilder.OutputType.VCF).unsetOption(Options.INDEX_ON_THE_FLY).build(); final AbstractFeatureReader<VariantContext, LineIterator> reader = AbstractFeatureReader.getFeatureReader(inputFile.getAbsolutePath(), new VCFCodec(), false)) { log.info(reader.getClass().getSimpleName() + " hasIndex " + reader.hasIndex()); if (writer != null) { log.info(writer.getClass().getSimpleName()); writer.writeHeader((VCFHeader) reader.getHeader()); } final ProgressLogger pl = new ProgressLogger(log, 1000000); for (final VariantContext vc : reader.iterator()) { if (writer != null) { writer.add(vc); } pl.record(vc.getContig(), vc.getStart()); } } final long end = System.currentTimeMillis(); log.info(String.format("Done. Elapsed time %.3f seconds", (end - start) / 1000.0)); }
public static void main(final String[] args) throws IOException { if (args.length < 1) { System.out.println("Usage: " + PrintVariantsExample.class.getCanonicalName() + " inFile [outFile]"); System.exit(1); } final File inputFile = new File(args[0]); final File outputFile = args.length >= 2 ? new File(args[1]) : null; final long start = System.currentTimeMillis(); log.info("Start with args:" + Arrays.toString(args)); printConfigurationInfo(); try (final VariantContextWriter writer = outputFile == null ? null : new VariantContextWriterBuilder().setOutputFile(outputFile).setOutputFileType(VariantContextWriterBuilder.OutputType.VCF).unsetOption(Options.INDEX_ON_THE_FLY).build(); final AbstractFeatureReader<VariantContext, LineIterator> reader = AbstractFeatureReader.getFeatureReader(inputFile.getAbsolutePath(), new VCFCodec(), false)) { log.info(reader.getClass().getSimpleName() + " hasIndex " + reader.hasIndex()); if (writer != null) { log.info(writer.getClass().getSimpleName()); writer.writeHeader((VCFHeader) reader.getHeader()); } final ProgressLogger pl = new ProgressLogger(log, 1000000); for (final VariantContext vc : reader.iterator()) { if (writer != null) { writer.add(vc); } pl.record(vc.getContig(), vc.getStart()); } } final long end = System.currentTimeMillis(); log.info(String.format("Done. Elapsed time %.3f seconds", (end - start) / 1000.0)); }
/** * Common parts of {@link VariantContextWriterBuilder} creation for the openVariantContextWriter functions. */ private static VariantContextWriterBuilder makeBuilder(VCFHeader header) { // construct factory object for VariantContextWriter VariantContextWriterBuilder builder = new VariantContextWriterBuilder(); builder.setReferenceDictionary(header.getSequenceDictionary()); // Be more lenient in missing header fields. builder.setOption(Options.ALLOW_MISSING_FIELDS_IN_HEADER); // Disable on-the-fly generation of Tribble index if the input file does not have a sequence dictionary. if (header.getSequenceDictionary() == null) builder.unsetOption(Options.INDEX_ON_THE_FLY); return builder; }
private void writeAllViolations(final MendelianViolationDetector.Result result) { if (VCF_DIR != null) { LOG.info(String.format("Writing family violation VCFs to %s/", VCF_DIR.getAbsolutePath())); final VariantContextComparator vcComparator = new VariantContextComparator(inputHeader.get().getContigLines()); final Set<VCFHeaderLine> headerLines = new LinkedHashSet<>(inputHeader.get().getMetaDataInInputOrder()); headerLines.add(new VCFInfoHeaderLine(MendelianViolationDetector.MENDELIAN_VIOLATION_KEY, 1, VCFHeaderLineType.String, "Type of mendelian violation.")); headerLines.add(new VCFInfoHeaderLine(MendelianViolationDetector.ORIGINAL_AC, VCFHeaderLineCount.A, VCFHeaderLineType.Integer, "Original AC")); headerLines.add(new VCFInfoHeaderLine(MendelianViolationDetector.ORIGINAL_AF, VCFHeaderLineCount.A, VCFHeaderLineType.Float, "Original AF")); headerLines.add(new VCFInfoHeaderLine(MendelianViolationDetector.ORIGINAL_AN, 1, VCFHeaderLineType.Integer, "Original AN")); for (final PedFile.PedTrio trio : pedFile.get().values()) { final File outputFile = new File(VCF_DIR, IOUtil.makeFileNameSafe(trio.getFamilyId() + IOUtil.VCF_FILE_EXTENSION)); LOG.info(String.format("Writing %s violation VCF to %s", trio.getFamilyId(), outputFile.getAbsolutePath())); final VariantContextWriter out = new VariantContextWriterBuilder() .setOutputFile(outputFile) .unsetOption(INDEX_ON_THE_FLY) .build(); final VCFHeader newHeader = new VCFHeader(headerLines, CollectionUtil.makeList(trio.getMaternalId(), trio.getPaternalId(), trio.getIndividualId())); final TreeSet<VariantContext> orderedViolations = new TreeSet<>(vcComparator); orderedViolations.addAll(result.violations().get(trio.getFamilyId())); out.writeHeader(newHeader); orderedViolations.forEach(out::add); out.close(); } } }
@Test public void testAsync() { final VariantContextWriterBuilder builder = new VariantContextWriterBuilder() .setReferenceDictionary(dictionary) .setOutputFile(vcf); VariantContextWriter writer = builder.build(); Assert.assertEquals(writer instanceof AsyncVariantContextWriter, Defaults.USE_ASYNC_IO_WRITE_FOR_TRIBBLE, "testAsync default"); writer = builder.setOption(Options.USE_ASYNC_IO).build(); Assert.assertTrue(writer instanceof AsyncVariantContextWriter, "testAsync option=set"); writer = builder.unsetOption(Options.USE_ASYNC_IO).build(); Assert.assertFalse(writer instanceof AsyncVariantContextWriter, "testAsync option=unset"); }
private void writeAllViolations(final MendelianViolationDetector.Result result) { if (VCF_DIR != null) { LOG.info(String.format("Writing family violation VCFs to %s/", VCF_DIR.getAbsolutePath())); final VariantContextComparator vcComparator = new VariantContextComparator(inputHeader.get().getContigLines()); final Set<VCFHeaderLine> headerLines = new LinkedHashSet<>(inputHeader.get().getMetaDataInInputOrder()); headerLines.add(new VCFInfoHeaderLine(MendelianViolationDetector.MENDELIAN_VIOLATION_KEY, 1, VCFHeaderLineType.String, "Type of mendelian violation.")); headerLines.add(new VCFInfoHeaderLine(MendelianViolationDetector.ORIGINAL_AC, VCFHeaderLineCount.A, VCFHeaderLineType.Integer, "Original AC")); headerLines.add(new VCFInfoHeaderLine(MendelianViolationDetector.ORIGINAL_AF, VCFHeaderLineCount.A, VCFHeaderLineType.Float, "Original AF")); headerLines.add(new VCFInfoHeaderLine(MendelianViolationDetector.ORIGINAL_AN, 1, VCFHeaderLineType.Integer, "Original AN")); for (final PedFile.PedTrio trio : pedFile.get().values()) { final File outputFile = new File(VCF_DIR, IOUtil.makeFileNameSafe(trio.getFamilyId() + IOUtil.VCF_FILE_EXTENSION)); LOG.info(String.format("Writing %s violation VCF to %s", trio.getFamilyId(), outputFile.getAbsolutePath())); final VariantContextWriter out = new VariantContextWriterBuilder() .setOutputFile(outputFile) .unsetOption(INDEX_ON_THE_FLY) .build(); final VCFHeader newHeader = new VCFHeader(headerLines, CollectionUtil.makeList(trio.getMaternalId(), trio.getPaternalId(), trio.getIndividualId())); final TreeSet<VariantContext> orderedViolations = new TreeSet<>(vcComparator); orderedViolations.addAll(result.violations().get(trio.getFamilyId())); out.writeHeader(newHeader); orderedViolations.forEach(out::add); out.close(); } } }
/** * Return a new {@link VariantContextWriter} that uses the header from <code>reader</code> but has the header * extended header through {@link #extendHeaderFields}. * * @param header * the VCF header to use for the construction * @param fileName * path to output file * @param additionalHeaderLines * additional {@link VCFHeaderLine}s to add * @param generateIndex * whether or not to generate an index * @return A correct writer for variantContexts */ public static VariantContextWriter openVariantContextWriter(VCFHeader header, String fileName, Collection<VCFHeaderLine> additionalHeaderLines, boolean generateIndex) { VariantContextWriterBuilder builder = makeBuilder(header); builder.setOutputFile(new File(fileName)); if (!generateIndex) builder.unsetOption(Options.INDEX_ON_THE_FLY); // construct VariantContextWriter and write out header VariantContextWriter out = builder.build(); final VCFHeader updatedHeader = extendHeaderFields(new VCFHeader(header)); for (VCFHeaderLine headerLine : additionalHeaderLines) updatedHeader.addMetaDataLine(headerLine); out.writeHeader(updatedHeader); return out; }
/** * Create a VariantContextWriter. * * @param outputStream Output stream to write. * @param sequenceDictionary SAM sequence directory (it can be got from VCFHeader) * @param options Writer options * @return The variant context writer */ public static VariantContextWriter createVariantContextWriter(OutputStream outputStream, SAMSequenceDictionary sequenceDictionary, Options ...options) { // setup writer VariantContextWriterBuilder builder = new VariantContextWriterBuilder() .setOutputStream(outputStream) .setReferenceDictionary(sequenceDictionary) .setOption(Options.WRITE_FULL_FORMAT_FIELD) .unsetOption(Options.INDEX_ON_THE_FLY); // options if (options != null) { for (Options option : options) { builder.setOption(option); } } return builder.build(); }
@Test public void testSetOutputStream() { final OutputStream stream = new ByteArrayOutputStream(); final VariantContextWriterBuilder builder = new VariantContextWriterBuilder() .setReferenceDictionary(dictionary) .unsetOption(Options.INDEX_ON_THE_FLY) .setOutputStream(stream); VariantContextWriter writer = builder.build(); Assert.assertTrue(writer instanceof VCFWriter, "testSetOutputStream default"); writer = builder.setOption(Options.FORCE_BCF).build(); Assert.assertTrue(writer instanceof BCF2Writer, "testSetOutputStream FORCE_BCF set -> expected BCF stream, was VCF stream"); // test that FORCE_BCF remains in effect, overriding the explicit setting of VCF writer = builder.setOutputVCFStream(stream).build(); Assert.assertTrue(writer instanceof BCF2Writer, "testSetOutputStream FORCE_BCF set 2 -> expected BCF stream, was VCF stream"); writer = builder.unsetOption(Options.FORCE_BCF).build(); Assert.assertTrue(writer instanceof VCFWriter, "testSetOutputStream FORCE_BCF unset -> expected VCF stream, was BCF stream"); writer = builder.setOutputBCFStream(stream).build(); Assert.assertTrue(writer instanceof BCF2Writer, "testSetOutputStream BCF"); writer = builder.setOutputVCFStream(stream).build(); Assert.assertTrue(writer instanceof VCFWriter, "testSetOutputStream VCF"); }
@Test(expectedExceptions = IllegalStateException.class) public void testChangeHeaderAfterWritingHeader() throws IOException { final File bcfOutputFile = File.createTempFile("testWriteAndReadVCF.", ".bcf", tempDir); bcfOutputFile.deleteOnExit(); final VCFHeader header = createFakeHeader(); // prevent changing header if it's already written try (final VariantContextWriter writer = new VariantContextWriterBuilder() .setOutputFile(bcfOutputFile).setReferenceDictionary(header.getSequenceDictionary()) .unsetOption(Options.INDEX_ON_THE_FLY) .build()) { writer.writeHeader(header); writer.setHeader(header); } }
@Test(expectedExceptions = IllegalStateException.class) public void testWriteHeaderTwice() throws IOException { final File bcfOutputFile = File.createTempFile("testWriteAndReadVCF.", ".bcf", tempDir); bcfOutputFile.deleteOnExit(); final VCFHeader header = createFakeHeader(); // prevent writing header twice try (final VariantContextWriter writer = new VariantContextWriterBuilder() .setOutputFile(bcfOutputFile).setReferenceDictionary(header.getSequenceDictionary()) .unsetOption(Options.INDEX_ON_THE_FLY) .build()) { writer.writeHeader(header); writer.writeHeader(header); } }
/** * Return a new {@link VariantContextWriter} that uses the header from <code>reader</code> but has the header * extended header through {@link #extendHeaderFields}. * * @param header * the VCF header to use for the construction * @param outStream * {@link OutputStream} to write to * @param additionalHeaderLines * additional {@link VCFHeaderLine}s to add * @return A correct writer for variantContexts */ public static VariantContextWriter openVariantContextWriter(VCFHeader header, OutputStream outStream, Collection<VCFHeaderLine> additionalHeaderLines) { VariantContextWriterBuilder builder = makeBuilder(header); builder.unsetOption(Options.INDEX_ON_THE_FLY); builder.setOutputStream(outStream); // construct VariantContextWriter and write out header VariantContextWriter out = builder.build(); final VCFHeader updatedHeader = extendHeaderFields(new VCFHeader(header)); for (VCFHeaderLine headerLine : additionalHeaderLines) updatedHeader.addMetaDataLine(headerLine); out.writeHeader(updatedHeader); return out; }
@Test public void testBuffering() { final VariantContextWriterBuilder builder = new VariantContextWriterBuilder() .setReferenceDictionary(dictionary) .setOutputFile(vcf) .unsetOption(Options.INDEX_ON_THE_FLY); // so the potential BufferedOutputStream is not wrapped in a PositionalOutputStream VariantContextWriter writer = builder.build(); Assert.assertTrue(((VCFWriter) writer).getOutputStream() instanceof BufferedOutputStream, "testBuffering was not buffered by default"); writer = builder.unsetBuffering().build(); Assert.assertFalse(((VCFWriter) writer).getOutputStream() instanceof BufferedOutputStream, "testBuffering was buffered when unset"); writer = builder.setBuffer(8192).build(); Assert.assertTrue(((VCFWriter) writer).getOutputStream() instanceof BufferedOutputStream, "testBuffering was not buffered when set"); }
private VariantContextWriter openOutputFile() { VariantContextWriterBuilder builder = new VariantContextWriterBuilder() .setReferenceDictionary(fasta.getSequenceDictionary()).setOutputFile(options.getPathOutputVCF()); if (options.getPathOutputVCF().endsWith(".gz") || options.getPathOutputVCF().endsWith(".bcf")) builder.setOption(Options.INDEX_ON_THE_FLY); else builder.unsetOption(Options.INDEX_ON_THE_FLY); VariantContextWriter writer = builder.build(); VCFHeader header = new VCFHeader(); int i = 0; for (SAMSequenceRecord record : fasta.getSequenceDictionary().getSequences()) { Map<String, String> mapping = new TreeMap<String, String>(); mapping.put("ID", record.getSequenceName()); mapping.put("length", Integer.toString(record.getSequenceLength())); header.addMetaDataLine(new VCFContigHeaderLine(mapping, i++)); } header.addMetaDataLine(new VCFSimpleHeaderLine("ALT", "ERROR", "Error in conversion")); header.addMetaDataLine(new VCFFilterHeaderLine("PARSE_ERROR", "Problem in parsing original HGVS variant string, written out as variant at 1:g.1N>N")); header.addMetaDataLine(new VCFInfoHeaderLine("ERROR_MESSAGE", 1, VCFHeaderLineType.String, "Error message")); header.addMetaDataLine(new VCFInfoHeaderLine("ORIG_VAR", 1, VCFHeaderLineType.String, "Original HGVS variant string from input file to hgvs-to-vcf")); writer.writeHeader(header); return writer; }
@Test public void testSetOutputFileType() { final VariantContextWriterBuilder builder = new VariantContextWriterBuilder() .setReferenceDictionary(dictionary) .setOutputFile(unknown); VariantContextWriter writer = builder.setOutputFileType(VariantContextWriterBuilder.OutputType.VCF).build(); Assert.assertTrue(writer instanceof VCFWriter, "testSetOutputFileType VCF"); Assert.assertFalse(((VCFWriter) writer).getOutputStream() instanceof BlockCompressedOutputStream, "testSetOutputFileType VCF was compressed"); writer = builder.setOption(Options.FORCE_BCF).build(); Assert.assertTrue(writer instanceof BCF2Writer, "testSetOutputFileType FORCE_BCF set -> expected BCF, was VCF"); // test that FORCE_BCF remains in effect, overriding the explicit setting of VCF writer = builder.setOutputFileType(VariantContextWriterBuilder.OutputType.VCF).build(); Assert.assertTrue(writer instanceof BCF2Writer, "testSetOutputFileType FORCE_BCF set 2 -> expected BCF, was VCF"); writer = builder.unsetOption(Options.FORCE_BCF).build(); Assert.assertTrue(writer instanceof VCFWriter, "testSetOutputFileType FORCE_BCF unset -> expected VCF, was BCF"); Assert.assertFalse(((VCFWriter) writer).getOutputStream() instanceof BlockCompressedOutputStream, "testSetOutputFileType FORCE_BCF unset was compressed"); writer = builder.setOutputFileType(VariantContextWriterBuilder.OutputType.BLOCK_COMPRESSED_VCF).build(); Assert.assertTrue(writer instanceof VCFWriter, "testSetOutputFile BLOCK_COMPRESSED_VCF"); Assert.assertTrue(((VCFWriter) writer).getOutputStream() instanceof BlockCompressedOutputStream, "testSetOutputFileType BLOCK_COMPRESSED_VCF was not compressed"); writer = builder.setOutputFileType(VariantContextWriterBuilder.OutputType.BCF).build(); Assert.assertTrue(writer instanceof BCF2Writer, "testSetOutputFileType BCF"); }
@Test(expectedExceptions = IllegalStateException.class) public void testChangeHeaderAfterWritingBody() throws IOException { final File bcfOutputFile = File.createTempFile("testWriteAndReadVCF.", ".bcf", tempDir); bcfOutputFile.deleteOnExit(); final VCFHeader header = createFakeHeader(); // prevent changing header if part of body is already written try (final VariantContextWriter writer = new VariantContextWriterBuilder() .setOutputFile(bcfOutputFile).setReferenceDictionary(header.getSequenceDictionary()) .unsetOption(Options.INDEX_ON_THE_FLY) .build()) { writer.setHeader(header); writer.add(createVC(header)); writer.setHeader(header); } }
/** * test, using the writer and reader, that we can output and input BCF without problems */ @Test public void testWriteAndReadBCF() throws IOException { final File bcfOutputFile = File.createTempFile("testWriteAndReadVCF.", ".bcf", tempDir); bcfOutputFile.deleteOnExit(); final VCFHeader header = createFakeHeader(); try (final VariantContextWriter writer = new VariantContextWriterBuilder() .setOutputFile(bcfOutputFile).setReferenceDictionary(header.getSequenceDictionary()) .unsetOption(Options.INDEX_ON_THE_FLY) .build()) { writer.writeHeader(header); writer.add(createVC(header)); writer.add(createVC(header)); } VariantContextTestProvider.VariantContextContainer container = VariantContextTestProvider .readAllVCs(bcfOutputFile, new BCF2Codec()); int counter = 0; final Iterator<VariantContext> it = container.getVCs().iterator(); while (it.hasNext()) { it.next(); counter++; } Assert.assertEquals(counter, 2); }
builder.setOption(Options.INDEX_ON_THE_FLY); else builder.unsetOption(Options.INDEX_ON_THE_FLY); final VariantContextWriter writer = builder.build(); writer.writeHeader(header);