htsjdk.samtools.metrics.Header Java Examples

@Override
public MetricsCollectorSpark<? extends MetricsArgumentCollection> createCollector(
        final String outputBaseName,
        final Set<MetricAccumulationLevel> metricAccumulationLevel,
        final List<Header> defaultHeaders,
        final SAMFileHeader samHeader)
{
    // disambiguate this collector's output files from the other collectors
    final String localBaseName = outputBaseName + "." + QualityYieldMetrics.getUniqueNameSuffix();

    final QualityYieldMetricsArgumentCollection qyArgs = new QualityYieldMetricsArgumentCollection();
    qyArgs.output = localBaseName + ".txt";

    final QualityYieldMetricsCollectorSpark collector = new QualityYieldMetricsCollectorSpark();
    collector.initialize(qyArgs, samHeader, defaultHeaders);

    return collector;
}
 

@Override
public MetricsCollectorSpark<? extends MetricsArgumentCollection> createCollector(
        final String outputBaseName,
        final Set<MetricAccumulationLevel> metricAccumulationLevel,
        final List<Header> defaultHeaders,
        final SAMFileHeader samHeader)
{
    // disambiguate this collector's output files from the other collectors
    final String localBaseName = outputBaseName + "." + InsertSizeMetrics.getUniqueNameSuffix();

    final InsertSizeMetricsArgumentCollection isArgs = new InsertSizeMetricsArgumentCollection();
    isArgs.output = localBaseName + ".txt";
    isArgs.histogramPlotFile = localBaseName + ".pdf";
    isArgs.metricAccumulationLevel.accumulationLevels = metricAccumulationLevel;

    final InsertSizeMetricsCollectorSpark collector = new InsertSizeMetricsCollectorSpark();
    collector.initialize(isArgs, samHeader, defaultHeaders);

    return collector;
}
 

/**
 * For each collector type, provide a type-safe, collector-specific method
 * that creates and populates an instance of the  collector's input argument
 * class; creates an instance of the collector; initializes the collector
 * with the arguments, and returns the initialized collector.
 */
MetricsCollectorSpark<? extends MetricsArgumentCollection> createCollector(
        final String outputBaseName,
        final Set<MetricAccumulationLevel> metricAccumulationLevel,
        final List<Header> defaultHeaders,
        final SAMFileHeader samHeader
);
 

@Test(dataProvider="metricsTestFiles", groups = "spark")
public void testCustomCollectorAPI(
    final String fileName,
    final String referenceName,
    final String expectedInsertSizeResults,
    final String expectedQualityYieldResults) throws IOException
{
    // Test CollectMultipleMetricsSpark with a custom collector
    final TestCustomCollector testCollector = new TestCustomCollector();

    ArgumentsBuilder args = new ArgumentsBuilder();
    setupMultipleCollector(args, fileName, referenceName);

    // CollectMultipleMetricsSpark provider that creates an initializes a custom
    // collector
    CollectMultipleMetricsSpark.SparkCollectorProvider customProvider =
        new CollectMultipleMetricsSpark.SparkCollectorProvider() {
            @Override
            public MetricsCollectorSpark<? extends MetricsArgumentCollection> createCollector(
                final String outputBaseName,
                final Set<MetricAccumulationLevel> metricAccumulationLevel,
                final List<Header> defaultHeaders,
                final SAMFileHeader samHeader)
            {
                return testCollector;
            }
    };

    // Manually create a tool and programmatically set the custome collector as the one
    // to run
    CollectMultipleMetricsSpark multipleCollectorTool = new CollectMultipleMetricsSpark();
    multipleCollectorTool.setCollectorsToRun(Collections.singletonList(customProvider));
    multipleCollectorTool.instanceMain(args.getArgsArray());

    Assert.assertEquals(testCollector.count, 52L);
}
 

/** 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;
}
 

/**
 * Initialize the collector with input arguments;
 */
@Override
public void initialize(
        final InsertSizeMetricsArgumentCollection inputArgs,
        final SAMFileHeader samHeader,
        final List<Header> defaultHeaders)
{
    this.inputArgs = inputArgs;
    collector.initialize(inputArgs, samHeader);
    metricsFile = new MetricsFile<>();
    if (defaultHeaders != null) {
        defaultHeaders.stream().forEach(h -> metricsFile.addHeader(h));
    }
}
 

/**
 * Initialize the collector with input arguments;
 */
@Override
public void initialize(
        final QualityYieldMetricsArgumentCollection inputArgs,
        final SAMFileHeader samHeader,
        final List<Header> defaultHeaders) {
    metricsFile = new MetricsFile<QualityYieldMetrics, Integer>();
    defaultHeaders.stream().forEach(h -> metricsFile.addHeader(h));
    this.args = inputArgs;
}
 

@Override
protected void initialize(
        final InsertSizeMetricsArgumentCollection inputArgs,
        final SAMFileHeader samHeader,
        final List<Header> defaultHeaders)
{
    insertSizeCollector.initialize(inputArgs, samHeader, defaultHeaders);
}
 

public static Header getMergedMetricsHeader(List<File> inputMetricsList, File outputMetrics) {
    List<String> header = new ArrayList<>();
    for (File file : inputMetricsList)
        header.add("INPUT="+ file.getAbsolutePath());
    header.add("OUTPUT="+ outputMetrics.getAbsolutePath());

    return new StringHeader(StringUtils.join(header, "\t"));
}
 

@Override
protected void initialize(
        final QualityYieldMetricsArgumentCollection inputArgs,
        final SAMFileHeader samHeader,
        final List<Header> defaultHeaders) {
    qualityYieldCollector.initialize(inputArgs, samHeader, defaultHeaders);
}
 

/**
 * Initialize the collector with input arguments.
 */
@Override
public void initialize(
        final ExampleMultiMetricsArgumentCollection inputArgs,
        final SAMFileHeader samHeader,
        final List<Header> defaultHeaders)
{
    this.inputArgs = inputArgs;
    collector.initialize(inputArgs, samHeader);
    metricsFile = new MetricsFile<>();
    if (defaultHeaders != null) {
        defaultHeaders.stream().forEach(h -> metricsFile.addHeader(h));
    }
}
 

/**
 * Initialize the collector with it's input arguments.
 *
 * @param inputArgs The input arguments for this collector. The {@link MetricsCollectorSparkTool} base class
 *                  will have previously obtained these through a call to {@link #getInputArguments},
 *                  and passes them back here to be forwarded to the embedded collector.
 * @param samHeader SAMFileHeader for the input
 * @param defaultHeaders Default headers for this tool to optionally be used in any resulting metrics file.
 */
@Override
protected void initialize(
        final ExampleSingleMetricsArgumentCollection inputArgs,
        final SAMFileHeader samHeader,
        final List<Header> defaultHeaders)
{
    // Initialize the collector with it's input arguments
    exampleSingleCollector.initialize(inputArgs, samHeader, defaultHeaders);
}
 

/**
 * Initialize the collector with input arguments;
 */
@Override
public void initialize(
        final ExampleSingleMetricsArgumentCollection inputArgs,
        final SAMFileHeader samHeader,
        final List<Header> defaultHeaders) {
    metricsFile = new MetricsFile<ExampleSingleMetrics, Integer>();
    defaultHeaders.stream().forEach(h -> metricsFile.addHeader(h));
    this.args = inputArgs;
}
 

/** 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;
}
 

public void writeReport(final File output, final List<Header> headers) {
    final MetricsFile<SamComparisonMetric, ?> comparisonMetricFile = new MetricsFile<>();

    headers.forEach(comparisonMetricFile::addHeader);
    comparisonMetricFile.addAllMetrics(Collections.singletonList(comparisonMetric));
    comparisonMetricFile.write(output);
}
 

public List<Header> getDefaultHeaders() {
    return this.defaultHeaders;
}
 

public void setDefaultHeaders(final List<Header> headers) {
    this.defaultHeaders.clear();
    this.defaultHeaders.addAll(headers);
}
 

/**
 * Replaces the set of default metrics headers by the given argument.
 * The given list is copied.
 */
public final void setDefaultHeaders(final List<Header> headers) {
    Utils.nonNull(headers);
    this.defaultHeaders.clear();
    this.defaultHeaders.addAll(headers);
}
 

/**
 * Returns the (live) list of default metrics headers used by this tool.
 */
public final List<Header> getDefaultHeaders() {
    return this.defaultHeaders;
}
 

@Override
public void initialize(
        MetricsArgumentCollection inputArgs, SAMFileHeader samHeader, List<Header> defaultHeaders) {}
 

/**
 * Initialize the collector with it's input arguments.
 *
 * @param inputArgs The input arguments for this collector. The {@link MetricsCollectorSparkTool} base class
 *                  will have previously obtained these through a call to {@link #getInputArguments},
 *                  and passes them back here to be forwarded to the embedded collector.
 * @param samHeader SAMFileHeader for the input
 * @param defaultHeaders Default headers for this tool to optionally be used in any resulting metrics file.
 */
@Override
protected void initialize(
        final ExampleMultiMetricsArgumentCollection inputArgs,
        final SAMFileHeader samHeader,
        final List<Header> defaultHeaders)
{
    exampleMultiCollector.initialize(inputArgs, samHeader, defaultHeaders);
}
 

/**
 * Give the collector's input arguments to the collector (if the collector
 * is being driven by a standalone tool. This method will always be called
 * before either getReadFilter (so the collector can use the arguments to
 * initialize the readFilter) or collectMetrics.
 * @param inputArgs an object that contains the argument values to be used for
 *                  the collector
 * @param samHeader the SAMFileHeader for the input
 * @param defaultMetricsHeaders default metrics headers from the containing tool
 */
void initialize(T inputArgs, SAMFileHeader samHeader, List<Header> defaultMetricsHeaders);
 

abstract protected void initialize(T inputArgs, SAMFileHeader samHeader, List<Header> defaultHeaders);