/** Gets a MetricsFile with default headers already written into it. */ protected <A extends MetricBase,B extends Comparable<?>> MetricsFile<A,B> getMetricsFile() { final MetricsFile<A,B> file = new MetricsFile<>(); for (final Header h : this.defaultHeaders) { file.addHeader(h); } return file; }
/** Gets a MetricsFile with default headers already written into it. */ protected <A extends MetricBase,B extends Comparable<?>> MetricsFile<A,B> getMetricsFile() { final MetricsFile<A,B> file = new MetricsFile<>(); for (final Header h : this.defaultHeaders) { file.addHeader(h); } return file; }
/** * Creates a new metrics file with appropriate headers for this context * @return MetricsFile */ public <A extends MetricBase,B extends Comparable<?>> MetricsFile<A,B> createMetricsFile() { final MetricsFile<A,B> file = new MetricsFile<A,B>(); for (final Header h : metricsHeaders) { file.addHeader(h); } return file; } public GridssConfiguration getConfig() {
/** * Compare the metrics in two files, ignoring headers and histograms. */ public static boolean areMetricsEqual(final File file1, final File file2) { try { final MetricsFile<MetricBase, ?> mf1 = new MetricsFile<>(); final MetricsFile<MetricBase, ?> mf2 = new MetricsFile<>(); mf1.read(new FileReader(file1)); mf2.read(new FileReader(file2)); return mf1.areMetricsEqual(mf2); } catch (FileNotFoundException e) { throw new SAMException(e.getMessage(), e); } }
/** * Compare the metrics in two files, ignoring headers and histograms. */ public static boolean areMetricsEqual(final File file1, final File file2) { try { final MetricsFile<MetricBase, ?> mf1 = new MetricsFile<>(); final MetricsFile<MetricBase, ?> mf2 = new MetricsFile<>(); mf1.read(new FileReader(file1)); mf2.read(new FileReader(file2)); return mf1.areMetricsEqual(mf2); } catch (FileNotFoundException e) { throw new SAMException(e.getMessage(), e); } }
/** * Method to read the header from a metrics file. */ public static List<Header> readHeaders(final File file) { try { final MetricsFile<MetricBase, ?> metricsFile = new MetricsFile<>(); metricsFile.read(new FileReader(file)); return metricsFile.getHeaders(); } catch (FileNotFoundException e) { throw new SAMException(e.getMessage(), e); } }
/** * Method to read the header from a metrics file. */ public static List<Header> readHeaders(final File file) { try { final MetricsFile<MetricBase, ?> metricsFile = new MetricsFile<>(); metricsFile.read(new FileReader(file)); return metricsFile.getHeaders(); } catch (FileNotFoundException e) { throw new SAMException(e.getMessage(), e); } }
/** * Compare the metrics and histograms in two files, ignoring headers. */ public static boolean areMetricsAndHistogramsEqual(final File file1, final File file2) { try { final MetricsFile<MetricBase, ?> mf1 = new MetricsFile<>(); final MetricsFile<MetricBase, ?> mf2 = new MetricsFile<>(); mf1.read(new FileReader(file1)); mf2.read(new FileReader(file2)); return mf1.areMetricsEqual(mf2) && mf1.areHistogramsEqual(mf2); } catch (FileNotFoundException e) { throw new SAMException(e.getMessage(), e); } } }
@Override protected int doWork() { IOUtil.assertFilesAreReadable(metricsFiles); final MetricsFile<?, ?> metricsA = new MetricsFile(); final MetricsFile<?, ?> metricsB = new MetricsFile(); try { metricsA.read(new FileReader(metricsFiles.get(0))); metricsB.read(new FileReader(metricsFiles.get(1))); final boolean areEqual = metricsA.areMetricsEqual(metricsB) && metricsA.areHistogramsEqual(metricsB); final String status = areEqual ? "EQUAL" : "NOT EQUAL"; log.info("Files " + metricsFiles.get(0) + " and " + metricsFiles.get(1) + "are " + status); } catch (final Exception e) { throw new PicardException(e.getMessage()); } return 0; }
/** Helper method to persist metrics to file and read them back again. */ private <METRIC extends MetricBase> MetricsFile<METRIC, Integer> writeThenReadBack(MetricsFile<METRIC,Integer> in) throws IOException { File f = File.createTempFile("test", ".metrics"); f.deleteOnExit(); FileWriter out = new FileWriter(f); in.write(out); MetricsFile<METRIC,Integer> retval = new MetricsFile<METRIC,Integer>(); retval.read(new FileReader(f)); return retval; }
private void assertMetricsFileEqual(final File actualMetricsFile, final File expectedMetricsFile) throws FileNotFoundException { // Actual metrics file final MetricsFile<GenotypeConcordanceSummaryMetrics, Comparable<?>> actual = new MetricsFile<GenotypeConcordanceSummaryMetrics, Comparable<?>>(); actual.read(new FileReader(actualMetricsFile)); // Expected metrics file final MetricsFile<GenotypeConcordanceSummaryMetrics, Comparable<?>> expected = new MetricsFile<GenotypeConcordanceSummaryMetrics, Comparable<?>>(); expected.read(new FileReader(expectedMetricsFile)); // Note - cannot use .equals as it calls .areHeadersEqual and they are not since the timestamp (at a minimum is different) Assert.assertTrue(expected.areMetricsEqual(actual)); Assert.assertTrue(expected.areHistogramsEqual(actual)); }
private MetricsFile<ExtractIlluminaBarcodes.BarcodeMetric, Integer> runIt(final List<String> args, final File metricsFile) throws Exception { // Generate _barcode.txt files and metrics file. Assert.assertEquals(runPicardCommandLine(args), 0); final MetricsFile<ExtractIlluminaBarcodes.BarcodeMetric, Integer> retval = new MetricsFile<>(); retval.read(new FileReader(metricsFile)); return retval; } }
/** * Convenience method to read all the Metric beans from a metrics file. * @param file to be read. * @return list of beans from the file. */ public static <T extends MetricBase> List<T> readBeans(final File file) { final MetricsFile<T, ?> metricsFile = new MetricsFile<>(); final Reader in = IOUtil.openFileForBufferedReading(file); metricsFile.read(in); CloserUtil.close(in); return metricsFile.getMetrics(); }
/** * Convenience method to read all the Metric beans from a metrics file. * @param file to be read. * @return list of beans from the file. */ public static <T extends MetricBase> List<T> readBeans(final File file) { final MetricsFile<T, ?> metricsFile = new MetricsFile<>(); final Reader in = IOUtil.openFileForBufferedReading(file); metricsFile.read(in); CloserUtil.close(in); return metricsFile.getMetrics(); }
@Test public void testZeroLengthReads() throws IOException { final File input = new File(TEST_DATA_DIR, "summary_alignment_stats_test2.sam"); final File outfile = File.createTempFile("alignmentMetrics", ".txt"); outfile.deleteOnExit(); final String[] args = new String[] { "INPUT=" + input.getAbsolutePath(), "OUTPUT=" + outfile.getAbsolutePath(), }; Assert.assertEquals(runPicardCommandLine(args), 0); final MetricsFile<AlignmentSummaryMetrics, Comparable<?>> output = new MetricsFile<>(); output.read(new FileReader(outfile)); for (final AlignmentSummaryMetrics metrics : output.getMetrics()) { // test that it doesn't blow up } }
private MetricsFile<RrbsSummaryMetrics, ?> getSummaryFile(final String input, final String reference, final String prefix, final List<String> sequences) throws Exception { final List<String> argList = new ArrayList<String>(); argList.add("INPUT=" + input); argList.add("METRICS_FILE_PREFIX=" + prefix); argList.add("REFERENCE=" + reference); for (final String sequence : sequences) { argList.add("SEQUENCE_NAMES=" + sequence); } final String[] args = new String[argList.size()]; argList.toArray(args); Assert.assertEquals(new CollectRrbsMetrics().instanceMain(args), 0); final MetricsFile<RrbsSummaryMetrics, ?> retVal = new MetricsFile<RrbsSummaryMetrics, Integer>(); retVal.read(new FileReader(prefix + ".rrbs_summary_metrics")); return retVal; }
/** * Compare the metrics in two files, ignoring headers and histograms. */ public static boolean areMetricsEqual(final File file1, final File file2, final String[] columnsToCompare) throws NoSuchFieldException { try { final MetricsFile<MetricBase, ?> mf1 = new MetricsFile<>(); final MetricsFile<MetricBase, ?> mf2 = new MetricsFile<>(); mf1.read(new FileReader(file1)); mf2.read(new FileReader(file2)); return areMetricsEqual(mf1,mf2,columnsToCompare); } catch (FileNotFoundException e) { throw new SAMException(e.getMessage(), e); } }
@Test(dataProvider = "shardDataProvider") public void testMerge(final List<File> inputs) throws IOException { final File mergedFilePrefix = new File(TEST_DATA_DIR + "mergeTest"); final File mergedSummaryFile = new File(mergedFilePrefix.getAbsolutePath() + ".variant_calling_summary_metrics"); final File mergedDetailFile = new File(mergedFilePrefix.getAbsolutePath() + ".variant_calling_detail_metrics"); mergedSummaryFile.deleteOnExit(); mergedDetailFile.deleteOnExit(); final AccumulateVariantCallingMetrics program = new AccumulateVariantCallingMetrics(); program.INPUT = inputs; program.OUTPUT = mergedFilePrefix; Assert.assertEquals(program.doWork(), 0); final MetricsFile<CollectVariantCallingMetrics.VariantCallingDetailMetrics, Comparable<?>> detail = new MetricsFile<>(); detail.read(new FileReader(mergedDetailFile)); final MetricsFile<CollectVariantCallingMetrics.VariantCallingSummaryMetrics, Comparable<?>> summary = new MetricsFile<>(); summary.read(new FileReader(mergedSummaryFile)); checkResults(detail, summary); }
@Test(dataProvider = "TheoreticalSensitivityConstantDepthDataProvider") public void testSensitivityAtConstantDepth(final double expected, final File metricsFile, final double alleleFraction, final int depth, final int sampleSize, final double tolerance) throws Exception { // This tests Theoretical Sensitivity assuming a uniform depth with a distribution of base quality scores. // Because this only tests sensitivity at a constant depth, we use this for testing the code at high depths. final MetricsFile<?, Integer> metrics = new MetricsFile<>(); try (final FileReader metricsFileReader = new FileReader(metricsFile)) { metrics.read(metricsFileReader); } final List<Histogram<Integer>> histograms = metrics.getAllHistograms(); final Histogram<Integer> qualityHistogram = histograms.get(1); // We ensure that even using different random seeds we converge to roughly the same value. for (int i = 0; i < 3; i++) { double result = TheoreticalSensitivity.sensitivityAtConstantDepth(depth, qualityHistogram, 3, sampleSize, alleleFraction, i); Assert.assertEquals(result, expected, tolerance); } }
@Test public void testFloatingPointEquality() throws IOException { MetricsFile<FloatingPointMetric,Integer> file = new MetricsFile<FloatingPointMetric,Integer>(); FloatingPointMetric metric = new FloatingPointMetric(); metric.DOUBLE_PRIMITIVE = .0000000000000000001d; metric.DOUBLE_PROP = .0000000000000000001d; metric.FLOAT_PRIMITIVE = .0000000000000000001f; metric.FLOAT_PROP = .0000000000000000001f; file.addMetric(metric); MetricsFile<FloatingPointMetric,Integer> file2 = writeThenReadBack(file); Assert.assertEquals(file, file2); }