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

The scheme is defined in the constructor.

Concatenate efficiently BAM files that resulted from a scattered parallel analysis.

Class that holds detailed metrics about reads that fall within windows of a certain GC bin on the reference genome.

Calculates GC Bias Metrics on multiple levels Created by kbergin on 3/23/15.

Utilities to calculate GC Bias Created by kbergin on 9/23/15.

Load gene annotations into an OverlapDetector of Gene objects.

A simple structure to return the results of getAlleles.

A class to store the counts for various truth and call state classifications relative to a reference.

This defines for each valid TruthState and CallState tuple, the set of contingency table entries that to which the tuple should contribute.

Created by kbergin on 7/30/15.

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

A minute class to store the truth and call state respectively.

Class that holds summary metrics about Genotype Concordance

Genotype filter that filters out genotypes below a given quality threshold.

Created by farjoun on 11/2/16.

Class to convert an Illumina GTC file into a VCF file.

Represents information about a group of SNPs that form a haplotype in perfect LD with one another.

Abstract class for storing and calculating various likelihoods and probabilities for haplotype alleles given evidence.

Represents the probability of the underlying haplotype of the contaminating sample given the data.

Represents the likelihood of the HaplotypeBlock given the GenotypeLikelihoods (GL field from a VCF, which is actually a log10-likelihood) for each of the SNPs in that block.

A wrapper class for any HaplotypeProbabilities instance that will assume that the given evidence is that of a tumor sample and provide an hp for the normal sample that tumor came from.

Calculates HS metrics for a given SAM or BAM file.

Program to create a fingerprint for the contaminating sample when the level of contamination is both known and uniform in the genome.

Manages the conversion of Illumina basecalls into some output format.

Simple switch to control the read name format to emit.

A class to parse the contents of an Illumina Bead Pool Manifest (BPM) file A BPM file contains metadata (including the alleles, mapping and normalization information) on an Illumina Genotyping Array Each type of genotyping array has a specific BPM .

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

List of data types of interest when parsing Illumina data.

Embodies characteristics that describe a lane.

A class to represent a record (line) from an Illumina Manifest [Assay] entry

Illumina's TileMetricsOut.bin file codes various metrics, both concrete (all density id's are code 100) or as a base code (e.g.

A read name encoder following the encoding initially produced by picard fastq writers.

Describes adapters used on each pair of strands

Metric to be used for InDel errors

A class to provide methods for accessing Illumina Infinium Data Files.

A class to encapsulate the table of contents for an Illumina Infinium Data Files.

Collects InsertSizeMetrics on the specified accumulationLevels using

Base interface for an interval argument collection.

An interface for a class that scatters IntervalLists.

Scatters IntervalList by interval count so that resulting IntervalList's have the same number of intervals in them.

Like IntervalListScattererWithoutSubdivision but will overflow current list if the projected size of the remaining lists is bigger than the "ideal".

An enum to control the creation of the various IntervalListScatter objects

Performs various IntervalList manipulations.

Tools that process genomic intervals in various formats.

High level metrics about the presence of outward- and inward-facing pairs within a SAM file generated with a jumping library, produced by the CollectJumpingLibraryMetrics program and usually stored in a file with the extension ".jump_metrics".

A class to generate library Ids and keep duplication metrics by library IDs.

This tool adjusts the coordinates in an interval list on one reference to its homologous interval list on another reference, based on a chain file that describes the correspondence between the two references.

Summary

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

Creates a VCF that contains all the site-level information for all records in the input VCF but no genotype information.

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

Enum for the possible values that a duplicate read can be tagged with in the DT attribute.

This will iterate through a coordinate sorted SAM file (iterator) and either mark or remove duplicates as appropriate.

This is the mark queue.

General math utilities

Program to generate a data table and chart of mean quality by cycle from a BAM file.

Describes the type and number of mendelian violations found within a Trio.

An extension of MetricBase that knows how to merge-by-adding fields that are appropriately annotated (MergeByAdding).

Metrics whose values should be equal when merging.

Metrics that are not merged, but are subsequently derived from other metrics, for example by MergeableMetricBase.calculateDerivedFields().

Summary

This tool is used for combining SAM and/or BAM files from different runs or read groups into a single file, similar to the \"merge\" function of Samtools (http://www.htslib.org/doc/samtools.html).

For use with Picard metrics programs that may output metrics for multiple levels of aggregation with an analysis.

For a paired-end aligner that aligns each end independently, select the pair of alignments that result in the largest insert size.

NextSeq-style bcl's have all tiles for a cycle in a single file.

For file types for which there is one file per lane, with fixed record size, and all the tiles in it, so the s_.bci file can be used to figure out where each tile starts and ends.

Created by jcarey on 3/13/14.

Abstract class for files with fixed-length records for multiple tiles, e.g.

Parse cbcls Illumina Basecall files, and use them the to populate ClusterData objects.

Little program to "normalize" a fasta file to ensure that all line of sequence are the same length, and are a reasonable length!

Picard default argument collection for an optional reference.

Base interface for an output argument collection.

An error metric for the errors invovling bases in the overlapping region of a read-pair.

Simple Pair class.

Little class to hold a pair of VariantContexts that are in sync with one another.

Represents a .ped file of family information as documented here: http://pngu.mgh.harvard.edu/~purcell/plink/data.shtml Stores the information in memory as a map of individualId -> Pedigree information for that individual

Argument Collection which holds parameters common to classes that want to add PG tags to reads in SAM/BAM files

Stores the minimal information needed for optical duplicate detection.

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

This is the main class of Picard and is the way of executing individual command line programs.

Custom Barclay-based Javadoc Doclet used for generating Picard help/documentation.

Created by jcarey on 3/13/14.

Summary

Performs on-the-fly filtering of the provided VariantContext Iterator such that only variants that satisfy all predicates are emitted.

Given a set of alignments for a read or read pair, mark one alignment as primary, according to whatever strategy is appropriate.

Filters out sites that have a QD annotation applied to them and where the QD value is lower than a lower limit.

A collection of helper utilities for iterating through reads that are in query-name sorted read order as pairs

While structurally identical to CompositeIndex, this class is maintained as it makes code more readable when the two are used together (see QSeqParser)

Stratifies into quintiles of read cycle.

A CollectionStratifier is a stratifier that uses a collection of stratifiers to inform the stratification.

Stratify by tags used during duplex and single index consensus calling.

Stratifies base into their read's tile which is parsed from the read-name.

Stratifies base into their read's Y coordinate which is parsed from the read-name.

Stratifies according to the length of an insertion or deletion.

Stratifies according to the overall mismatches (from SAMTag.NM) that the read has against the reference, NOT including the current base.

An enum for holding a reads read-pair's Orientation (i.e.

An enum to hold information about the "properness" of a read pair

An enum to hold the ordinality of a read

Data for a single end of a paired-end read, a barcode read, or for the entire read if not paired end.

Represents one set of cycles in an ReadStructure (e.g.

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

Interface for storing and retrieving ReadEnds objects.

Created by nhomer on 9/13/15.

Describes the intended logical output structure of clusters of an Illumina run.

Base interface for a reference argument collection.

Loads gene annotations from a refFlat file into an OverlapDetector.

Class which contains utility functions that use reflection.

Reorders a SAM/BAM input file according to the order of contigs in a second reference file.

Little struct-like class to hold a record index, the index of the corresponding representative read, and duplicate set size information.

This tool reverts the original base qualities (if specified) and adds the mate cigar tag to mapped BAMs.

Reverts a SAM file by optionally restoring original quality scores and by removing all alignment information.

Util class for executing R scripts.

Holds information about CpG sites encountered for RRBS processing QC

Holds summary statistics from RRBS processing QC

Compare two SAM/BAM files.

Argument collection for SAM comparison

Converts a BAM file to human-readable SAM output or vice versa

This class sets the duplicate read flag as the result state when examining sets of records.

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

Bait bias artifacts broken down by context.

Pre-adapter artifacts broken down by context.

Represents the sex of an individual.

This is a simple tool to mark duplicates using the DuplicateSetIterator, DuplicateSet, and SAMRecordDuplicateComparator.

Super class that is designed to provide some consistent structure between subclasses that simply iterate once over a coordinate sorted BAM and collect information from the records as the go in order to produce some kind of output.

Sorts a SAM or BAM file.

Command-line program to split a SAM or BAM file into separate files based on library name.

Splits the input VCF file into two, one for indels and one for SNPs.

Parser for tab-delimited files

Metrics class for the analysis of reads obtained from targeted pcr experiments e.g.

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).

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).

Created by David Benjamin on 5/13/15.

TheoreticalSensitivityMetrics, are metrics calculated from TheoreticalSensitivity and parameters used in the calculation.

This version of the thread pool executor will throw an exception if any of the internal jobs have throw exceptions while executing

Load a file containing 8-byte records like this: tile number: 4-byte int number of clusters in tile: 4-byte int Number of records to read is determined by reaching EOF.

Reads a TileMetricsOut file commonly found in the InterOp directory of an Illumina Run Folder.

IlluminaPhasingMetrics corresponds to a single record in a TileMetricsOut file

Utility for reading the tile data from an Illumina run directory's TileMetricsOut.bin file

Defines the first or second template read for a tile

UmiGraph is used to identify UMIs that come from the same original source molecule.

A utility class for dealing with unsigned types.

This tool reports on the validity of a SAM or BAM file relative to the SAM format specification.

Describes the functionality for an executor that manages the delegation of work to VariantProcessor.Accumulators.

Tools that evaluate and refine variant calls, e.g.

Tools that filter variants

Tools that manipulate variant call format (VCF) data

Handles VariantContexts, and accumulates their data in some fashion internally.

Simple builder of VariantProcessors.

Enum to hold the possible types of dbSnps.

Describes a mechanism for producing VcfFileSegments from a VCF file.

A simple program to convert a Genotyping Arrays VCF to an ADPC file (Illumina intensity data file).

Metrics for evaluating the performance of whole genome sequencing experiments.

Implementation of WgsMetricsProcessor that gets input data from a given iterator and processes it with a help of collector