import htsjdk.samtools.metrics.MetricsFile; //导入依赖的package包/类
/**
 * Note that (due to raw data), this test includes collapsing over libraries (not just the contexts).
 * @throws IOException
 */
@Test
public void testBasicScoring() throws IOException {
    final MetricsFile<SequencingArtifactMetrics.PreAdapterDetailMetrics, Comparable<?>> mf = new MetricsFile<>();
    mf.read(new FileReader(testPreAdapterDetailsMetrics));

    final Map<Transition, Double> scoreMap = PreAdapterOrientationScorer.scoreOrientationBiasMetricsOverContext(mf.getMetrics());

    Assert.assertNotNull(scoreMap);
    Assert.assertEquals(scoreMap.keySet().size(), 12);

    // Ground truth values painstakingly derived manually
    Assert.assertEquals(scoreMap.get(Transition.transitionOf('A', 'C')), 100.0, 1e-6);
    Assert.assertEquals(scoreMap.get(Transition.transitionOf('A', 'G')), 50.5788416297570, 1e-6);
    Assert.assertEquals(scoreMap.get(Transition.transitionOf('A', 'T')), 100.0, 1e-6);
    Assert.assertEquals(scoreMap.get(Transition.transitionOf('C', 'A')), 100.0, 1e-6);
    Assert.assertEquals(scoreMap.get(Transition.transitionOf('C', 'G')), 100.0, 1e-6);
    Assert.assertEquals(scoreMap.get(Transition.transitionOf('C', 'T')), 58.0641821538479, 1e-6);
}
 

import htsjdk.samtools.metrics.MetricsFile; //导入依赖的package包/类
/**
 * Note that (due to raw data), this test includes collapsing over libraries (not just the contexts).
 * @throws IOException
 */
@Test
public void testBasicCounting() throws IOException {
    final MetricsFile<SequencingArtifactMetrics.PreAdapterDetailMetrics, Comparable<?>> mf = new MetricsFile<>();
    mf.read(new FileReader(testPreAdapterDetailsMetrics));

    final Map<Transition, RealMatrix> countMap = PreAdapterOrientationScorer.countOrientationBiasMetricsOverContext(mf.getMetrics());

    Assert.assertNotNull(countMap);
    Assert.assertEquals(countMap.keySet().size(), 12);

    // Ground truth values painstakingly derived manually from both libraries (hence four values in the expression instead of two)
    // L1 norm can be used since all values are always positive.
    Assert.assertEquals(countMap.get(Transition.transitionOf('A', 'C')).getRowVector(0).getL1Norm(), 2836660 + 2631203 + 240 + 246, 1e-1);
    Assert.assertEquals(countMap.get(Transition.transitionOf('A', 'C')).getRowVector(1).getL1Norm(), 2852491 + 333 + 2646654 + 297, 1e-1);
    Assert.assertEquals(countMap.get(Transition.transitionOf('A', 'G')).getRowVector(0).getL1Norm(), 2631203 + 416 + 2836660 + 481, 1e-1);
    Assert.assertEquals(countMap.get(Transition.transitionOf('A', 'G')).getRowVector(1).getL1Norm(), 2852491 + 404 + 2646654 + 397, 1e-1);
}
 

import htsjdk.samtools.metrics.MetricsFile; //导入依赖的package包/类
/**
 * Gets the accumulated statistics for barcodes match/mismatch.
 *
 * Note: calling this method recomputes the percentage every time.
 *
 * @see MatcherStat
 */
public MetricsFile<MatcherStat, Integer> getMatcherStatMetrics() {
    // create the matcher stats
    final MetricsFile<MatcherStat, Integer> matcherStats = new MetricsFile<>();
    // add the header and the metrics
    matcherStats.addHeader(metricHeader);

    // update the percentage value
    final double total = stats.values().stream().mapToInt(i -> i.RECORDS).sum();
    // for each value, set the percentage and add the metric
    stats.values().forEach(ms -> {
        ms.PCT_RECORDS = 100d * ms.RECORDS / total;
        matcherStats.addMetric(ms);
    });
    return matcherStats;
}
 

import htsjdk.samtools.metrics.MetricsFile; //导入依赖的package包/类
/**
 * Gets the accumulated statistics for each barcode.
 *
 * @see BarcodeStat
 */
public MetricsFile<BarcodeStat, Integer> getBarcodeStatMetrics() {
    // create the barcode stats
    final MetricsFile<BarcodeStat, Integer> barcode = new MetricsFile<>();
    for (int i = 0; i < dictionary.getNumberOfBarcodes(); i++) {
        final Map<String, BarcodeStat> current = barcodeStats.get(i);
        for (final Map.Entry<String, Histogram<Integer>> entry : mismatchesHist.get(i)
                .entrySet()) {
            final BarcodeStat s = current.get(entry.getKey());
            s.MEAN_MISMATCH = entry.getValue().getMean();
            s.MEAN_N = nMean.get(i).get(entry.getKey()).mean();
            barcode.addHistogram(entry.getValue());
        }
        barcode.addAllMetrics(current.values());
    }
    return barcode;
}
 

import htsjdk.samtools.metrics.MetricsFile; //导入依赖的package包/类
/**
 * Prints the statistics for each barcode into a metrics file and logs the number of records
 * per barcode.
 */
@Override
public Object onTraversalSuccess() {
    // TODO: maybe we should create a metric file per statistic
    final Path path = outputBamArgumentCollection.makeMetricsFile(null);
    try (final Writer metricsWriter = Files.newBufferedWriter(path)) {
        // trimer metrics with the header
        final MetricsFile<TrimmerMetric, Integer> trimming = getMetricsFile();
        trimming.addAllMetrics(pipeline.getTrimmingStats());
        trimming.write(metricsWriter);

        // filter metrics with histogram without header
        final MetricsFile<FilterMetric, Integer> filtering = new MetricsFile<>();
        filtering.addAllMetrics(pipeline.getFilterStats());
        lengthHistogramsBeforeTrimming.forEach(filtering::addHistogram);
        lengthHistogramsAfterTrimming.forEach(filtering::addHistogram);
        filtering.write(metricsWriter);

    } catch (IOException e) {
        throw new UserException.CouldNotCreateOutputFile(path.toString(), e.getMessage(), e);
    }
    return null;
}
 

import htsjdk.samtools.metrics.MetricsFile; //导入依赖的package包/类
@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
    }
}
 

import htsjdk.samtools.metrics.MetricsFile; //导入依赖的package包/类
/**
 * Handles completion of metric collection. Metrics are computed from counts of data and written out to a file.
 */
private void onComplete() {
    try {
        final MetricsFile<IlluminaBasecallingMetrics, Comparable<?>> file = getMetricsFile();
        final IlluminaMetricCounts allLaneCounts = new IlluminaMetricCounts(null, null, LANE);
        for (final String s : barcodeToMetricCounts.keySet()) {
            final IlluminaMetricCounts counts = barcodeToMetricCounts.get(s);
            counts.addMetricsToFile(file);
            allLaneCounts.addIlluminaMetricCounts(counts);
        }
        if (!barcodeToMetricCounts.keySet().contains("")) {
            allLaneCounts.addMetricsToFile(file);  // detect non-indexed case
        }
        file.write(OUTPUT);
    } catch (final Exception ex) {
        throw new PicardException("Error writing output file " + OUTPUT.getPath(), ex);
    }
}
 

import htsjdk.samtools.metrics.MetricsFile; //导入依赖的package包/类
/**
* Outputs the detailed statistics tables for SNP and Indel match categories.
**/
public static void outputDetailMetricsFile(final VariantContext.Type variantType, final MetricsFile<GenotypeConcordanceDetailMetrics,?> genotypeConcordanceDetailMetricsFile,
                                           final GenotypeConcordanceCounts counter, final String truthSampleName, final String callSampleName,
                                           final boolean missingSitesHomRef, final boolean outputAllRows) {
    final GenotypeConcordanceSchemeFactory schemeFactory = new GenotypeConcordanceSchemeFactory();
    final GenotypeConcordanceScheme scheme = schemeFactory.getScheme(missingSitesHomRef);
    scheme.validateScheme();
    for (final TruthState truthState : TruthState.values()) {
        for (final CallState callState : CallState.values()) {
            final long count = counter.getCount(truthState, callState);
            final String contingencyValues = scheme.getContingencyStateString(truthState, callState);
            if (count > 0 || outputAllRows) {
                final GenotypeConcordanceDetailMetrics detailMetrics = new GenotypeConcordanceDetailMetrics();
                detailMetrics.VARIANT_TYPE = variantType;
                detailMetrics.TRUTH_SAMPLE = truthSampleName;
                detailMetrics.CALL_SAMPLE = callSampleName;
                detailMetrics.TRUTH_STATE = truthState;
                detailMetrics.CALL_STATE = callState;
                detailMetrics.COUNT = count;
                detailMetrics.CONTINGENCY_VALUES = contingencyValues;
                genotypeConcordanceDetailMetricsFile.addMetric(detailMetrics);
            }
        }
    }
}
 

import htsjdk.samtools.metrics.MetricsFile; //导入依赖的package包/类
@Override
protected int doWork() {
    IOUtil.assertFileIsReadable(INPUT);
    if(OUTPUT != null) IOUtil.assertFileIsWritable(OUTPUT);

    final MetricsFile<CrosscheckMetric, ?> metricsFile = getMetricsFile();

    try {
        metricsFile.read(new FileReader(INPUT));
    } catch (FileNotFoundException e) {
        e.printStackTrace();
        return 1;
    }

    clusterMetrics(metricsFile.getMetrics()).write(OUTPUT);

    return 0;
}
 

import htsjdk.samtools.metrics.MetricsFile; //导入依赖的package包/类
@Override
protected void finish() {
    final MetricsFile<BaseDistributionByCycleMetrics, ?> metrics = getMetricsFile();
    hist.addToMetricsFile(metrics);
    metrics.write(OUTPUT);
    if (hist.isEmpty()) {
        log.warn("No valid bases found in input file. No plot will be produced.");
    } else {
        final int rResult = RExecutor.executeFromClasspath("picard/analysis/baseDistributionByCycle.R",
                OUTPUT.getAbsolutePath(),
                CHART_OUTPUT.getAbsolutePath(),
                INPUT.getName(),
                plotSubtitle);
        if (rResult != 0) {
            throw new PicardException("R script nucleotideDistributionByCycle.R failed with return code " + rResult);
        }
    }
}
 

import htsjdk.samtools.metrics.MetricsFile; //导入依赖的package包/类
protected void saveResults(final MetricsFile<?, Integer> metrics, final SAMFileHeader readsHeader, final String inputFileName) {
    MetricsUtils.saveMetrics(metrics, out);

    if (metrics.getAllHistograms().isEmpty()) {
        logger.warn("No valid bases found in input file.");
    } else if (chartOutput != null) {
        // Now run R to generate a chart

        // If we're working with a single library, assign that library's name
        // as a suffix to the plot title
        final List<SAMReadGroupRecord> readGroups = readsHeader.getReadGroups();

        /*
         * A subtitle for the plot, usually corresponding to a library.
         */
        String plotSubtitle = "";
        if (readGroups.size() == 1) {
            plotSubtitle = StringUtil.asEmptyIfNull(readGroups.get(0).getLibrary());
        }
        final RScriptExecutor executor = new RScriptExecutor();
        executor.addScript(getBaseDistributionByCycleRScriptResource());
        executor.addArgs(out, chartOutput.getAbsolutePath(), inputFileName, plotSubtitle);
        executor.exec();
    }
}
 

import htsjdk.samtools.metrics.MetricsFile; //导入依赖的package包/类
private void writeResultsToFiles() {
    final MetricsFile<GcBiasMetrics, Integer> file = getMetricsFile();
    final MetricsFile<GcBiasDetailMetrics, ?> detailMetricsFile = getMetricsFile();
    final MetricsFile<GcBiasSummaryMetrics, ?> summaryMetricsFile = getMetricsFile();
    multiCollector.addAllLevelsToFile(file);
    final List<GcBiasMetrics> gcBiasMetricsList = file.getMetrics();
    for (final GcBiasMetrics gcbm : gcBiasMetricsList) {
        final List<GcBiasDetailMetrics> gcDetailList = gcbm.DETAILS.getMetrics();
        for (final GcBiasDetailMetrics d : gcDetailList) {
            detailMetricsFile.addMetric(d);
        }
        summaryMetricsFile.addMetric(gcbm.SUMMARY);
    }
    detailMetricsFile.write(OUTPUT);
    summaryMetricsFile.write(SUMMARY_OUTPUT);

    final NumberFormat fmt = NumberFormat.getIntegerInstance();
    fmt.setGroupingUsed(true);
    RExecutor.executeFromClasspath(R_SCRIPT,
            OUTPUT.getAbsolutePath(),
            SUMMARY_OUTPUT.getAbsolutePath(),
            CHART_OUTPUT.getAbsolutePath(),
            String.valueOf(SCAN_WINDOW_SIZE));
}
 

import htsjdk.samtools.metrics.MetricsFile; //导入依赖的package包/类
@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;
}
 

import htsjdk.samtools.metrics.MetricsFile; //导入依赖的package包/类
@Test
public void testChimeras() throws IOException {
    final File input = new File(TEST_DATA_DIR, "summary_alignment_stats_test_chimeras.sam");
    final File reference = new File(TEST_DATA_DIR, "summary_alignment_stats_test.fasta");
    final File outfile   = File.createTempFile("alignmentMetrics", ".txt");
    outfile.deleteOnExit();
    final String[] args = new String[] {
            "INPUT="  + input.getAbsolutePath(),
            "OUTPUT=" + outfile.getAbsolutePath(),
            "MAX_INSERT_SIZE=20",
            "REFERENCE_SEQUENCE=" + reference.getAbsolutePath(),
    };
    Assert.assertEquals(runPicardCommandLine(args), 0);

    final MetricsFile<AlignmentSummaryMetrics, Comparable<?>> output = new MetricsFile<>();
    output.read(new FileReader(outfile));

    for (final AlignmentSummaryMetrics metrics : output.getMetrics()) {
        if (metrics.CATEGORY == AlignmentSummaryMetrics.Category.FIRST_OF_PAIR) {
            TestNGUtil.compareDoubleWithAccuracy(metrics.PCT_CHIMERAS, 5D / 6, 0.0001);
        }
        if (metrics.CATEGORY == AlignmentSummaryMetrics.Category.SECOND_OF_PAIR) {
            TestNGUtil.compareDoubleWithAccuracy(metrics.PCT_CHIMERAS, 3D / 6, 0.0001);
        }
    }
}
 

import htsjdk.samtools.metrics.MetricsFile; //导入依赖的package包/类
@Override
protected void finish() {
    // Generate a "Histogram" of mean quality and write it to the file
    final MetricsFile<?,Integer> metrics = getMetricsFile();
    metrics.addHistogram(q.getMeanQualityHistogram());
    if (!oq.isEmpty()) metrics.addHistogram(oq.getMeanQualityHistogram());
    metrics.write(OUTPUT);

    if (q.isEmpty() && oq.isEmpty()) {
        log.warn("No valid bases found in input file. No plot will be produced.");
    }
    else {
        // Now run R to generate a chart
        final int rResult = RExecutor.executeFromClasspath(
                "picard/analysis/meanQualityByCycle.R",
                OUTPUT.getAbsolutePath(),
                CHART_OUTPUT.getAbsolutePath(),
                INPUT.getName(),
                plotSubtitle);

        if (rResult != 0) {
            throw new PicardException("R script meanQualityByCycle.R failed with return code " + rResult);
        }
    }
}
 

import htsjdk.samtools.metrics.MetricsFile; //导入依赖的package包/类
/**
 * Saves the metrics to a file.
 * Note: the SamFileHeader is needed in order to include libraries that didn't have any duplicates.
 * @param result metrics object, potentially pre-initialized with headers,
 */
public static void saveMetricsRDD(final MetricsFile<DuplicationMetrics, Double> result, final SAMFileHeader header, final JavaPairRDD<String, DuplicationMetrics> metricsRDD, final String metricsOutputPath) {
    final LibraryIdGenerator libraryIdGenerator = new LibraryIdGenerator(header);

    final Map<String, DuplicationMetrics> nonEmptyMetricsByLibrary = metricsRDD.collectAsMap();           //Unknown Library
    final Map<String, DuplicationMetrics> emptyMapByLibrary = libraryIdGenerator.getMetricsByLibraryMap();//with null

    final List<String> sortedListOfLibraryNames = new ArrayList<>(Sets.union(emptyMapByLibrary.keySet(), nonEmptyMetricsByLibrary.keySet()));
    sortedListOfLibraryNames.sort(Utils.COMPARE_STRINGS_NULLS_FIRST);
    for (final String library : sortedListOfLibraryNames){
        //if a non-empty exists, take it, otherwise take from the the empties. This is done to include libraries with zero data in them.
        //But not all libraries are listed in the header (esp in testing data) so we union empty and non-empty
        final DuplicationMetrics metricsToAdd = nonEmptyMetricsByLibrary.containsKey(library) ? nonEmptyMetricsByLibrary.get(library) : emptyMapByLibrary.get(library);
        metricsToAdd.calculateDerivedMetrics();
        result.addMetric(metricsToAdd);
    }

    if (nonEmptyMetricsByLibrary.size() == 1) {
        result.setHistogram(nonEmptyMetricsByLibrary.values().iterator().next().calculateRoiHistogram());
    }

    MetricsUtils.saveMetrics(result, metricsOutputPath);
}
 

import htsjdk.samtools.metrics.MetricsFile; //导入依赖的package包/类
@Test(dataProvider = "metricsPaths", groups = "bucket")
public void testSaveMetrics(String destinationPrefix) throws IOException {
    final String outputPath = BucketUtils.getTempFilePath(destinationPrefix, ".txt");
    TestMetric testMetric = new TestMetric();
    testMetric.value1 = 10;
    testMetric.value2 = 5;

    final MetricsFile<TestMetric, ?> metrics = new MetricsFile<>();
    metrics.addMetric(testMetric);
    MetricsUtils.saveMetrics(metrics, outputPath);
    Assert.assertTrue(BucketUtils.fileExists(outputPath));
    File localCopy = copyFileToLocalTmpFile(outputPath);

    final File expectedMetrics = createTempFile("expectedMetrics", ".txt");
    metrics.write(expectedMetrics);

    Assert.assertTrue(MetricsFile.areMetricsEqual(localCopy, expectedMetrics));
}
 

import htsjdk.samtools.metrics.MetricsFile; //导入依赖的package包/类
private void saveResults(final MetricsFile<?, Integer> metrics, final SAMFileHeader readsHeader, final String inputFileName){
    MetricsUtils.saveMetrics(metrics, out);

    if (metrics.getAllHistograms().isEmpty()) {
        logger.warn("No valid bases found in input file.");
    } else if (chartOutput != null){
        // Now run R to generate a chart

        // If we're working with a single library, assign that library's name
        // as a suffix to the plot title
        final List<SAMReadGroupRecord> readGroups = readsHeader.getReadGroups();

        /*
         * A subtitle for the plot, usually corresponding to a library.
         */
        String plotSubtitle = "";
        if (readGroups.size() == 1) {
            plotSubtitle = StringUtil.asEmptyIfNull(readGroups.get(0).getLibrary());
        }
        final RScriptExecutor executor = new RScriptExecutor();
        executor.addScript(getMeanQualityByCycleRScriptResource());
        executor.addArgs(out, chartOutput.getAbsolutePath(), inputFileName, plotSubtitle);
        executor.exec();
    }
}
 

import htsjdk.samtools.metrics.MetricsFile; //导入依赖的package包/类
@Test
public void testNoLocsSymlink() throws Exception {
    final File metricsFile = File.createTempFile("dual.", ".metrics");
    metricsFile.deleteOnExit();

    final String[] args = new String[]{
            "BASECALLS_DIR=" + noSymlink.getAbsolutePath(),
            "LANE=" + 1,
            "METRICS_FILE=" + metricsFile,
            "READ_STRUCTURE=" + "25T8B8B25T",
            "BARCODE=" + "CAATAGTCCGACTCTC"
    };

    Assert.assertEquals(runPicardCommandLine(args), 0);
    final MetricsFile<ExtractIlluminaBarcodes.BarcodeMetric, Integer> result = new MetricsFile<>();
    result.read(new FileReader(metricsFile));
    Assert.assertEquals(result.getMetrics().get(0).PERFECT_MATCHES, 2, "Got wrong number of perfect matches");
    Assert.assertEquals(result.getMetrics().get(0).ONE_MISMATCH_MATCHES, 0, "Got wrong number of one-mismatch matches");
}
 

import htsjdk.samtools.metrics.MetricsFile; //导入依赖的package包/类
private MetricsFile<ExtractIlluminaBarcodes.BarcodeMetric, Integer> runIt(final int lane, final String readStructure)
        throws Exception {
    final File metricsFile = File.createTempFile("eib.", ".metrics");
    metricsFile.deleteOnExit();

    final List<String> args = new ArrayList<>(Arrays.asList(
            "BASECALLS_DIR=" + basecallsDir.getPath(),
            "LANE=" + lane,
            "READ_STRUCTURE=" + readStructure,
            "METRICS_FILE=" + metricsFile.getPath()
    ));
    for (final String barcode : BARCODES) {
        args.add("BARCODE=" + barcode);
    }
    return runIt(args, metricsFile);
}