* Encapsulates a reference coordinate; i.e. identifiers for (a) a * reference sequence, and (b) a 0-based offset into that sequence. */

* Encapsulates an edit between the read sequence and the reference sequence. * We obey a few conventions when populating its fields. The fields are:

* A generic score object for an alignment. Used for accounting during * SW and elsewhere. Encapsulates the score, the number of N positions * and

* A buffer for keeping all relevant information about a single read. */

* Encapsulates a reference interval, which consists of a Coord and a length. */

* Encapsulates a stretch of the reference containing only unambiguous * characters. From an ordered list of RefRecords, one can (almost) * deduce t

* A search root. Consists of an offset from the 5' end read and flags * indicating (a) whether we're initially heading left-to-right or * right-to-

* Exception to throw when a file-realted error occurs. */

* A simple function of one argument, parmeterized by I, X, C and L: min * value, max value, constant term, and coefficient respectively: * * 1. Con

A Benchmark item

A basic Cigar.

Sam Header.

Record Item for SAM.

* How to penalize various types of sequence dissimilarity, and other settings * that govern how dynamic programming tables should be filled in and ho

* This class is the glue between a DescentDriver and the dynamic programming * implementations in Bowtie 2. The DescentDriver is used to find some v

* Encapsulates a set of metrics that we would like an aligner to keep * track of, so that we can possibly use it to diagnose performance * issues.

* Interface used to query and update a pair of caches: one thread- * local and unsynchronized, another shared and synchronized. One or * both can b

* Encapsulates some general information about an alignment that doesn't belong * in AlnRes. Specifically: * * 1. Whether the alignment is paired

* Encapsulates an alignment result. The result comprises: * * 1. All the nucleotide edits for both mates ('ned'). * 2. All "edits" where an ambigu

* Encapsulates a concise summary of a set of alignment results for a * given pair or mate. Referring to the fields of this object should * provide

* Global hit sink for hits from the MultiSeed aligner. Encapsulates * all aspects of the MultiSeed aligner hitsink that are global to all * threads

* An AlnSink concrete subclass for printing SAM alignments. The user might * want to customize SAM output in various ways. We encapsulate all these

* Per-thread hit sink "wrapper" for the MultiSeed aligner. Encapsulates * aspects of the MultiSeed aligner hit sink that are per-thread. This * in

* Use SSE instructions to quickly find stretches with lots of matches, then * resolve alignments. */

Iterable for all benchmarks found in our test directory.

* Concrete reference representation that bulk-loads the reference from * the bit-pair-compacted binary file and stores it in memory also in * bit-pa

Forward declaration

* Wrapper for a buffered output stream that writes bitpairs. */

* TODO: Do BowtieMapq on a per-thread basis prior to the mutex'ed output * function. * * topCoeff :: top_coeff * botCoeff :: bot_coeff * mx :: ma

* V2 of the MAPQ calculator */

* V3 of the MAPQ calculator */

* Encapsulates a "branch" which is a diagonal of cells (possibly of length 0) * in the matrix where all the cells are matches. These stretches are l

* Parameters for a matrix of potential backtrace problems to solve. * Encapsulates information about: * * The problem given a particular reference

* Instantiate and solve best-first branch-based backtraces. */

* Parent class for PatternSources that read from a file. * Uses unlocked C I/O, on the assumption that all reading * from the file will take place i

* Encapsulates a collection of checkpoints. Assumes the scheme is to * checkpoint adjacent pairs of anti-diagonals. */

Default traits for the ConcurrentQueue. To change some of the traits without re-implementing all of them, inherit from this struct and shadow the decl

* A constraint to apply to an alignment zone, or to an overall * alignment. * * The constraint can put both caps and ceilings on the number and *

* Describes a dynamic programming rectangle. * * Only knows about reference offsets, not reference sequences. */

Some data IFace bowtie can work with.

* Encapsulates a descent through a search tree, along a path of matches. * Descents that are part of the same alignment form a chain. Two aligments

* An alignment result from a Descent. */

* Selects alignments to report from a complete non-empty stratum of * alignments stored in the DescentAlignmentSink. */

* Encapsulates settings governing how we descent. */

* Encapsulates the constraints limiting which outgoing edges are permitted. * Specifically, we constrain the total penalty accumulated so far so that

* Class responsible for advancing all the descents. The initial descents may * emanate from several different locations in the read. Note that desc

* Encapsulates an edge outgoing from a descent. */

* Counters to keep track of how much work is being done. */

* Encapsulates an incomplete summary of the outgoing edges from a descent. We * don't try to store information about all outgoing edges, because doi

* Selects and prioritizes partial alignments from the heap of the * DescentDriver. We assume that the heap is no longer changing (i.e. that the * D

* A partial alignment result from a Descent where the reference offset has * been resolved. */

* Class that aggregates partial alignments taken from a snapshot of the * DescentDriver heap. */

* FM Index state associated with a single position in a descent. For both the * forward and backward indexes, it stores the four SA ranges correspon

* Set of flags indicating outgoing edges we've tried from a DescentPos. */

* Priority used to rank which descent we should branch from next. Right now, * priority is governed by a 4-tuple. From higher to lower priority: *

* Map from pairs to top, bot, penalty triples. */

* Encapsulates the state of a Descent that allows us to determine whether it * is redundant with another Descent. Two Descents are redundant if: *

* Abstract parent for classes that select descent roots and descent * configurations given information about the read. */

* Encapsulates a set of conditions governing when the DescentDriver should * stop. */