The cl-sam Reference Manual

4.1.1 cl-sam/cl-sam.asd

Source

cl-sam.asd.

Parent Component

cl-sam (system).

ASDF Systems

cl-sam.

---

4.1.2 cl-sam/cl-sam/package.lisp

Source

cl-sam.asd.

Parent Component

cl-sam (module).

Packages

• sam.
• bgzf-ffi.

---

4.1.3 cl-sam/cl-sam/conditions.lisp

Dependency

package.lisp (file).

Source

cl-sam.asd.

Parent Component

cl-sam (module).

Public Interface

• bam-error (condition).
• bam-sort-error (condition).
• bgzf-io-error (condition).

Internals

• bgzf-of (reader method).
• errno-of (reader method).
• position-of (reader method).
• prev-position-of (reader method).
• prev-reference-of (reader method).
• reference-of (reader method).

---

4.1.4 cl-sam/cl-sam/bgzf.lisp

Dependency

conditions.lisp (file).

Source

cl-sam.asd.

Parent Component

cl-sam (module).

Public Interface

• bgzf (structure).
• bgzf-close (function).
• bgzf-eof-p (function).
• bgzf-open (function).
• bgzf-open-p (function).
• bgzf-seek (function).
• bgzf-tell (function).
• with-bgzf (macro).

Internals

• *default-compression* (special variable).
• *empty-bgz-record* (special variable).
• +bgz-max-payload-length+ (constant).
• +member-footer-length+ (constant).
• +member-header-length+ (constant).
• +sf1+ (constant).
• +sf2+ (constant).
• +slen+ (constant).
• +xlen+ (constant).
• bgz-member (structure).
• bgz-member-bsize (reader).
• (setf bgz-member-bsize) (writer).
• bgz-member-cdata (function).
• (setf bgz-member-cdata) (function).
• bgz-member-cend (function).
• (setf bgz-member-cend) (function).
• bgz-member-cm (function).
• bgz-member-crc32 (function).
• (setf bgz-member-crc32) (function).
• bgz-member-flg (function).
• (setf bgz-member-flg) (function).
• bgz-member-id1 (function).
• bgz-member-id2 (function).
• bgz-member-isize (function).
• (setf bgz-member-isize) (function).
• bgz-member-mtime (function).
• (setf bgz-member-mtime) (function).
• bgz-member-os (function).
• (setf bgz-member-os) (function).
• bgz-member-p (function).
• bgz-member-sf1 (reader).
• bgz-member-sf2 (reader).
• bgz-member-slen (reader).
• bgz-member-udata (reader).
• (setf bgz-member-udata) (writer).
• bgz-member-xfl (function).
• (setf bgz-member-xfl) (function).
• bgz-member-xlen (function).
• (setf bgz-member-xlen) (function).
• bgzf-buffer (reader).
• (setf bgzf-buffer) (writer).
• bgzf-coffset (function).
• bgzf-compression (reader).
• (setf bgzf-compression) (writer).
• bgzf-empty-p (function).
• bgzf-eof (reader).
• (setf bgzf-eof) (writer).
• bgzf-load-seek (reader).
• (setf bgzf-load-seek) (writer).
• bgzf-loaded-p (reader).
• (setf bgzf-loaded-p) (writer).
• bgzf-offset (reader).
• (setf bgzf-offset) (writer).
• bgzf-p (function).
• bgzf-pathname (reader).
• (setf bgzf-pathname) (writer).
• bgzf-pointer (reader).
• (setf bgzf-pointer) (writer).
• bgzf-position (reader).
• (setf bgzf-position) (writer).
• bgzf-stream (reader).
• (setf bgzf-stream) (writer).
• bgzf-uoffset (function).
• bgzf-util-buffer (reader).
• (setf bgzf-util-buffer) (writer).
• copy-bgz-member (function).
• copy-bgzf (function).
• deflate-bgz-member (function).
• inflate-bgz-member (function).
• make-bgz-member (function).
• make-bgzf (function).

---

4.1.5 cl-sam/cl-sam/bgzf-reader.lisp

Dependency

bgzf.lisp (file).

Source

cl-sam.asd.

Parent Component

cl-sam (module).

Internals

• read-bgz-member (function).
• read-bytes (function).
• read-string (function).

---

4.1.6 cl-sam/cl-sam/bgzf-writer.lisp

Dependency

bgzf-reader.lisp (file).

Source

cl-sam.asd.

Parent Component

cl-sam (module).

Internals

• bgzf-flush (function).
• write-bgz-member (function).
• write-bytes (function).
• write-chunked-bytes (function).

---

4.1.7 cl-sam/cl-sam/bgzip-stream.lisp

Dependency

bgzf-writer.lisp (file).

Source

cl-sam.asd.

Parent Component

cl-sam (module).

Public Interface

• bgzip-input-stream (class).
• bgzip-open (function).
• bgzip-stream (class).
• stream-close (method).
• stream-element-type (method).
• stream-file-position (method).
• stream-read-byte (method).
• stream-read-sequence (method).
• with-open-bgzip (macro).

Internals

• %stream-read-sequence (function).
• +bgzip-buffer-size+ (constant).
• bgzf-handle-mixin (class).
• bgzip-buffer (type).
• bgzip-buffer-index (type).
• buffer-empty-p (function).
• fill-buffer (function).

---

4.1.8 cl-sam/cl-sam/sam.lisp

Dependency

bgzip-stream.lisp (file).

Source

cl-sam.asd.

Parent Component

cl-sam (module).

Public Interface

• *sam-version* (special variable).
• add-pg-record (function).
• coordinate-sorted-p (function).
• ensure-mandatory-header-tags (function).
• ensure-valid-header-tags (function).
• ensure-valid-programs (function).
• hd-record (function).
• header-records (function).
• header-tags (function).
• header-type (function).
• header-value (function).
• last-programs (function).
• make-header-record (function).
• make-sam-header (function).
• merge-header-records (function).
• merge-sam-headers (function).
• name-sorted-p (function).
• pg-record (function).
• previous-programs (function).
• rg-record (function).
• sq-record (function).
• subst-group-order (function).
• subst-sam-version (function).
• subst-sort-order (function).
• valid-reference-name-p (function).
• valid-sam-version-p (function).

Internals

• *mandatory-header-tags* (special variable).
• *valid-group-orders* (special variable).
• *valid-header-tags* (special variable).
• *valid-header-types* (special variable).
• *valid-sort-orders* (special variable).
• define-header-tag-parser (macro).
• ensure-order (function).
• ensure-sam-version (function).
• ensure-unique-tag-values (function).
• find-duplicate-header-tags (function).
• find-duplicate-records (function).
• group-by-tag (function).
• header-record (function).
• mandatory-header-tags (function).
• parse-hd-tag (function).
• parse-pg-tag (function).
• parse-rg-tag (function).
• parse-sq-tag (function).
• partition-by-type (function).
• simplify-records (function).
• update-pg-records (function).
• user-header-tag-p (function).
• valid-header-tags (function).

---

4.1.9 cl-sam/cl-sam/bam.lisp

Dependency

sam.lisp (file).

Source

cl-sam.asd.

Parent Component

cl-sam (module).

Public Interface

• alignment-bin (function).
• alignment-cigar (function).
• alignment-core (function).
• alignment-core-alist (function).
• alignment-flag (function).
• alignment-flag-alist (function).
• alignment-not-primary-p (function).
• alignment-position (function).
• alignment-reference-end (function).
• alignment-tag-documentation (generic function).
• alignment-tag-values (function).
• bam-sort-error (function).
• cigar-length (function).
• copy-alignment-record (function).
• define-alignment-tag (macro).
• fails-platform-qc-p (function).
• first-in-pair-p (function).
• flag-bits (function).
• insert-length (function).
• make-alignment-record (function).
• make-reference-table (function).
• mapped-proper-pair-p (function).
• mapping-quality (function).
• mate-alignment-position (function).
• mate-forward-p (function).
• mate-mapped-p (function).
• mate-reference-id (function).
• mate-reverse-p (function).
• mate-unmapped-p (function).
• medial-frag-p (function).
• pcr/optical-duplicate-p (function).
• print-object (method).
• quality-string (function).
• query-forward-p (function).
• query-mapped-p (function).
• query-reverse-p (function).
• query-unmapped-p (function).
• read-length (function).
• read-name (function).
• read-name-length (function).
• reference-id (function).
• second-in-pair-p (function).
• seq-string (function).
• sequenced-pair-p (function).
• unknown-frag-p (function).
• valid-flag-p (function).
• valid-mapped-pair-p (function).
• valid-mapped-proper-pair-p (function).
• with-bam (macro).

Internals

• %encode-string-tag (function).
• *bam-magic* (special variable).
• *invalid-read-name-chars* (special variable).
• +alignment-size-tag+ (constant).
• +null-byte+ (constant).
• +tag-size+ (constant).
• +unknown-position+ (constant).
• +unknown-quality+ (constant).
• +unknown-reference+ (constant).
• alignment (structure).
• alignment-indices (function).
• alignment-p (function).
• alignment-primary-p (function).
• alignment-read-length (function).
• alignment-reference-length (function).
• alignment-tag-bytes (function).
• aln-bin (reader).
• (setf aln-bin) (writer).
• aln-cigar (reader).
• (setf aln-cigar) (writer).
• aln-flag (reader).
• (setf aln-flag) (writer).
• aln-insert-length (reader).
• (setf aln-insert-length) (writer).
• aln-map-qual (reader).
• (setf aln-map-qual) (writer).
• aln-mate-pos (reader).
• (setf aln-mate-pos) (writer).
• aln-mate-ref-id (reader).
• (setf aln-mate-ref-id) (writer).
• aln-pos (reader).
• (setf aln-pos) (writer).
• aln-qual-str (reader).
• (setf aln-qual-str) (writer).
• aln-read-name (reader).
• (setf aln-read-name) (writer).
• aln-record (reader).
• (setf aln-record) (writer).
• aln-ref-id (reader).
• (setf aln-ref-id) (writer).
• aln-ref-len (reader).
• (setf aln-ref-len) (writer).
• aln-seq-str (reader).
• (setf aln-seq-str) (writer).
• copy-alignment (function).
• decode-cigar (function).
• decode-quality-string (function).
• decode-read-name (function).
• decode-seq-string (function).
• decode-tag-values (function).
• encode-alignment-tag (generic function).
• encode-char-tag (function).
• encode-cigar (function).
• encode-float-tag (function).
• encode-hex-tag (function).
• encode-int-tag (function).
• encode-quality-string (function).
• encode-read-name (function).
• encode-seq-string (function).
• encode-string-tag (function).
• encode-unknown-quality (function).
• ensure-valid-flag (function).
• ensure-valid-read-name (function).
• ensure-valid-reference-name (function).
• flag-symbol (function).
• flag-validation-error (function).
• make-alignment (function).
• make-aln (function).
• print-aln (function).
• valid-read-name-p (function).

---

4.1.10 cl-sam/cl-sam/bam-index.lisp

Dependency

bam.lisp (file).

Source

cl-sam.asd.

Parent Component

cl-sam (module).

Public Interface

• bam-index (structure).
• bam-index-refs (reader).
• (setf bam-index-refs) (writer).
• bin (structure).
• bin-chunk (function).
• bin-chunks (reader).
• (setf bin-chunks) (writer).
• bin-num (reader).
• chunk (structure).
• chunk-end (reader).
• (setf chunk-end) (writer).
• chunk-start (reader).
• (setf chunk-start) (writer).
• empty-bin-p (function).
• find-bam-index (function).
• find-bins (function).
• print-object (method).
• print-object (method).
• print-object (method).
• print-object (method).
• print-object (method).
• ref-index (function).
• ref-index (structure).
• ref-index-bin (function).
• ref-index-bins (reader).
• (setf ref-index-bins) (writer).
• ref-index-intervals (reader).
• (setf ref-index-intervals) (writer).

Internals

• *bam-index-file-type* (special variable).
• *bam-index-magic* (special variable).
• *tree-deepening-boundaries* (special variable).
• *voffset-merge-distance* (special variable).
• +linear-bin-size+ (constant).
• +max-num-bins+ (constant).
• +samtools-kludge-bin+ (constant).
• adjacentp (function).
• bam-index-p (function).
• bin-p (function).
• chunk-p (function).
• copy-bam-index (function).
• copy-bin (function).
• copy-chunk (function).
• copy-ref-index (function).
• copy-region (function).
• copy-samtools-bam-index (function).
• copy-samtools-ref-index (function).
• find-interval (function).
• make-bam-chunks (function).
• make-bam-index (function).
• make-bin (function).
• make-chunk (function).
• make-ref-index (function).
• make-region (function).
• make-samtools-bam-index (function).
• make-samtools-ref-index (function).
• max-bin-num (function).
• merge-chunks (function).
• print-bin (function).
• print-chunk (function).
• print-ref-index (function).
• print-region (function).
• print-samtools-ref-index (function).
• ref-index-id (reader).
• ref-index-p (function).
• region (function).
• region (structure).
• region-end (reader).
• (setf region-end) (writer).
• region-p (function).
• region-ref (reader).
• (setf region-ref) (writer).
• region-start (reader).
• (setf region-start) (writer).
• region-to-bin (function).
• region-to-bins (function).
• region-to-interval (function).
• run-length-encode (function).
• samtools-bam-index (structure).
• samtools-bam-index-p (function).
• samtools-bam-index-refs (function).
• (setf samtools-bam-index-refs) (function).
• samtools-bam-index-unassigned (reader).
• (setf samtools-bam-index-unassigned) (writer).
• samtools-ref-index (structure).
• samtools-ref-index-bins (function).
• (setf samtools-ref-index-bins) (function).
• samtools-ref-index-end (reader).
• (setf samtools-ref-index-end) (writer).
• samtools-ref-index-id (function).
• samtools-ref-index-intervals (function).
• (setf samtools-ref-index-intervals) (function).
• samtools-ref-index-mapped (reader).
• (setf samtools-ref-index-mapped) (writer).
• samtools-ref-index-p (function).
• samtools-ref-index-start (reader).
• (setf samtools-ref-index-start) (writer).
• samtools-ref-index-unmapped (reader).
• (setf samtools-ref-index-unmapped) (writer).
• voffset-merge-p (function).

---

4.1.11 cl-sam/cl-sam/bam-index-reader.lisp

Dependency

bam-index.lisp (file).

Source

cl-sam.asd.

Parent Component

cl-sam (module).

Public Interface

• read-bam-index (function).
• with-bam-index (macro).

Internals

• read-bin (function).
• read-binning-index (function).
• read-index-magic (function).
• read-linear-index (function).
• read-ref-index (function).

---

4.1.12 cl-sam/cl-sam/bam-index-writer.lisp

Dependency

bam-index-reader.lisp (file).

Source

cl-sam.asd.

Parent Component

cl-sam (module).

Public Interface

write-bam-index (generic function).

Internals

• %write-int32 (function).
• %write-int64 (function).
• write-bin (function).
• write-binning-index (function).
• write-index-magic (function).
• write-linear-index (function).
• write-ref-index (generic function).

---

4.1.13 cl-sam/cl-sam/bam-indexer.lisp

Dependency

bam-index-writer.lisp (file).

Source

cl-sam.asd.

Parent Component

cl-sam (module).

Public Interface

index-bam-file (function).

Internals

• %make-bam-index (function).
• %make-ref-index (function).

---

4.1.14 cl-sam/cl-sam/bam-reader.lisp

Dependency

bam-indexer.lisp (file).

Source

cl-sam.asd.

Parent Component

cl-sam (module).

Public Interface

• parse-region-string (function).
• read-alignment (function).
• read-bam-header (function).
• read-bam-magic (function).
• read-bam-meta (function).
• read-bam-terminator (function).
• read-num-references (function).
• read-reference-meta (function).

Internals

• bam-meta-size (function).
• bam-meta-size2 (function).
• block-sizes (function).
• ensure-valid-region (function).
• make-bam-full-scan-input (function).
• make-bam-index-input (function).
• make-bam-scan-input (function).
• make-region< (function).
• normalise-regions (function).
• partition-regions (function).

---

4.1.15 cl-sam/cl-sam/bam-writer.lisp

Dependency

bam-reader.lisp (file).

Source

cl-sam.asd.

Parent Component

cl-sam (module).

Public Interface

• make-bam-output (function).
• write-alignment (function).
• write-bam-header (function).
• write-bam-magic (function).
• write-bam-meta (function).
• write-num-references (function).
• write-reference-meta (function).

---

4.1.16 cl-sam/cl-sam/sam-writer.lisp

Dependency

bam-writer.lisp (file).

Source

cl-sam.asd.

Parent Component

cl-sam (module).

Public Interface

• write-header-record (function).
• write-sam-alignment (function).
• write-sam-header (function).

Internals

• make-header-string (function).
• write-cigar (function).
• write-quality-string (function).
• write-seq-string (function).
• write-tag-values (function).

---

4.1.17 cl-sam/cl-sam/external-bam-sort.lisp

Dependency

sam-writer.lisp (file).

Source

cl-sam.asd.

Parent Component

cl-sam (module).

Public Interface

• alignment-name< (function).
• alignment-record< (function).
• initialize-instance (method).
• make-merge-stream (method).
• sort-bam-file (function).
• stream-merge (method).
• stream-read-element (method).
• stream-write-element (method).

Internals

• %read-bam-alignment (function).
• alignment-name-natural< (function).
• bam-merge-stream (class).
• bam-sort-input-stream (class).
• bam-sort-output-stream (class).
• buffer-of (reader method).
• parse-digits (function).
• sort-bam-alignments (function).

---

4.1.18 cl-sam/cl-sam/bam-utilities.lisp

Dependency

external-bam-sort.lisp (file).

Source

cl-sam.asd.

Parent Component

cl-sam (module).

Public Interface

• alignment-generator (function).
• alignment-orphanizer (function).
• generate-bam-file (function).
• generate-reference-file (function).
• repair-mapping-flags (function).

Internals

• default-orphanizer-test (function).
• default-qual-string (function).
• default-seq-string (function).
• encode-phred-quality (function).

---

4.1.19 cl-sam/cl-sam/cl-sam.lisp

Dependency

bam-utilities.lisp (file).

Source

cl-sam.asd.

Parent Component

cl-sam (module).

Public Interface

• flagstat (function).
• view-sam (function).

Internals

stream-view-sam (function).

---

6.1.1 Special variables

Special Variable: *sam-version* ¶

The SAM version written by cl-sam.

Package

sam.

Source

sam.lisp.

---

6.1.2 Macros

Macro: define-alignment-tag (tag value-type &optional docstring) ¶

Defines a new alignment tag to hold a datum of a particular SAM type.

Arguments:

- tag (symbol): The tag e.g. :rg
- value-type (symbol): The value type, one of :char , :string , :hex :int32 or :float .

Optional:

- docstring (string): Documentation for the tag.

Package

sam.

Source

bam.lisp.

Macro: with-bam ((var (&optional header num-refs ref-meta) filespec &rest args &key compress-header pad-header index regions &allow-other-keys) &body body) ¶

Evaluates BODY with VAR bound to a new BAM generator function on pathname designator FILESPEC. The direction (:input versus :output) is determined by the stream-opening arguments in ARGS. The standard generator interface functions NEXT and HAS-MORE-P may be used in operations on the returned generator.

On reading, HEADER, NUM-REFS and REF-META will be automatically bound to the BAM file metadata i.e. the metadata are read automatically and the iterator positioned before the first alignment record.

Optionally, iteration may be restricted to a specific reference, designated by REF-NUM and to alignments that start between reference positions START and END. Furthermore, a BAM-INDEX object INDEX may be provided to allow the stream to seek directly to the desired region of the file.

On writing, HEADER, NUM-REFS and REF-META should be bound to appropriate values for the BAM file metadata, which will be automatically written to the underlying stream.

The COMPRESS-HEADER and PAD-HEADER keyword arguments are only applicable on writing where they control whether the records and header block should be compressed and whether the header string should be padded with nulls to allow space for expansion. Writing an uncompressed, padded header means that a header that fits in the first BGZF block may be updated without re-writing the entire BAM file. The BGZF COMPRESSION keyword is also accepted, permitting the Zlib compression level to be set for the stream.

A list REGIONS may be supplied to limit the returned alignments to specific references and reference coordinates. REGIONS may be region objects or region designators in the form of list tuples

;;; (<reference designator> start end)

where a reference designator is either the reference name string or its identifier number in the BAM file. REGIONS will be normalised automatically by sorting according to reference position in the BAM file (according to the BAM metadata) and then by start and
end. Overlapping regions will be merged.

For example:

To count all records in a BAM file:

;;; (with-bam (in () "in.bam")
;;; (loop
;;; while (has-more-p in)
;;; count (next in)))

To copy only records with a mapping quality of >= 30 to another BAM file:

;;; (with-bam (in (header n ref-meta) "in.bam")
;;; (with-bam (out (header n rer-meta) "out.bam" :direction :output) ;;; (let ((q30 (discarding-if (lambda (x)
;;; (< (mapping-quality x) 30)) in))) ;;; (loop
;;; while (has-more-p q30)
;;; do (consume out (next q30))))))

To count records with mapping quality of >= 30 in a set of genomic ranges, using an index:

;;; (with-bam-index (index "index.bai")
;;; (with-bam (bam () bam-file :index index
;;; :regions ’((0 1000000 1100000) (1 1000000 1100000))) ;;; (loop
;;; while (has-more-p bam)
;;; count (>= (mapping-quality (next bam)) 30))))

Package

sam.

Source

bam.lisp.

Macro: with-bam-index ((var filespec) &body body) ¶

Evaluates BODY with VAR bound to a BAM-INDEX read from file denoted by pathname designator FILESPEC.

Package

sam.

Source

bam-index-reader.lisp.

Macro: with-bgzf ((var filespec &rest args) &body body) ¶

Executes BODY with VAR bound to a BGZF handle structure created by opening the file denoted by FILESPEC.

Arguments:

- var (symbol): The symbol to be bound.
- filespec (pathname designator): The file to open.

Rest:

- args: Arguments applicable to bgzf-open.

Package

sam.

Source

bgzf.lisp.

Macro: with-open-bgzip ((var filespec &rest args) &body body) ¶

Package

sam.

Source

bgzip-stream.lisp.

---

6.1.3 Ordinary functions

Function: add-pg-record (header new-record) ¶

Returns a copy of HEADER with PG record NEW-RECORD added. If the ID of NEW-RECORD clashes with existing IDs, all IDs are remapped to new, generated sequential integer IDs, starting at 0. PP links are also updated. NEW-RECORD must have its PP field set by the caller.

Package

sam.

Source

sam.lisp.

Function: alignment-bin (aln) ¶

Returns an integer that indicates the alignment bin to which ALN has been assigned.

Package

sam.

Source

bam.lisp.

Function: alignment-cigar (aln) ¶

Returns the CIGAR record list of the alignment described by
ALN. CIGAR operations are given as a list, each member being a list of a CIGAR operation keyword and an integer operation length.

Package

sam.

Source

bam.lisp.

Function: alignment-core (aln &key validate) ¶

Returns a list of the core data described by ALN. The list elements are comprised of reference-id, alignment-position, read-name length, mapping-quality alignment-bin, cigar length, alignment flag, read length, mate reference-id, mate alignment-position and insert length.

Package

sam.

Source

bam.lisp.

Function: alignment-core-alist (aln &key validate) ¶

Returns the same data as {defun alignment-core} in the form of an alist.

Package

sam.

Source

bam.lisp.

Function: alignment-flag (aln &key validate) ¶

Returns an integer whose bits are flags that describe properties of the ALN. If the VALIDATE key is T (the default) the flag’s bits are checked for internal consistency.

Package

sam.

Source

bam.lisp.

Function: alignment-flag-alist (aln &key validate) ¶

Returns the bitwise flags of ALN in the form of an alist. The primary purpose of this function is debugging.

Package

sam.

Source

bam.lisp.

Function: alignment-generator (reference-id read-group &key read-length name-suffix insert-length start end step-size mapping-quality seq-fn quality-fn) ¶

Returns a new standard generator function which returns pairs of
BAM alignment records.

Arguments:

- reference-id (integer): The BAM reference identifier.
- read-group (string): The read group name.

Key:

- read-length (integer): The read length.
- insert-length (integer): The insert length, defined as the distance between the inner boundaries of the paired alignments.
- start (integer): The position at which to start generating alignments. - end (integer): The position at which to stop generating alignments, expressed in Lisp vector indices (zero-based, half-open), rather than BAM’s (zero-based, closed).
- step-size (integer): The distance between each successive pair of alignments.
- mapping-quality (integer): The mapping quality of the alignments.

Returns

- A function.

Package

sam.

Source

bam-utilities.lisp.

Function: alignment-name< (alignment-record1 alignment-record2) ¶

Returns T if ALIGNMENT-RECORD1 sorts before ALIGNMENT-RECORD2 by read name. Sorting semantics of read names are not fully defined in the SAM spec; whether you should expect natural order or numeric order of read name strings is not defined.

This function compares numerically by read name, then by alignment template region for reads paired in sequencing and finally by alignment strand.

Package

sam.

Source

external-bam-sort.lisp.

Function: alignment-not-primary-p (flag) ¶

Returns T if FLAG indicates that the read mapping was not the primary mapping to a reference, or NIL otherwise.

Package

sam.

Source

bam.lisp.

Function: alignment-orphanizer (gen &key test) ¶

Given an alignment generator function GEN, returns a new function that omits some alignments, yielding orphans. Any alignments for which TEST returns T will be omitted. The default is to omit alternate last fragment alignments.

Package

sam.

Source

bam-utilities.lisp.

Function: alignment-position (aln) ¶

Returns the 0-based sequence coordinate of ALN in the reference sequence of the first base of the clipped read.

Package

sam.

Source

bam.lisp.

Function: alignment-record< (alignment-record1 alignment-record2) ¶

Returns T if ALIGNMENT-RECORD1 sorts before
ALIGNMENT-RECORD2. Sorting semantics are not fully defined in the SAM spec, however, an informal consensus on sequence order sorting seems to be:

- mapped reads should first be sorted by their reference in the order in which reference sequences appear in the header
- unmapped reads should sort after mapped reads
- reads mapped to the same reference must appear in ascending order of their alignment position

This function compares first by reference sequence, then alignment position, by alignment strand and finally by read name. The output is identical to a coordinate sort performed by Picard 1.07.

Package

sam.

Source

external-bam-sort.lisp.

Function: alignment-reference-end (aln) ¶

Returns the end position of the alignment on the reference. Requires decoding the CIGAR string.

Package

sam.

Source

bam.lisp.

Function: alignment-tag-values (aln) ¶

Returns an alist of tag and values described by ALN.

Package

sam.

Source

bam.lisp.

Reader: bam-index-refs (instance) ¶

Writer: (setf bam-index-refs) (instance) ¶

Package

sam.

Source

bam-index.lisp.

Target Slot

refs.

Function: bam-sort-error (previous-ref previous-pos ref pos &optional message &rest message-arguments) ¶

Package

sam.

Source

bam.lisp.

Function: bgzf-close (bgzf) ¶

Closes an open block gzip file.

Arguments:

- bgzf (bgzf structure): The file to close.

Returns:

- T on success.

Package

sam.

Source

bgzf.lisp.

Function: bgzf-eof-p (bgzf) ¶

Returns T if the BGZF stream is terminated by an empty record.

Package

sam.

Source

bgzf.lisp.

Function: bgzf-open (bgzfspec &rest args &key compression &allow-other-keys) ¶

Opens a block gzip file for reading or writing.

Arguments:

- bgzfspec (pathname designator, open stream or bgzf object): The file to open or an open stream or bgzf object (which is returned unmodified). The *standard-input* or *standard-ouput* streams may be used.

Key:

- compression (keyword): The zlib compression level (for writing).

Also accepts the keyword arguments applicable to CL:OPEN. However,
an :element-type argument will be ignored as the type is always octet.

Returns:

- A BGZF structure.

Package

sam.

Source

bgzf.lisp.

Function: bgzf-open-p (bgzf) ¶

Package

sam.

Source

bgzf.lisp.

Function: bgzf-seek (bgzf position) ¶

Seeks with the file encapsulated by a block gzip file.

Arguments:

- bgzf (bgzf structure): The handle to seek.

- position (integer): The position to seek. Only values previously returned by {defun bgzf-tell} may be used. The most significant 48 bits denote the real file position and the least significant 16 bits the offset within the uncompressed gzip member (see the SAM spec).

Returns:

- The new position.

Package

sam.

Source

bgzf.lisp.

Function: bgzf-tell (bgzf) ¶

Returns the current position in the encapsulated file of a block gzip file.

Arguments:

- bgzf (bgzf structure): The file.

Returns:

- The file position.

Package

sam.

Source

bgzf.lisp.

Function: bgzip-open (filespec &key direction) ¶

Opens a block gzip stream for FILESPEC.

Key:

- direction (symbol): One of :input (the default) or :output

Returns:

- A {defclass bgzip-stream}

Package

sam.

Source

bgzip-stream.lisp.

Function: bin-chunk (bin chunk-num) ¶

Returns the chunk number CHUNK-NUM in BIN.

Package

sam.

Source

bam-index.lisp.

Reader: bin-chunks (instance) ¶

Writer: (setf bin-chunks) (instance) ¶

Package

sam.

Source

bam-index.lisp.

Target Slot

chunks.

Reader: bin-num (instance) ¶

Package

sam.

Source

bam-index.lisp.

Target Slot

num.

Reader: chunk-end (instance) ¶

Writer: (setf chunk-end) (instance) ¶

Package

sam.

Source

bam-index.lisp.

Target Slot

end.

Reader: chunk-start (instance) ¶

Writer: (setf chunk-start) (instance) ¶

Package

sam.

Source

bam-index.lisp.

Target Slot

start.

Function: cigar-length (aln) ¶

Returns the number of CIGAR operations in ALN.

Package

sam.

Source

bam.lisp.

Function: coordinate-sorted-p (header) ¶

Returns T if parsed HEADER indicates that the file is sorted by coordinate, or NIL otherwise.

Package

sam.

Source

sam.lisp.

Function: copy-alignment-record (aln &key alignment-flag reference-id alignment-pos mate-reference-id mate-alignment-pos mapping-quality alignment-bin insert-length cigar tag-values) ¶

Returns a copy of ALN, optionally setting some fields to new values.

Package

sam.

Source

bam.lisp.

Function: empty-bin-p (bin) ¶

Returns T if BIN contains no chunks, or NIL otherwise.

Package

sam.

Source

bam-index.lisp.

Function: ensure-mandatory-header-tags (record) ¶

Returns HEADER-RECORD if all mandatory tags are present, or raises a {define-condition malformed-record-error} .

Package

sam.

Source

sam.lisp.

Function: ensure-valid-header-tags (record) ¶

Checks list HEADER-RECORD for tag validity and returns HEADER-RECORD or raises a {define-condition malformed-record-error} if invalid tags are present. Ignores any user tags (lower case tags).

Package

sam.

Source

sam.lisp.

Function: ensure-valid-programs (header) ¶

Returns HEADER if its PG records have unique ID tag values and valid PP tag values. A valid PP tag must point to the ID of one of the other PG records in the header.

Package

sam.

Source

sam.lisp.

Function: fails-platform-qc-p (flag) ¶

Returns T if FLAG indicates that the read failed plaform quality control, or NIL otherwise.

Package

sam.

Source

bam.lisp.

Function: find-bam-index (bam-filespec) ¶

Returns the pathname of an index file for BAM-FILESPEC, if the file is present and conforms to the naming convention of either Picard or Samtools. If both are present, the Picard convention is favoured.

Package

sam.

Source

bam-index.lisp.

Function: find-bins (index reference-id start end) ¶

Returns a list of all the bins for reference REFERENCE-ID in INDEX, between reference positions START and END.

Package

sam.

Source

bam-index.lisp.

Function: first-frag-p (flag) ¶

Returns T if FLAG indicates that the read was the first in a pair of reads from one template, or NIL otherwise.

Package

sam.

Alias for

first-in-pair-p.

Function: first-in-pair-p (flag) ¶

Returns T if FLAG indicates that the read was the first in a pair of reads from one template, or NIL otherwise.

Package

sam.

Source

bam.lisp.

Function: flag-bits (flag &rest bit-names) ¶

Returns an integer FLAG that had BAM flag bits named by symbols BIT-NAMES set.

Arguments:

- flag (unsigned-byte 8): a BAM alignment flag.

Rest:

- bit-names (symbols): Any number of valid bit flag names:

;;; :sequenced-pair
;;; :mapped-proper-pair
;;; :query-mapped , :query-unmapped
;;; :mate-mapped , :mate-unmapped
;;; :query-forward , :query-reverse
;;; :mate-forward , :mate-reverse
;;; :first-in-pair , :second-in-pair
;;; :alignment-primary , :alignment-not-primary
;;; :fails-platform-qc
;;; :pcr/optical-duplicate

Returns:

- An (unsigned-byte 8)

Package

sam.

Source

bam.lisp.

Function: flagstat (bam-filespec &optional stream) ¶

Writes SAM flag counts from BAM-FILESPEC to STREAM.

Package

sam.

Source

cl-sam.lisp.

Function: frag-forward-p (flag) ¶

Returns T if FLAG indicates that the read was mapped to the forward strand of a reference, or NIL if it was mapped to the reverse strand.

Package

sam.

Alias for

query-forward-p.

Function: frag-mapped-p (flag) ¶

Returns T if FLAG indicates that the read’s mate was mapped to a reference, or NIL otherwise.

Package

sam.

Alias for

query-mapped-p.

Function: frag-reverse-p (flag) ¶

Returns T if FLAG indicates that the read was mapped to the reverse strand of a reference, or NIL if it was mapped to the forward strand.

Package

sam.

Alias for

query-reverse-p.

Function: frag-unmapped-p (flag) ¶

Returns T if FLAG indicates that the read was not mapped to a reference, or NIL otherwise.

Package

sam.

Alias for

query-unmapped-p.

Function: generate-bam-file (filespec num-refs ref-length read-groups &rest aln-generators) ¶

Writes a very uniform BAM file to the file denoted by pathname designator FILESPEC, for testing purposes.

Arguments:

- filespec (pathname designator): The BAM file to be written.
- num-refs (integer): The number of reference sequences in the BAM header. - read-groups (list of string): The read group names in the BAM header. Each reference will have a set of reads generated in each read group.

Rest:

- aln-generators (list of function): A list of alignment generator functions created with {defun alignment-generator} function. All of these functions will be called until exhausted, so they should represent finite sequences.

Returns

- filespec.

Package

sam.

Source

bam-utilities.lisp.

Function: generate-reference-file (filespec name length &optional fn) ¶

Creates an artificial reference genome Fasta file to accompany a generated BAM file.

Arguments:

- filespec (pathname designator): The file to create.
- name (string): The name of the reference sequence.
- length (integer): The length of the reference sequence.

Optional:

- fn (function): A function that returns a single base character. The default randomly returns a, c, g or t in equal proportions.

Returns:

- The filespec.

Package

sam.

Source

bam-utilities.lisp.

Function: hd-record (&key version sort-order) ¶

Returns a new HD record.

Package

sam.

Source

sam.lisp.

Function: header-records (header header-type) ¶

Returns a list of all records of HEADER-TYPE from HEADER.

Package

sam.

Source

sam.lisp.

Function: header-tags (record) ¶

Returns an alist of the tag-values of RECORD.

Package

sam.

Source

sam.lisp.

Function: header-type (record) ¶

Returns a symbol indicating the header-type of RECORD, being one of :HD , :SQ , :RG or :PG .

Package

sam.

Source

sam.lisp.

Function: header-value (record tag) ¶

Returns the value associated with TAG in RECORD.

Package

sam.

Source

sam.lisp.

Function: index-bam-file (filespec) ¶

Returns a new BAM-INDEX object, given pathname designator FILESPEC.

Package

sam.

Source

bam-indexer.lisp.

Function: insert-length (aln) ¶

Returns the insert length described by ALN.

Package

sam.

Source

bam.lisp.

Function: last-frag-p (flag) ¶

Returns T if FLAG indicates that the read was the second in a pair of reads from one template, or NIL otherwise.

Package

sam.

Alias for

second-in-pair-p.

Function: last-programs (header) ¶

Returns a list of the PG ID values from HEADER that are the last programs to act on the data. i.e. these are the leaf programs in the previous program tree.

Package

sam.

Source

sam.lisp.

Function: make-alignment-record (read-name seq-str alignment-flag &key reference-id alignment-pos mate-reference-id mate-alignment-pos mapping-quality alignment-bin insert-length cigar quality-str tag-values) ¶

Returns a new alignment record array.

Arguments:

- read-name (string): The read name.
- seq-str (string): The read sequence.
- alignment-flag (integer): The binary alignment flag.

Key:

- reference-id (integer): The reference identifier, defaults to -1
- alignment-pos (integer): The 1-based alignment position, defaults to -1. - mate-reference-id (integer): The reference identifier of the mate, defaults to -1.
- mate-alignment-pos (integer): The 1-based alignment position of the mate. - mapping-quality (integer): The mapping quality, defaults to 0.
- alignment-bin (integer): The alignment bin, defaults to 0.
- insert-length (integer): The insert size, defaults to 0.
- cigar (alist): The cigar represented as an alist of operations e.g.

;;; ’((:M . 9) (:I . 1) (:M . 25))

- quality-str (string): The read quality string.
- tag-values (alist): The alignment tags represented as an alist e.g.

;;; ’((:XT . #U) (:NM . 1) (:X0 . 1) (:X1 . 0)
;;; (:XM . 1) (:XO . 0) (:XG . 0) (:MD . "3T31"))

The tags must have been defined with {defmacro define-alignment-tag} .

Returns:

- A vector of ’(unsigned-byte 8).

Package

sam.

Source

bam.lisp.

Function: make-bam-output (bam) ¶

Returns a consumer function that accepts an argument of a BAM record and writes it to BAM output stream BAM. The standard consumer interface function CONSUME may be used in operations on the returned consumer.

Package

sam.

Source

bam-writer.lisp.

Function: make-header-record (str) ¶

Parses a single SAM header record STR and returns a list. May raise a {define-condition malformed-record-error} or {define-condition malformed-field-error} . SAM tags are converted to keyword symbols.

Given a header record of

;;; "@SQ SN:AL096846 LN:6490 SP:Schizosaccharomyces pombe"

the returned list will be

;;; (:SQ (:SN . "AL096846") (:LN . 6490)
;;; (:SP . "Schizosaccharomyces pombe"))

thus the list’s first element is a keyword describing the record type and the rest of the list is itself an alist of record keys and values.

Package

sam.

Source

sam.lisp.

Function: make-reference-table (ref-meta-list) ¶

Returns a hash-table mapping reference identifiers to reference names for the reference data in REF-META-LIST.

Package

sam.

Source

bam.lisp.

Function: make-sam-header (str) ¶

Returns a list containing the data in header STR as Lisp
objects. If the header is NIL (there was no header) this function
returns NIL.

Given a header of

;;; "@HD VN:1.0
;;; @SQ SN:AL096846 LN:6490 SP:Schizosaccharomyces pombe
;;; @PG ID:bwa VN:0.4.6 CL:aln -n 0.04 -o 1 -e -1 -i 5 -d 10 -k 2 -M 3 -O 11 -E 4"

the returned list will be

;;; ((:HD (:VN . "1.0"))
;;; (:SQ (:SN . "AL096846") (:LN . 6490)
;;; (:SP . "Schizosaccharomyces pombe"))
;;; (:PG (:ID . "bwa") (:VN . "0.4.6")
;;; (:CL . "aln -n 0.04 -o 1 -e -1 -i 5 -d 10 -k 2 -M 3 -O 11 -E 4"))))

thus each list element is a list whose first element is a keyword
describing the record type. The rest of each list is itself an alist
of record keys and values.

Package

sam.

Source

sam.lisp.

Function: mapped-proper-pair-p (flag) ¶

Returns T if FLAG indicates that the read was mapped as a member of a properly oriented read-pair, or NIL otherwise.

Package

sam.

Source

bam.lisp.

Function: mapping-quality (aln) ¶

Returns the integer mapping quality of ALN.

Package

sam.

Source

bam.lisp.

Function: mate-alignment-position (aln) ¶

Returns the 0-based sequence position of the read mate’s alignment described by ALN.

Package

sam.

Source

bam.lisp.

Function: mate-forward-p (flag) ¶

Returns T if FLAG indicates that the read’s mate was mapped to the forward, or NIL if it was mapped to the reverse strand.

Package

sam.

Source

bam.lisp.

Function: mate-mapped-p (flag) ¶

Returns T if FLAG indicates that the read’s mate was mapped to a reference, or NIL otherwise.

Package

sam.

Source

bam.lisp.

Function: mate-reference-id (aln) ¶

Returns the integer reference ID of ALN.

Package

sam.

Source

bam.lisp.

Function: mate-reverse-p (flag) ¶

Returns T if FLAG indicates that the read’s mate was mapped to the reverse, or NIL if it was mapped to the forward strand.

Package

sam.

Source

bam.lisp.

Function: mate-unmapped-p (flag) ¶

Returns T if FLAG indicates that the read’s mate was not mapped to a reference, or NIL otherwise.

Package

sam.

Source

bam.lisp.

Function: medial-frag-p (flag) ¶

Returns T if FLAG indicates that the read was sequenced as a non-terminal part of a linear template, or NIL otherwise.

Package

sam.

Source

bam.lisp.

Function: merge-header-records (record1 record2) ¶

Returns a new header record created by merging the tags of header-records RECORD1 and RECORD2. Records may be safely merged if they have the same header-type and do not contain any conflicting tag values.

Package

sam.

Source

sam.lisp.

Function: merge-sam-headers (&rest headers) ¶

Returns a new SAM header that is the result of merging HEADERS. Headers may be safely merged if none of their constituent records contain conflicting tag values once merged.

Package

sam.

Source

sam.lisp.

Function: multiple-frags-p (flag) ¶

Returns T if FLAG indicates that the read was sequenced as a member of a pair, or NIL otherwise.

Package

sam.

Alias for

sequenced-pair-p.

Function: name-sorted-p (header) ¶

Returns T if parsed HEADER indicates that the file is sorted by name, or NIL otherwise.

Package

sam.

Source

sam.lisp.

Function: next-reverse-p (flag) ¶

Returns T if FLAG indicates that the read’s mate was mapped to the reverse, or NIL if it was mapped to the forward strand.

Package

sam.

Alias for

mate-reverse-p.

Function: next-unmapped-p (flag) ¶

Returns T if FLAG indicates that the read’s mate was not mapped to a reference, or NIL otherwise.

Package

sam.

Alias for

mate-unmapped-p.

Function: parse-region-string (str) ¶

Returns a new region from a string region designator in samtools-style format:

<reference name>:<start coordinate>-<end coordinate>

The reference name must be one of those described in the BAM header metadata. The reference sequence coordinates are zero-based, half open with start < end.

Package

sam.

Source

bam-reader.lisp.

Function: pcr/optical-duplicate-p (flag) ¶

Returns T if FLAG indicates that the read is a PCR or optical duplicate, or NIL otherwise.

Package

sam.

Source

bam.lisp.

Function: pg-record (identity &key program-name program-version previous-program command-line) ¶

Returns a new PG record.

Package

sam.

Source

sam.lisp.

Function: previous-programs (header identity) ¶

Returns a list of PG ID values from HEADER that are previous programs with respect to PG ID IDENTITY. The list is ordered with the most recently used program first i.e. reverse chronological order.

Package

sam.

Source

sam.lisp.

Function: proper-aligned-frags-p (flag) ¶

Returns T if FLAG indicates that the read was mapped as a member of a properly oriented read-pair, or NIL otherwise.

Package

sam.

Alias for

mapped-proper-pair-p.

Function: quality-string (aln) ¶

Returns the sequence quality string described by ALN.

Package

sam.

Source

bam.lisp.

Function: query-forward-p (flag) ¶

Returns T if FLAG indicates that the read was mapped to the forward strand of a reference, or NIL if it was mapped to the reverse strand.

Package

sam.

Source

bam.lisp.

Function: query-mapped-p (flag) ¶

Returns T if FLAG indicates that the read’s mate was mapped to a reference, or NIL otherwise.

Package

sam.

Source

bam.lisp.

Function: query-reverse-p (flag) ¶

Returns T if FLAG indicates that the read was mapped to the reverse strand of a reference, or NIL if it was mapped to the forward strand.

Package

sam.

Source

bam.lisp.

Function: query-unmapped-p (flag) ¶

Returns T if FLAG indicates that the read was not mapped to a reference, or NIL otherwise.

Package

sam.

Source

bam.lisp.

Function: read-alignment (bgzf &key validate) ¶

Reads one alignment block from handle BGZF, returns it as a Lisp array of unsigned-byte 8. The handle is advanced to the next alignment. If no more alignments are available, returns NIL.

This is the preferred function to use for validation. i.e. validate early. A USE-VALUE restart is provided so that an invalid alignment may be modified and re-read without unwinding the stack.

Package

sam.

Source

bam-reader.lisp.

Function: read-bam-header (bgzf) ¶

Returns the unparsed BAM header from the handle BGZF as a Lisp string.

Package

sam.

Source

bam-reader.lisp.

Function: read-bam-index (stream) ¶

Reads a BAM (.bai) index from STREAM.

Package

sam.

Source

bam-index-reader.lisp.

Function: read-bam-magic (bgzf) ¶

Reads the BAM magic number from the handle BGZF and returns T if it is valid or raises a {define-condition malformed-file-error} if not.

Package

sam.

Source

bam-reader.lisp.

Function: read-bam-meta (bgzf) ¶

Reads all BAM metadata from handle BGZF, leaving the handle pointing at the first alignment record. Returns the header string, the number of references and a list of reference sequence metadata. The list contains one element per reference sequence, each element being a list of reference identifier, reference name and reference length.

Package

sam.

Source

bam-reader.lisp.

Function: read-bam-terminator (bgzf) ¶

Reads the EOF from handle BGZF, returning T if it is present, or raising a {define-condition malformed-file-error} otherwise.

Package

sam.

Source

bam-reader.lisp.

Function: read-length (aln) ¶

Returns the length of the read described by ALN.

Package

sam.

Source

bam.lisp.

Function: read-name (aln) ¶

Returns the read name string described by ALN.

Package

sam.

Source

bam.lisp.

Function: read-name-length (aln) ¶

Returns the length in ASCII characters of the read name of ALN.

Package

sam.

Source

bam.lisp.

Function: read-num-references (bgzf) ¶

Returns the number of reference sequences described in the BAM header of handle BGZF.

Package

sam.

Source

bam-reader.lisp.

Function: read-reference-meta (bgzf) ¶

Returns the reference sequence metadata for a single reference sequence described in the BAM header of handle BGZF. Two values are returned, the reference name as a string and the reference length as an integer,

Package

sam.

Source

bam-reader.lisp.

Function: ref-index (bam-index reference-id) ¶

Returns the reference index for reference number REFERENCE-ID in BAM-INDEX.

Package

sam.

Source

bam-index.lisp.

Function: ref-index-bin (ref-index bin-num) ¶

Returns the BIN number BIN-NUM in REF-INDEX.

Package

sam.

Source

bam-index.lisp.

Reader: ref-index-bins (instance) ¶

Writer: (setf ref-index-bins) (instance) ¶

Package

sam.

Source

bam-index.lisp.

Target Slot

bins.

Reader: ref-index-intervals (instance) ¶

Writer: (setf ref-index-intervals) (instance) ¶

Package

sam.

Source

bam-index.lisp.

Target Slot

intervals.

Function: reference-id (aln) ¶

Returns the reference sequence identifier of ALN. This is an integer locally assigned to a reference sequence within the context of a BAM file.

Package

sam.

Source

bam.lisp.

Function: repair-mapping-flags (aln) ¶

Returns alignment ALN if it has correct mapped-proper-pair, query-mapped and mate-mapped flags, or a modified copy with fixed flags. Also sets the user tag ZF:I:<original flag> if the flags are changed.

Alignments produced by the BWA aligner have been observed to contain invalid flags. This is caused by BWA creating mappings that overhang the end of the reference. The underlying cause is reference concatenation in the Burrows-Wheeler index.

This function attempts to fix invalid mapped-proper-pair flags in cases where query-unmapped and/or mate-unmapped flags are set. Such unmapped reads may also have reference-ids set and good mapping scores. This function does not correct these other fields.

It is necessary to use this function in order to obtain correct flag counts when using samtools flagstat or {defun flagstat} .

Package

sam.

Source

bam-utilities.lisp.

Function: rg-record (identity sample &key library description platform-unit insert-size sequencing-centre sequencing-date platform-tech flow-order key-sequence) ¶

Returns a new RG record.

Package

sam.

Source

sam.lisp.

Function: second-in-pair-p (flag) ¶

Returns T if FLAG indicates that the read was the second in a pair of reads from one template, or NIL otherwise.

Package

sam.

Source

bam.lisp.

Function: seq-string (aln) ¶

Returns the sequence string described by ALN.

Package

sam.

Source

bam.lisp.

Function: sequenced-pair-p (flag) ¶

Returns T if FLAG indicates that the read was sequenced as a member of a pair, or NIL otherwise.

Package

sam.

Source

bam.lisp.

Function: sort-bam-file (in-filespec out-filespec &key sort-order buffer-size) ¶

Sorts a BAM file by coordinate or by read name.

Arguments:

- in-filespec (pathname designator): The input BAM file.
- out-filespec (pathname designator): The output BAM file.

Key:

- sort-order (symbol): The sort order, either :coordinate
or :queryname .

- buffer-size (fixnum): The maximum number of reads to sort in memory at any one time, defaulting to 1000000.

Returns:

- The number of alignments sorted.
- The number of files used in the external merge sort.

Package

sam.

Source

external-bam-sort.lisp.

Function: sq-record (seq-name seq-length &key assembly-identity seq-md5 seq-uri seq-species) ¶

Returns a new SQ record.

Package

sam.

Source

sam.lisp.

Function: subst-group-order (header order) ¶

Returns a copy of HEADER with any group order tag initially present substituted by symbol ORDER, which must be one of the valid SAM sort orders. If there is no HD record in HEADER, one is added.

Package

sam.

Source

sam.lisp.

Function: subst-sam-version (header &optional version) ¶

Returns a copy of HEADER with any header version tag initially present substituted by string VERSION, defaulting to *SAM-VERSION* .

Package

sam.

Source

sam.lisp.

Function: subst-sort-order (header order) ¶

Returns a copy of HEADER with any sort order tag initially present substituted by symbol ORDER, which must be one of the valid SAM sort orders. If there is no HD record in HEADER, one is added.

Package

sam.

Source

sam.lisp.

Function: unknown-frag-p (flag) ¶

Returns T if FLAG indicates that the read was sequenced as part of a non-linear template or as part of a linear template where the position has been lost, or NIL otherwise.

Package

sam.

Source

bam.lisp.

Function: valid-flag-p (flag) ¶

Returns T if the paired-read-specific bits of FLAG are internally consistent.

Package

sam.

Source

bam.lisp.

Function: valid-mapped-pair-p (flag) ¶

Returns T if FLAG indicates valid mapping states for a pair of mapped reads, that is both must be mapped, or NIL otherwise.

Package

sam.

Source

bam.lisp.

Function: valid-mapped-proper-pair-p (flag) ¶

Returns T if FLAG indicates valid proper mapping states for a pair of mapped reads, that is both must be mapped and on opposite strands, or NIL otherwise.

Package

sam.

Source

bam.lisp.

Function: valid-reference-name-p (str) ¶

Returns T if STR is a valid reference sequence name matching the regex [!-)+-<>-~][!-~]* , or NIL otherwise.

Package

sam.

Source

sam.lisp.

Function: valid-sam-version-p (str) ¶

Returns T if SAM version string STR matches /^[0-9]+.[0-9]$/, or NIL otherwise.

Package

sam.

Source

sam.lisp.

Function: view-sam (bam-filespec sam-filespec) ¶

Writes the contents of binary BAM file BAM-FILESPEC to SAM text file SAM-FILESPEC.

Package

sam.

Source

cl-sam.lisp.

Function: write-alignment (bgzf alignment-record) ¶

Writes one ALIGNMENT-RECORD to handle BGZF and returns the number of bytes written.

Package

sam.

Source

bam-writer.lisp.

Function: write-bam-header (bgzf header &key compress null-padding mtime) ¶

Writes the BAM header string HEADER to handle BGZF, followed by padding of NULL-PADDING null bytes. This function also writes the header length, including padding, in the 4 bytes preceding the header.

Package

sam.

Source

bam-writer.lisp.

Function: write-bam-magic (bgzf &key compress) ¶

Writes the BAM magic number to the handle BGZF.

Package

sam.

Source

bam-writer.lisp.

Function: write-bam-meta (bgzf header num-refs ref-meta &key compress null-padding) ¶

Writes BAM magic number and then all metadata to handle BGZF. The metadata consist of the HEADER string, number of reference sequences NUM-REFS and a list reference sequence metadata REF-META. The list contains one element per reference sequence, each element being a list of reference identifier, reference name and reference length. Returns the number of bytes written.

Key:

- compress-header (boolean): Compress the header block if T.
- null-padding (fixnum): A number of null bytes to be appended to the end of the header string, as allowed by the SAM spec. This is useful for creating slack space so that BAM headers may be edited in place.

Package

sam.

Source

bam-writer.lisp.

Function: write-header-record (header-record &optional stream) ¶

Writes alist HEADER-RECORD to STREAM.

Package

sam.

Source

sam-writer.lisp.

Function: write-num-references (bgzf n) ¶

Writes the number of reference sequences N to handle BGZF.

Package

sam.

Source

bam-writer.lisp.

Function: write-reference-meta (bgzf ref-name ref-length) ¶

Writes the metadata for a single reference sequence named REF-NAME, of length REF-LENGTH bases, to handle BGZF.

Package

sam.

Source

bam-writer.lisp.

Function: write-sam-alignment (alignment-record ref-table &optional stream) ¶

Writes ALIGNMENT-RECORD to STREAM as SAM. REF-TABLE is a hash-table created by {defun make-reference-table} .

Package

sam.

Source

sam-writer.lisp.

Function: write-sam-header (alist &optional stream) ¶

Writes SAM header ALIST as a string to STREAM.

Package

sam.

Source

sam-writer.lisp.

---

6.1.4 Generic functions

Generic Function: alignment-tag-documentation (tag) ¶

Returns the documentation for TAG or NIL if none is available.

Package

sam.

Source

bam.lisp.

Methods

Method: alignment-tag-documentation ((tag (eql :xt))) ¶

Method: alignment-tag-documentation ((tag (eql :xs))) ¶

Method: alignment-tag-documentation ((tag (eql :xo))) ¶

Method: alignment-tag-documentation ((tag (eql :xn))) ¶

Method: alignment-tag-documentation ((tag (eql :xm))) ¶

Method: alignment-tag-documentation ((tag (eql :xg))) ¶

Method: alignment-tag-documentation ((tag (eql :xf))) ¶

Method: alignment-tag-documentation ((tag (eql :xe))) ¶

Method: alignment-tag-documentation ((tag (eql :xc))) ¶

Method: alignment-tag-documentation ((tag (eql :xa))) ¶

Method: alignment-tag-documentation ((tag (eql :x1))) ¶

Method: alignment-tag-documentation ((tag (eql :x0))) ¶

Method: alignment-tag-documentation ((tag (eql :zf))) ¶

Method: alignment-tag-documentation ((tag (eql :za))) ¶

Method: alignment-tag-documentation ((tag (eql :uq))) ¶

Method: alignment-tag-documentation ((tag (eql :u2))) ¶

Method: alignment-tag-documentation ((tag (eql :tc))) ¶

Method: alignment-tag-documentation ((tag (eql :sq))) ¶

Method: alignment-tag-documentation ((tag (eql :sm))) ¶

Method: alignment-tag-documentation ((tag (eql :s2))) ¶

Method: alignment-tag-documentation ((tag (eql :sa))) ¶

Method: alignment-tag-documentation ((tag (eql :rt))) ¶

Method: alignment-tag-documentation ((tag (eql :rg))) ¶

Method: alignment-tag-documentation ((tag (eql :r2))) ¶

Method: alignment-tag-documentation ((tag (eql :qt))) ¶

Method: alignment-tag-documentation ((tag (eql :q2))) ¶

Method: alignment-tag-documentation ((tag (eql :pu))) ¶

Method: alignment-tag-documentation ((tag (eql :pt))) ¶

Method: alignment-tag-documentation ((tag (eql :pq))) ¶

Method: alignment-tag-documentation ((tag (eql :pg))) ¶

Method: alignment-tag-documentation ((tag (eql :oq))) ¶

Method: alignment-tag-documentation ((tag (eql :op))) ¶

Method: alignment-tag-documentation ((tag (eql :oc))) ¶

Method: alignment-tag-documentation ((tag (eql :nm))) ¶

Method: alignment-tag-documentation ((tag (eql :nh))) ¶

Method: alignment-tag-documentation ((tag (eql :mq))) ¶

Method: alignment-tag-documentation ((tag (eql :mf))) ¶

Method: alignment-tag-documentation ((tag (eql :md))) ¶

Method: alignment-tag-documentation ((tag (eql :ih))) ¶

Method: alignment-tag-documentation ((tag (eql :hi))) ¶

Method: alignment-tag-documentation ((tag (eql :h2))) ¶

Method: alignment-tag-documentation ((tag (eql :h1))) ¶

Method: alignment-tag-documentation ((tag (eql :h0))) ¶

Method: alignment-tag-documentation ((tag (eql :lb))) ¶

Method: alignment-tag-documentation ((tag (eql :gq))) ¶

Method: alignment-tag-documentation ((tag (eql :gs))) ¶

Method: alignment-tag-documentation ((tag (eql :gc))) ¶

Method: alignment-tag-documentation ((tag (eql :fz))) ¶

Method: alignment-tag-documentation ((tag (eql :fs))) ¶

Method: alignment-tag-documentation ((tag (eql :fi))) ¶

Method: alignment-tag-documentation ((tag (eql :e2))) ¶

Method: alignment-tag-documentation ((tag (eql :ct))) ¶

Method: alignment-tag-documentation ((tag (eql :cs))) ¶

Method: alignment-tag-documentation ((tag (eql :cq))) ¶

Method: alignment-tag-documentation ((tag (eql :cp))) ¶

Method: alignment-tag-documentation ((tag (eql :co))) ¶

Method: alignment-tag-documentation ((tag (eql :cm))) ¶

Method: alignment-tag-documentation ((tag (eql :cc))) ¶

Method: alignment-tag-documentation ((tag (eql :bq))) ¶

Method: alignment-tag-documentation ((tag (eql :bc))) ¶

Method: alignment-tag-documentation ((tag (eql :as))) ¶

Method: alignment-tag-documentation ((tag (eql :am))) ¶

Method: alignment-tag-documentation (tag) ¶

Generic Function: write-bam-index (index stream) ¶

Package

sam.

Source

bam-index-writer.lisp.

Methods

Method: write-bam-index ((index bam-index) stream) ¶

Method: write-bam-index ((index samtools-bam-index) stream) ¶

---