minibwa 0.0.0

data/ext/minibwa/minibwa/mbpriv.h

@@ -0,0 +1,148 @@
+#ifndef MBPRIV_H
+#define MBPRIV_H
+
+#include "minibwa.h"
+#include "l2bit.h"
+#include "bwt.h"
+#include "kommon.h"
+#include "bseq.h"
+
+#define MB_DBG_ALN_SEQ     (0x1LL)
+#define MB_DBG_ANCHOR      (0x2LL)
+#define MB_DBG_SEED        (0x4LL)
+#define MB_DBG_QNAME       (0x8LL)
+#define MB_DBG_ALN_PE      (0x10LL)
+#define MB_DBG_AN_POS      (0x20LL)
+
+#define MB_SEED_LONG_JOIN  0x1
+#define MB_SEED_IGNORE     0x2
+
+struct mb_idx_s {
+	int32_t is_meth;
+	l2b_t *l2b;
+	mb_bwt_t *bwt;
+};
+
+typedef struct {
+	int32_t sid; // tid<<1|rev
+	int32_t len; // length of the anchor
+	int32_t qpos; // the query coordinate of the last base in the anchor; the start base is qpos+1-len; flipped by rev
+	uint32_t flag:31, flt:1;
+	int64_t tpos; // target/contig coordinate
+} mb_anchor_t;
+
+typedef struct { int64_t n, m; mb_anchor_t *a; } mb_anchor_v;
+
+typedef struct {
+	int lo, hi;      // lower and upper bounds within which a read pair is considered to be properly paired
+	int failed;      // non-zero if the orientation is not supported by sufficient data
+	double avg, std; // mean and stddev of the insert size distribution
+} mb_pestat_t;
+
+typedef struct { uint64_t x, y; } mb128_t;
+void radix_sort_mb128x(mb128_t *beg, mb128_t *end);
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// defined in options.c
+void mb_opt_adap(const mb_opt_t *opt0, int32_t len, mb_opt_t *opt);
+
+// defined in bwtgen.c
+void mb_bwtgen(const char *fn_pac, const char *fn_bwt, int block_size);
+
+// defined in seed.c
+void mb_seed_intv(void *km, const mb_bwt_t *bwt, int32_t len, const uint8_t *seq, int32_t min_len, int32_t max_sub_occ, mb_sai_v *v);
+void mb_seed_intv_batch(void *km, const mb_bwt_t *bwt, int32_t n_seq, const int32_t *len, uint8_t *const* seq, int32_t min_len, int32_t max_sub_occ, mb_sai_v *v);
+double mb_anchor(void *km, const mb_idx_t *idx, mb_sai_v *u, int32_t min_len, int32_t qlen, const uint8_t *qseq, l2b_meth_t mt, int32_t max_occ, mb_anchor_v *v);
+void mb_anchor_sort(const l2b_t *l2b, int64_t n_a, mb_anchor_t *a);
+
+// defined in lchain.c
+mb_anchor_t *mb_lchain_dp(void *km, const l2b_t *l2b, int max_dist_x, int max_dist_y, int bw, int max_skip, int max_iter, int min_sc, float chn_pen_gap,
+						  int64_t n, mb_anchor_t *a, int *n_u_, uint64_t **_u);
+
+// defined in map-algo.c
+void *mb_tbuf_km(mb_tbuf_t *b);
+int32_t mb_cal_mblen(int32_t n, const mb_anchor_t *a, int32_t *blen_);
+mb_hit_t *mb_gen_hit(void *km, uint32_t hash, int qlen, const l2b_t *l2b, int n_u, uint64_t *u, mb_anchor_t *a);
+void mb_sync_high_cov(int32_t n, mb_hit_t *h);
+void mb_set_parent(void *km, float mask_level, int mask_len, int n, mb_hit_t *r, int sub_diff, int hard_mask_level);
+void mb_set_sam_pri(int32_t n, mb_hit_t *r, int32_t is_primary5);
+void mb_hit_sort(void *km, int *n_regs, mb_hit_t *r);
+void mb_sync_hits(void *km, int n_regs, mb_hit_t *regs);
+void mb_select_sub(void *km, float pri_ratio, int min_diff, int best_n, int *n_, mb_hit_t *r);
+void mb_filter_hits(const mb_opt_t *opt, int qlen, int *n_regs, mb_hit_t *regs);
+int mb_squeeze_a(void *km, int n_regs, mb_hit_t *regs, mb_anchor_t *a);
+void mb_split_hit(mb_hit_t *r, mb_hit_t *r2, int n, int qlen, mb_anchor_t *a, const l2b_t *l2b);
+void mb_set_mapq(void *km, int32_t qlen, int n_regs, mb_hit_t *regs, int min_chain_sc, int match_sc, int is_sr, int max_sr_len);
+
+mb_hit_t *mb_map_sai(const mb_opt_t *opt, const mb_idx_t *idx, int64_t qlen, const char *seq, l2b_meth_t mt, mb_sai_v *u, int32_t *n_hit_, mb_tbuf_t *b, const char *qname);
+
+void radix_sort_mb64(uint64_t *st, uint64_t *en);
+void radix_sort_mb128x(mb128_t *st, mb128_t *en);
+
+// in cs.c
+void mb_write_cs_ds(void *km, kstring_t *s, const uint8_t *tseq, const uint8_t *qseq, const mb_hit_t *r, int is_ds);
+void mb_write_MD(void *km, kstring_t *s, const uint8_t *tseq, const uint8_t *qseq, const mb_hit_t *r);
+
+// defined in format.c
+void mb_fmt_paf(kstring_t *s, const l2b_t *l2b, const mb_bseq1_t *t, const mb_hit_t *p, uint64_t opt_flag, int n_seg, int seg_idx);
+int mb_fmt_sam_hdr(kstring_t *str, const l2b_t *idx, const char *rg, const char *ver, int argc, char *argv[]);
+void mb_format(void *km, kstring_t *s, const l2b_t *l2b, const mb_bseq1_t *t, int32_t n_seg, const int32_t *n_hit, mb_hit_t *const*hit, int32_t hit_idx, const mb_opt_t *opt, int seg_idx, int32_t mate_qlen);
+char *mb_escape(char *s);
+
+// defined in align.c
+mb_hit_t *mb_align_skeleton(void *km, const mb_opt_t *opt, const mb_idx_t *mi, int qlen, const uint8_t *seq, l2b_meth_t mt, int *n_regs_, mb_hit_t *regs, mb_anchor_t *a);
+void mb_append_cigar(mb_hit_t *r, uint32_t n_cigar, const uint32_t *cigar);
+void mb_update_extra(void *km, mb_hit_t *r, const uint8_t *qseq, const uint8_t *tseq, const int8_t *mat, int8_t q, int8_t e, uint64_t opt_flag, int log_gap);
+
+// defined in pe.c
+void mb_pestat(void *km, const mb_opt_t *opt, int32_t n_seg, const int32_t *seg_off, const int32_t *seg_cnt, const int32_t *n_hit, mb_hit_t *const *hit, mb_pestat_t pes[4]);
+void mb_pair(void *km, const mb_opt_t *opt, const l2b_t *l2b, int32_t n_hit[2], mb_hit_t *hit[2], const mb_pestat_t pes[4], int32_t qlen[2], char *const qseq[2]);
+
+// Fast log2 approximation (from minimap2)
+static inline float mb_log2(float x) // NB: this doesn't work when x<2
+{
+	union { float f; uint32_t i; } z = { x };
+	float log_2 = ((z.i >> 23) & 255) - 128;
+	z.i &= ~(255 << 23);
+	z.i += 127 << 23;
+	log_2 += (-0.34484843f * z.f + 2.02466578f) * z.f - 0.67487759f;
+	return log_2;
+}
+
+static inline uint64_t mb_hash64(uint64_t x)
+{
+	x ^= x >> 30;
+	x *= 0xbf58476d1ce4e5b9ULL;
+	x ^= x >> 27;
+	x *= 0x94d049bb133111ebULL;
+	x ^= x >> 31;
+	return x;
+}
+
+static inline uint32_t mb_hash_str(const char *s)
+{
+	uint32_t h = 2166136261U;
+	const unsigned char *t = (const unsigned char*)s;
+	for (; *t; ++t)
+		h ^= *t, h *= 16777619;
+	return h;
+}
+
+static inline void mb_seq_rev(uint32_t len, uint8_t *seq)
+{
+	kom_reverse(uint8_t, len, seq);
+}
+
+static inline int32_t mb_is_sr_mode(const mb_opt_t *opt, int32_t qlen)
+{
+	return (opt->flag & MB_F_LONG) || ((opt->flag & MB_F_ADAP) && qlen > opt->max_sr_len)? 0 : 1;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/minibwa/minibwa/minibwa.h

@@ -0,0 +1,176 @@
+#ifndef MINIBWA_H
+#define MINIBWA_H
+
+#include <stdint.h>
+
+#define MB_VERSION "0.6-r416"
+
+#define MB_F_PAF              (0x1LL)       // output in the PAF format
+#define MB_F_NO_UNMAP         (0x2LL)       // output unmapped query sequences
+#define MB_F_COPY_COMMENT     (0x4LL)       // copy FASTX comments to output
+#define MB_F_PE               (0x8LL)       // paired-end mode
+#define MB_F_LONG             (0x10LL)      // long-sequence mode
+#define MB_F_EQX              (0x20LL)      // = in CIGAR
+#define MB_F_NO_KALLOC        (0x40LL)      // disable kalloc
+#define MB_F_NO_ALN           (0x80LL)      // skip base alignment
+#define MB_F_PE_PREDEF        (0x100LL)     // use predefined PE
+#define MB_F_WRITE_DS         (0x200LL)     // write ds:Z
+#define MB_F_WRITE_CS         (0x400LL)     // write cs:Z
+#define MB_F_WRITE_MD         (0x800LL)     // write MD:Z
+#define MB_F_2ND_SEQ          (0x1000LL)    // in SAM, write SEQ for secondary alignments
+#define MB_F_SUPP_SOFT        (0x2000LL)    // in SAM, use soft-clips for supplementary alignments
+#define MB_F_ADAP             (0x4000LL)    // adaptive mode
+#define MB_F_PRIMARY5         (0x8000LL)    // for Hi-C
+#define MB_F_NO_PAIRING       (0x10000LL)   // don't pair reads
+#define MB_F_METH             (0x20000LL)   // methylation mode
+
+#define MB_CIGAR_MATCH      0
+#define MB_CIGAR_INS        1
+#define MB_CIGAR_DEL        2
+#define MB_CIGAR_N_SKIP     3
+#define MB_CIGAR_SOFTCLIP   4
+#define MB_CIGAR_HARDCLIP   5
+#define MB_CIGAR_PADDING    6
+#define MB_CIGAR_EQ_MATCH   7
+#define MB_CIGAR_X_MISMATCH 8
+
+#define MB_CIGAR_STR  "MIDNSHP=XB"
+
+typedef struct {
+	uint64_t flag;
+	// seeding options
+	int32_t min_len; // min seed length
+	int32_t max_sub_occ; // look for shorter seed if smem occ below this value
+	int32_t max_occ; // max interval occurrence
+	// general algorithm options
+	int32_t bw, bw_long; // bandwidth
+	int32_t max_gap; // break a chain if there are no seeds in a max_gap window
+	int32_t max_sr_len; // in the adaptive sr mode, treat reads longer than this as long reads
+	// chaining options
+	int32_t max_chain_skip;
+	int32_t max_chain_iter;
+	int32_t min_chain_score; // min chaining score
+	float chain_gap_scale;
+	// hit processing options
+	float mask_level;
+	int32_t mask_len;
+	float pri_ratio;
+	int32_t best_n;
+	// alignment options
+	int32_t a, b;     // match, mismatch
+	int32_t b_ts;     // transition mismatch
+	int32_t b_ambi;   // ambiguous mismatch
+	int32_t q, q2;    // gap open, long gap open
+	int32_t e, e2;    // gap extension, long gap extension
+	int32_t end_bonus;
+	int32_t min_dp_max; // min_dp_max*a is the min score
+	int32_t zdrop;
+	int32_t zdrop_inv;
+	int32_t min_ksw_len;
+	// pairing options
+	int32_t max_pe_ins;
+	int32_t max_rescue;
+	int32_t pen_unpair;
+	int32_t pe_avg, pe_std, pe_lo, pe_hi;
+	// input/output options
+	int32_t sb_len;   // number of bases for batch smem
+	int32_t sb_seq;   // number of sequences for batch smem
+	int32_t n_thread; // number of worker threads, excluding I/O threads
+	int32_t out_n;    // max number of secondary alignments to output
+	float out_s;
+	int32_t seed;
+	int32_t xa_max;
+	int64_t mb_size;  // mini-batch size
+	int64_t max_mb_size;
+	int64_t max_sw_mat;
+	int64_t cap_kalloc;
+} mb_opt_t;
+
+struct mb_idx_s;
+typedef struct mb_idx_s mb_idx_t;
+
+typedef struct {
+	uint32_t cap;               // the capacity of cigar[]
+	int32_t dp_score, dp_max0;  // DP score; score of the max-scoring segment
+	int32_t dp_max, dp_max2;    // adjusted score and second best score for mapQ
+	uint32_t n_ambi:31, cs:1;   // number of ambiguous bases;
+	int32_t n_cigar;            // number of cigar operations in cigar[]
+	uint32_t cigar[];           // cs/MD is appended at the end
+} mb_extra_t;
+
+#define MB_PARENT_UNSET   (-1)
+#define MB_PARENT_TMP_PRI (-2)
+
+typedef struct {
+	int64_t tid;            // target ID (the original tid, NOT stranded)
+	int64_t ts, te;         // target start and end
+	int32_t id;             // ID for internal uses
+	int32_t cnt;            // number of anchors
+	int32_t score, score0;  // chaining score; score0 is the original chaining score
+	int32_t as;             // offset in the a[] array (for internal uses only)
+	int32_t qs, qe;         // query start and end
+	int32_t parent, n_sub, subsc;
+	int32_t mlen, blen;
+	int32_t mapq;
+	uint32_t hash;
+	uint32_t rev:1, proper_pair:1, sam_pri:1, flt:1, inv:1, split:2, split_inv:1, rescued:1, frac_high:8, seed_ratio:8, dummy:7;
+	mb_extra_t *p;
+} mb_hit_t;
+
+struct mb_tbuf_s;
+typedef struct mb_tbuf_s mb_tbuf_t;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+mb_idx_t *mb_idx_load(const char *prefix, int32_t is_meth);
+mb_idx_t *mb_idx_load_mmap(const char *prefix, int32_t is_meth, int preload);
+void mb_idx_destroy(mb_idx_t *idx);
+const char *mb_idx_ctg_name(const mb_idx_t *idx, int32_t tid);
+int64_t mb_idx_ctg_len(const mb_idx_t *idx, int32_t tid);
+
+void mb_opt_init(mb_opt_t *opt);
+int mb_opt_preset(mb_opt_t *opt, const char *preset);
+
+mb_tbuf_t *mb_tbuf_init(int no_kalloc);
+void mb_tbuf_destroy(mb_tbuf_t *b);
+int32_t mb_tbuf_reset(mb_tbuf_t *b, int64_t max_block_size);
+
+/**
+ * Align one sequence
+ *
+ * @param opt        options, typically initialized by mb_opt_init()
+ * @param idx        index
+ * @param qlen       query length
+ * @param seq        query sequence, ASCII or 01/2/3 encoded
+ * @param mt         methylation type: 0 for unmethylated, 1 for read1 (C-to-T) and 2 for read2 (G-to-A)
+ * @param n_hit      (out) number of hits
+ * @param b          thread buffer; can be NULL
+ * @param qname      query name
+ *
+ * @return hit array
+ */
+mb_hit_t *mb_map(const mb_opt_t *opt, const mb_idx_t *idx, int32_t qlen, const char *seq, int32_t mt, int32_t *n_hit, mb_tbuf_t *b, const char *qname);
+
+/**
+ * Align a set of sequences in batch
+ *
+ * @param opt        options, typically initialized by mb_opt_init()
+ * @param idx        index
+ * @param n_seq      number of sequences
+ * @param qlen       query lengths, of size n_seq
+ * @param seq        query sequences, ASCII or 01/2/3 encoded, of size n_seq
+ * @param n_hit      (out) number of hits, of size n_seq
+ * @param b          thread buffer; can be NULL
+ * @param qname      query name, of size n_seq
+ *
+ * @return hits, of size n_seq
+ */
+mb_hit_t **mb_map_batch(const mb_opt_t *opt, const mb_idx_t *idx, int32_t n_seq, const int32_t *qlen, const char **seq, int32_t *n_hit, mb_tbuf_t *b, const char **qname);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/minibwa/minibwa/options.c

@@ -0,0 +1,116 @@
+#include <string.h>
+#include <math.h>
+#include "minibwa.h"
+
+static void mb_opt_reset(mb_opt_t *opt)
+{
+	memset(opt, 0, sizeof(mb_opt_t));
+	opt->min_len = 19;
+	opt->max_sr_len = 325;
+	// seeding options
+	opt->max_sub_occ = 10;
+	opt->max_occ = 250;
+	// chaining options
+	opt->max_chain_skip = 25;
+	opt->max_chain_iter = 5000;
+	opt->chain_gap_scale = 0.8f;
+	opt->bw_long = 20000;
+	opt->pri_ratio = 0.5f;
+	// hit processing options
+	opt->mask_level = 0.5f;
+	opt->mask_len = 0x7fffffff;
+	// alignment options
+	opt->a = 2,  opt->b = 8;
+	opt->q = 12, opt->q2 = 23;
+	opt->e = 2,  opt->e2 = 1;
+	opt->b_ambi = 1;
+	// pairing options
+	opt->max_pe_ins = 10000;
+	opt->max_rescue = 10;
+	opt->pen_unpair = 17;
+	opt->pe_avg = 400, opt->pe_std = 100;
+	opt->pe_lo = 50, opt->pe_hi = 800;
+	// I/O options
+	opt->sb_len = 1000000;
+	opt->sb_seq = 24;
+	opt->n_thread = 1;
+	opt->seed = 11;
+	opt->out_s = 0.8f;
+	opt->xa_max = 5;
+	opt->max_sw_mat = 100000000;
+	opt->cap_kalloc = 1UL<<28;
+	opt->max_mb_size = 1000000000;
+#ifndef HAVE_KALLOC
+	opt->flag |= MB_F_NO_KALLOC;
+#endif
+}
+
+void mb_opt_init(mb_opt_t *opt)
+{
+	mb_opt_reset(opt);
+	mb_opt_preset(opt, "adap");
+}
+
+int mb_opt_preset(mb_opt_t *opt, const char *preset)
+{
+	mb_opt_reset(opt);
+	if (strcmp(preset, "sr") == 0 || strcmp(preset, "adap") == 0) {
+		opt->flag |= MB_F_PE;
+		if (strcmp(preset, "adap") == 0) opt->flag |= MB_F_ADAP;
+		opt->min_dp_max = 30;
+		opt->flag |= MB_F_ADAP;
+		opt->bw = 100;
+		opt->max_gap = 100;
+		opt->zdrop = 80;
+		opt->zdrop_inv = 80;
+		opt->best_n = 50;
+		opt->end_bonus = 10;
+		opt->min_chain_score = 25;
+		opt->min_ksw_len = 20;
+		opt->mb_size = 100000000;
+	} else if (strcmp(preset, "lr") == 0) {
+		opt->flag |= MB_F_LONG;
+		opt->flag &= ~MB_F_PE;
+		opt->min_dp_max = 50;
+		opt->bw = 500;
+		opt->max_gap = 5000;
+		opt->zdrop = 400;
+		opt->zdrop_inv = 240;
+		opt->best_n = 5;
+		opt->end_bonus = -1;
+		opt->min_chain_score = 40;
+		opt->min_ksw_len = 200;
+		opt->mb_size = 500000000;
+	} else {
+		return -1;
+	}
+	return 0;
+}
+
+void mb_opt_adap(const mb_opt_t *opt0, int32_t len, mb_opt_t *opt)
+{
+	const int32_t min_len = 100, mid_len = 2000;
+	double a, b;
+	*opt = *opt0;
+	if (!(opt0->flag & MB_F_ADAP)) return;
+	a = -log(0.5) / (mid_len - min_len);
+	b = exp(-a * ((len > min_len? len : min_len) - min_len));
+	if (opt0->max_gap < 5000) {
+		opt->max_gap = (int32_t)(5000 - (5000 - opt0->max_gap) * b + .499);
+		if (opt->max_gap > len) opt->max_gap = len;
+	}
+	if (opt0->bw < 500)
+		opt->bw = (int32_t)(500 - (500 - opt0->bw) * b + .499);
+	if (opt->bw_long > len * 5) opt->bw_long = len * 5;
+	if (opt->bw_long < opt->bw) opt->bw_long = opt->bw;
+	if (opt0->zdrop < 400)
+		opt->zdrop = (int32_t)(400 - (400 - opt0->zdrop) * b + .499);
+	if (opt0->zdrop_inv < 240)
+		opt->zdrop_inv = (int32_t)(240 - (240 - opt0->zdrop_inv) * b + .499);
+	if (opt0->best_n > 5)
+		opt->best_n = (int32_t)((opt0->best_n - 5) * b + 5 + .499);
+	if (opt0->min_dp_max < 50)
+		opt->min_dp_max = (int32_t)(50 - (50 - opt0->min_dp_max) * b + .499);
+	if (opt0->min_chain_score < 40)
+		opt->min_chain_score = (int32_t)(40 - (40 - opt0->min_chain_score) * b + .499);
+}