All Classes

Class for parsing text files where each line consists of fields separated by whitespace.

Little class used to package up a header and an iterable/iterator.

Class for collecting data on reference coverage, base qualities and excluded bases from one AbstractLocusInfo object for CollectWgsMetrics.

Store one or more AdapterPairs to use to mark adapter sequence of SAMRecords.

A utility class for matching reads to adapters.

High level metrics about the alignment of reads within a SAM file, produced by the CollectAlignmentSummaryMetrics program and usually stored in a file with the extension ".alignment_summary_metrics".

Utilities class containing methods for restricting VariantContext and GenotypesContext objects to a reduced set of alleles, as well as for choosing the best set of alleles to keep and for cleaning up annotations and genotypes after subsetting.

A simple class to store names and counts for the the Control Information fields that are stored in an Illumina GTC file.

Describes

Set of possible design strategies for bait design.

Converts a BAM file into a BFQ (binary fastq formatted) file.

A class for finding the distance between multiple (matched) barcodes and multiple barcode reads.

Reads a single barcode file line by line and returns the barcode if there was a match or NULL otherwise.

An interface that can take a collection of bases (provided as SamLocusIterator.RecordAndOffset and SamLocusAndReferenceIterator.SAMLocusAndReference) and generates a ErrorMetric from them.

Parse various formats and versions of Illumina Basecall files, and use them the to populate ClusterData objects.

Created by jcarey on 3/14/14.

Describes a mechanism for revising and evaluating qualities read from a BCL file.

This strategy was designed for TopHat output, but could be of general utility.

A class to represent an 'Extended' Illumina Manifest file.

Takes a VCFFileReader and an IntervalList and provides a single iterator over all variants in all the intervals.

A read name encoder conforming to the standard described by Illumina Casava 1.8.

------------------------------------- CBCL Header ----------------------------------- Bytes 0 - 1 Version number, current version is 1 unsigned 16 bits little endian integer Bytes 2 - 5 Header size unsigned 32 bits little endian integer Byte 6 Number of bits per basecall unsigned Byte 7 Number of bits per q-score unsigned

Program to check a lane of an Illumina output directory.

Utility class that can scan for classes in the classpath and find all the ones annotated with a particular annotation.

Utilities to clip the adapter sequence from a SAMRecord read

The clocs file format is one of 3 Illumina formats(pos, locs, and clocs) that stores position data exclusively.

Store the information from Illumina files for a single cluster with one or more reads.

A metric class to hold the result of ClusterCrosscheckMetrics fingerprints.

Collect DuplicateMark'ing metrics from an input file that was already Duplicate-Marked.

Collect metrics regarding the reason for reads (sequenced by HiSeqX) not passing the Illumina PF Filter.

Metrics produced by the GetHiSeqXPFFailMetrics program.

A Command line tool to collect Illumina Basecalling metrics for a sequencing run Requires a Lane and an input file of Barcodes to expect.

Utility for collating Tile records from the Illumina TileMetrics file into lane-level and phasing-level metrics.

Command line program to read non-duplicate insert sizes, create a Histogram and report distribution statistics.

Class that is designed to instantiate and execute multiple metrics programs that extend SinglePassSamProgram while making only a single pass through the SAM file and supplying each program with the records as it goes.

Metrics class for outputs.

A set of metrics used to describe the general quality of a BAM file

Computes a number of metrics that are useful for evaluating coverage and performance of whole genome sequencing experiments, same implementation as CollectWgsMetrics, with different defaults: lacks baseQ and mappingQ filters and has much higher coverage cap.

Quantify substitution errors caused by mismatched base pairings during various stages of sample / library prep.

This tool calculates a set of PCR-related metrics from an aligned SAM or BAM file containing targeted sequencing data.

A collection of metrics relating to snps and indels within a variant-calling file (VCF) for a given sample.

Computes a number of metrics that are useful for evaluating coverage and performance of whole genome sequencing experiments.

Metrics for evaluating the performance of whole genome sequencing experiments.

A simple program to combine multiple genotyping array VCFs into one VCF The input VCFs must have the same sequence dictionary and same list of variant loci.

Abstract class to facilitate writing command-line programs.

A simple tool to compare two Illumina GTC files.

Rudimentary SAM comparer.

Class for managing a list of Counters of integer, provides methods to access data from Counters with respect to an offset.

Counting filter that discards reads that have been marked as duplicates.

Counting filter that discards reads below a configurable mapping quality threshold.

Create a SAM/BAM file from a fasta containing reference sequence.

A simple program to create a standard picard metrics file from the output of VerifyIDIntensity

A class to hold the result of crosschecking fingerprints.

Little tuple class to contain one bitset for SNPs and another for Indels.

Filters out a record if all variant samples have depth lower than the given value.

A genotype produced by one of the concrete implementations of AbstractAlleleCaller.

Disk-based implementation of ReadEndsForMarkDuplicatesMap.

Summary

When it is necessary to pick a primary alignment from a group of alignments for a read, pick the one that maps the earliest base in the read.

Created by farjoun on 6/26/18.

Attempts to estimate library complexity from sequence alone.

Determine the barcode for each read in an Illumina lane.

Extracts barcodes and accumulates metrics for an entire tile.

Simple command line program that allows sub-sequences represented by an interval list to be extracted from a reference sequence file.

Class represents fast algorithm for collecting data from AbstractLocusInfo with a list of aligned EdgingRecordAndOffset objects.

Created by jcarey on 3/13/14.

Summary

Applies a set of hard filters to Variants and to Genotypes within a VCF.

class to represent a genetic fingerprint as a set of HaplotypeProbabilities objects that give the relative probabilities of each of the possible haplotypes at a locus.

class to hold the details of a element of fingerprinting PU tag

Summary fingerprinting metrics and statistics about the comparison of the sequence data from a single read group (lane or index within a lane) vs.

Class that is used to represent the results of comparing a read group within a SAM file, or a sample within a VCF against one or more set of fingerprint genotypes.

A class that holds VariantContexts sorted by genomic position

Summary

Holds a 4 short values for each cycle of a read.

The default scheme is derived from the GA4GH Benchmarking Work Group's proposed evaluation scheme.

Simple little class that combines multiple VCFs that have exactly the same set of samples and totally discrete sets of loci.

High level metrics that capture how biased the coverage in a certain lane is.

Holds annotation of a gene for storage in an OverlapDetector.

Summary

Class that holds metrics about the Genotype Concordance contingency tables.

Class that holds detail metrics about Genotype Concordance

Created by kbergin on 6/19/15.

A class to store the various classifications for: 1.

A specific state for a 2x2 contingency table.

These states represent the relationship between a truth genotype and the reference sequence.

An interface for classes that perform Genotype filtration.

Miscellaneous tools, e.g.

An accumulator for collecting metrics about a single-sample GVCF.

A collection of metadata about Haplotype Blocks including multiple in memory "indices" of the data to make it easy to query the correct HaplotypeBlock or Snp by snp names, positions etc.

Log10(P(evidence| haplotype)) for the 3 different possible haplotypes {aa, ab, bb}

Represents a set of HaplotypeProbabilities that were derived from a single SNP genotype at a point in time.

Represents the probability of the underlying haplotype given the data.

Metrics generated by CollectHsMetrics for the analysis of target-capture sequencing experiments.

A class to encompass writing an Illumina adpc.bin file.

Metric for Illumina Basecalling that stores means and standard deviations on a per-barcode per-lane basis.

IlluminaBasecallsToSam transforms a lane of Illumina data file formats (bcl, locs, clocs, qseqs, etc.) into SAM or BAM file format.

A simple class to represent a locus entry in an Illumina Bead Pool Manifest (BPM) file

IlluminaDataProviderFactory accepts options for parsing Illumina data files for a lane and creates an IlluminaDataProvider, an iterator over the ClusterData for that lane, which utilizes these options.

General utils for dealing with IlluminaFiles as well as utils for specific, support formats.

A class to represent an Illumina Manifest file.

Metrics for Illumina Basecalling that stores median phasing and prephasing percentages on a per-template-read, per-lane basis.

Misc utilities for working with Illumina specific files and data

A calculator that estimates the error rate of the bases it observes for indels only.

A class to store information relevant for biological rate estimation

A class to parse the contents of an Illumina Infinium cluster (EGT) file A cluster file contains information about the clustering information used in mapping red / green intensity information to genotype calls

A class to parse the contents of an Illumina Infinium genotype (GTC) file A GTC file is the output of Illumina's genotype calling software (either Autocall or Autoconvert) and contains genotype calls, confidence scores, basecalls and raw intensities for all calls made on the chip.

A class to parse the contents of an Illumina Infinium Normalization Manifest file An Illumina Infinium Normalization Manifest file contains a subset of the information contained in the Illumina Manifest file in addition to the normalization ID which is needed for normalizating intensities in GtcToVcf

A class to store fields that are specific to a VCF generated from an Illumina GTC file.

Metrics about the insert size distribution of a paired-end library, created by the CollectInsertSizeMetrics program and usually written to a file with the extension ".insert_size_metrics".

The channels in a FourChannelIntensityData object, and the channels produced by a ClusterIntensityFileReader, for cases in which it is desirable to handle these abstractly rather than having the specific names in the source code.

a Baseclass for scatterers that scatter by uniqued base count.

A BaseCount Scatterer that avoid breaking-up intervals.

An IntervalListScatterer that attempts to place the same number of (uniquified) bases in each output interval list.

Trivially simple command line program to convert an IntervalList file to a BED file.

Helper class used to transform tile data for a lane into a collection of IlluminaPhasingMetrics

Liftover SNPs in HaplotypeMaps from one reference to another

Created by jcarey on 3/13/14.

Describes the behavior of a locus relative to a gene.

Creates a TSV from sample name to VCF/GVCF path, with one line per input.

Enum used to control how duplicates are flagged in the DT optional tag on each read.

An even better duplication marking algorithm that handles all cases including clipped and gapped alignments.

Command line program to mark the location of adapter sequences.

Represents the results of a fingerprint comparison between one dataset and a specific fingerprint file.

A collection of common math operations that work with log values.

Map from String to ReadEnds object.

Created by farjoun on 6/25/16.

Metrics whose values can be merged by adding.

Metrics that are merged manually in the MergeableMetricBase.merge(MergeableMetricBase) ()}.

Metrics that are not merged.

Class to take genotype calls from a ped file output from zCall and merge them into a vcf from autocall.

Combines multiple variant files into a single variant file.

MMapBackedIteratorFactory a file reader that takes a header size and a binary file, maps the file to a read-only byte buffer and provides methods to retrieve the header as it's own bytebuffer and create iterators of different data types over the values of file (starting after the end of the header).

MultiLevelCollector handles accumulating Metrics at different MetricAccumulationLevels(ALL_READS, SAMPLE, LIBRARY, READ_GROUP).

Created by jcarey on 3/13/14.

Parse .bcl.bgzf files that contain multiple tiles in a single file.

Read filter file that contains multiple tiles in a single file.

Read locs file that contains multiple tiles in a single file.

A tool to count the number of non-N bases in a fasta file

Contains methods for finding optical/co-localized/sequencing duplicates.

Miscellaneous tools, e.g.

In multiple locations we need to know what cycles are output, as of now we output all non-skip cycles, but rather than sprinkle this knowledge throughout the parser code, instead OutputMapping provides all the data a client might want about the cycles to be output including what ReadType they are.

A calculator that estimates the error rate of the bases it observes, assuming that the reference is truth.

An iterator that takes a pair of iterators over VariantContexts and iterates over them in tandem.

A base class for Metrics for targeted panels.

A class whose purpose is to initialize the various plugins that provide Path support.

Abstract base class for Parsers that open a single tile file at a time and iterate through them.

PerRecordCollector - An interface for classes that collect data in order to generate one or more metrics.

Small interface that provides access to the physical location information about a cluster.

This stores records that are comparable for detecting optical duplicates.

Small class that provides access to the physical location information about a cluster.

Basic Picard runtime exception that, for now, does nothing much

The Picard Documentation work unit handler class that is the companion to PicardHelpDoclet.

The pos file format is one 3 Illumina formats(pos, locs, and clocs) that stores position data exclusively.

PosParser parses multiple files formatted as one of the three file formats that contain position information only (pos, locs, and clocs).

It is useful to define a key such that the key will occur at most once among the primary alignments in a given file (assuming the file is valid).

Utility for loading properties files from resources.

Charts quality score distribution within a BAM file.

Classes, methods, and enums that deal with the stratification of read bases and reference information.

Stratifies according to the number of matching cigar operators (from CIGAR string) that the read has.

Types of consensus reads as determined by the number of duplicates used from first and second strands.

An enum designed to hold a binned version of any probability-like number (between 0 and 1) in quintiles

A stratifier that uses GC (of the read) to stratify.

Stratifies according to the number of indel bases (from CIGAR string) that the read has.

Stratify bases according to the type of Homopolymer that they belong to (repeating element, final reference base and whether the length is "long" or not).

Stratify by the number of Ns found in the read.

A PairStratifier is a stratifier that uses two other stratifiers to inform the stratification.

An enum for holding the direction for a read (positive strand or negative strand

The main interface for a stratifier.

Tools that manipulate read data in SAM, BAM or CRAM format

Little struct-like class to hold read pair (and fragment) end data for duplicate marking.

Codec for ReadEnds that just outputs the primitive fields and reads them back.

A class to store individual records for MarkDuplicatesWithMateCigar.

Provides access to the physical location information about a cluster.

A read type describes a stretch of cycles in an ReadStructure (e.g.

Tools that analyze and manipulate FASTA format references

Renames a sample within a VCF or BCF.

Codec for read names and integers that outputs the primitive fields and reads them back.

Argument collection for references that are required (and not common).

Used as a return for the canSkipSAMFile function.

Metrics about the alignment of RNA-seq reads within a SAM file to genes, produced by the CollectRnaSeqMetrics program and usually stored in a file with the extension ".rna_metrics".

Class that takes in a set of alignment information in SAM format and merges it with the set of all reads for which alignment was attempted, stored in an unmapped SAM file.

Metric for results of SamComparison.

Defines a MultilevelPerRecordCollector using the argument type of SAMRecord so that this doesn't have to be redefined for each subclass of MultilevelPerRecordCollector

Extracts read sequences and qualities from the input SAM/BAM file and writes them into the output file in Sanger FASTQ format.

A Tool for breaking up a reference into intervals of alternating regions of N and ACGT bases.

Class with helper methods for generating and writing SequenceDictionary objects.

Summary analysis of a single bait bias artifact, also known as a reference bias artifact.

Summary analysis of a single pre-adapter artifact.

Fixes the NM, MD, and UQ tags in a SAM or BAM file.

A calculator that estimates the error rate of the bases it observes, assuming that the reference is truth.

A class for finding the distance between a single barcode and a barcode-read (with base qualities)

Class to represent a SNP in context of a haplotype block that is used in fingerprinting.

Sorts one or more VCF files according to the order of the contigs in the header/sequence dictionary and then by coordinate.

Splits the input queryname sorted or query-grouped SAM/BAM file and writes it into multiple BAM files, each with an approximately equal number of reads.

A set of String constants in which the name of the constant (minus the _SHORT_NAME suffix) is the standard long Option name, and the value of the constant is the standard shortName.

Parse a tabbed text file in which columns are found by looking at a header line rather than by position.

Calculates HS metrics for a given SAM or BAM file.

TargetMetrics, are metrics to measure how well we hit specific targets (or baits) when using a targeted sequencing process like hybrid selection or Targeted PCR Techniques (TSCA).

A simple class that is used to store the coverage information about an interval.

For internal test purposes only.

Represents a tile from TileMetricsOut.bin.

Helper class which captures the combination of a lane, tile & metric code

Captures information about a phasing value - Which read it corresponds to, which phasing type and a median value

Enum representation of a transition from one base to any other.

This tool locates and tags duplicate reads in a BAM or SAM file, where duplicate reads are defined as originating from a single fragment of DNA.

Metrics that are calculated during the process of marking duplicates within a stream of SAMRecords using the UmiAwareDuplicateSetIterator.

Takes a VCF file and a Sequence Dictionary (from a variety of file types) and updates the Sequence Dictionary in VCF.

A VariantAccumulatorExecutor that breaks down work into chunks described by the provided VariantIteratorProducer and spreads them over the indicated number of threads.

Interface for classes that can generate filters for VariantContexts.

A mechanism for iterating over CloseableIterator of VariantContexts in in some fashion, given VCF files and optionally an interval list.

Describes an object that processes variants and produces a result.

Generates instances of VariantProcessor.Accumulators.

Takes a collection of results produced by VariantProcessor.Accumulator.result() and merges them into a single RESULT.

Describes a segment of a particular VCF file.

Converts an ASCII VCF file to a binary BCF or vice versa.

Converts a VCF or BCF file to a Picard Interval List.

Created by farjoun on 4/1/17.

Prints a SAM or BAM file to the screen.

Interface for processing data and generate result for CollectWgsMetrics