bio-bwa 0.2.0

data/ext/bwtsw2_main.c

@@ -0,0 +1,100 @@
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <math.h>
+#include "bwt.h"
+#include "bwtsw2.h"
+#include "utils.h"
+
+int bwa_bwtsw2(int argc, char *argv[])
+{
+	bsw2opt_t *opt;
+	bwt_t *target[2];
+	char buf[1024];
+	bntseq_t *bns;
+	int c;
+
+	opt = bsw2_init_opt();
+	srand48(11);
+	optind = 1;
+	while ((c = getopt(argc, argv, "q:r:a:b:t:T:w:d:z:m:y:s:c:N:Hf:")) >= 0) {
+		switch (c) {
+		case 'q': opt->q = atoi(optarg); break;
+		case 'r': opt->r = atoi(optarg); break;
+		case 'a': opt->a = atoi(optarg); break;
+		case 'b': opt->b = atoi(optarg); break;
+		case 'w': opt->bw = atoi(optarg); break;
+		case 'T': opt->t = atoi(optarg); break;
+		case 't': opt->n_threads = atoi(optarg); break;
+		case 'z': opt->z = atoi(optarg); break;
+		case 'y': opt->yita = atof(optarg); break;
+		case 's': opt->is = atoi(optarg); break;
+		case 'm': opt->mask_level = atof(optarg); break;
+		case 'c': opt->coef = atof(optarg); break;
+		case 'N': opt->t_seeds = atoi(optarg); break;
+		case 'H': opt->hard_clip = 1; break;
+		case 'f': xreopen(optarg, "w", stdout); break;
+		}
+	}
+	opt->qr = opt->q + opt->r;
+
+	if (optind + 2 > argc) {
+		fprintf(stderr, "\n");
+		fprintf(stderr, "Usage:   bwa bwasw [options] <target.prefix> <query.fa>\n\n");
+		fprintf(stderr, "Options: -a INT   score for a match [%d]\n", opt->a);
+		fprintf(stderr, "         -b INT   mismatch penalty [%d]\n", opt->b);
+		fprintf(stderr, "         -q INT   gap open penalty [%d]\n", opt->q);
+		fprintf(stderr, "         -r INT   gap extension penalty [%d]\n", opt->r);
+//		fprintf(stderr, "         -y FLOAT error recurrence coef. (4..16) [%.1f]\n", opt->yita);
+		fprintf(stderr, "\n");
+		fprintf(stderr, "         -t INT   number of threads [%d]\n", opt->n_threads);
+		fprintf(stderr, "         -s INT   size of a chunk of reads [%d]\n", opt->chunk_size);
+		fprintf(stderr, "\n");
+		fprintf(stderr, "         -w INT   band width [%d]\n", opt->bw);
+		fprintf(stderr, "         -m FLOAT mask level [%.2f]\n", opt->mask_level);
+		fprintf(stderr, "\n");
+		fprintf(stderr, "         -T INT   score threshold divided by a [%d]\n", opt->t);
+		fprintf(stderr, "         -s INT   maximum seeding interval size [%d]\n", opt->is);
+		fprintf(stderr, "         -z INT   Z-best [%d]\n", opt->z);
+		fprintf(stderr, "         -N INT   # seeds to trigger reverse alignment [%d]\n", opt->t_seeds);
+		fprintf(stderr, "         -c FLOAT coefficient of length-threshold adjustment [%.1f]\n", opt->coef);
+		fprintf(stderr, "         -H       in SAM output, use hard clipping rather than soft\n");
+        fprintf(stderr, "         -f FILE  file to output results to instead of stdout\n\n");
+		fprintf(stderr, "Note: For long Illumina, 454 and Sanger reads, assembly contigs, fosmids and\n");
+		fprintf(stderr, "      BACs, the default setting usually works well. For the current PacBio\n");
+		fprintf(stderr, "      reads (end of 2010), '-b5 -q2 -r1 -z10' is recommended. One may also\n");
+		fprintf(stderr, "      increase '-z' for better sensitivity.\n");
+		fprintf(stderr, "\n");
+
+		if (0) {
+			double c, theta, eps, delta;
+			c = opt->a / log(opt->yita);
+			theta = exp(-opt->b / c) / opt->yita;
+			eps = exp(-opt->q / c);
+			delta = exp(-opt->r / c);
+			fprintf(stderr, "mismatch: %lf, gap_open: %lf, gap_ext: %lf\n\n",
+					theta, eps, delta);
+		}
+		return 1;
+	}
+
+	// adjust opt for opt->a
+	opt->t *= opt->a;
+	opt->coef *= opt->a;
+
+	strcpy(buf, argv[optind]); target[0] = bwt_restore_bwt(strcat(buf, ".bwt"));
+	strcpy(buf, argv[optind]); bwt_restore_sa(strcat(buf, ".sa"), target[0]);
+	strcpy(buf, argv[optind]); target[1] = bwt_restore_bwt(strcat(buf, ".rbwt"));
+	strcpy(buf, argv[optind]); bwt_restore_sa(strcat(buf, ".rsa"), target[1]);
+	bns = bns_restore(argv[optind]);
+
+	bsw2_aln(opt, bns, target, argv[optind+1]);
+
+	bns_destroy(bns);
+	bwt_destroy(target[0]); bwt_destroy(target[1]);
+	free(opt);
+	fflush(stdout);
+	xreopen("/dev/tty","w",stdout);
+	return 0;
+}

data/ext/cs2nt.c

@@ -0,0 +1,191 @@
+#include <string.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include "bwtaln.h"
+#include "stdaln.h"
+
+/*
+  Here is a delicate example. ref_nt=ATTAAC(RBRBG), read_cs=RBBOG. If we
+  decode as ATTGAC(RBGOG), there are one color change and one nt change;
+  if we decode as ATTAAC(RBRBG), there are two color changes.
+
+  In DP, if color quality is smaller than COLOR_MM, we will use COLOR_MM
+  as the penalty; otherwise, we will use color quality as the
+  penalty. This means we always prefer two consistent color changes over
+  a nt change, but if a color has high quality, we may prefer one nt
+  change.
+
+  In the above example, the penalties of the two types of decoding are
+  q(B)+25 and q(B)+q(O), respectively. If q(O)>25, we prefer the first;
+  otherwise the second. Note that no matter what we choose, the fourth
+  base will get a low nt quality.
+ */
+
+#define COLOR_MM 19
+#define NUCL_MM  25
+
+static const int nst_ntnt2cs_table[] = { 4, 0, 0, 1, 0, 2, 3, 4, 0, 3, 2, 4, 1, 4, 4, 4 };
+
+/*
+  {A,C,G,T,N} -> {0,1,2,3,4}
+  nt_ref[0..size]: nucleotide reference: 0/1/2/3/4
+  cs_read[0..size-1]: color read+qual sequence: base<<6|qual; qual==63 for N
+  nt_read[0..size]: nucleotide read sequence: 0/1/2/3 (returned)
+  btarray[0..4*size]: backtrack array (working space)
+ */
+void cs2nt_DP(int size, const uint8_t *nt_ref, const uint8_t *cs_read, uint8_t *nt_read, uint8_t *btarray)
+{
+	int h[8], curr, last;
+	int x, y, xmin, hmin, k;
+
+	// h[0..3] and h[4..7] are the current and last best score array, depending on curr and last
+
+	// recursion: initial value
+	if (nt_ref[0] >= 4) memset(h, 0, sizeof(int) << 2);
+	else {
+		for (x = 0; x != 4; ++x) h[x] = NUCL_MM;
+		h[nt_ref[0]] = 0;
+	}
+	// recursion: main loop
+	curr = 1; last = 0;
+	for (k = 1; k <= size; ++k) {
+		for (x = 0; x != 4; ++x) {
+			int min = 0x7fffffff, ymin = 0;
+			for (y = 0; y != 4; ++y) {
+				int s = h[last<<2|y];
+				if ((cs_read[k-1]&0x3f) != 63 && cs_read[k-1]>>6 != nst_ntnt2cs_table[1<<x|1<<y])
+					s += ((cs_read[k-1]&0x3f) < COLOR_MM)? COLOR_MM : (cs_read[k-1]&0x3f); // color mismatch
+				if (nt_ref[k] < 4 && nt_ref[k] != x) s += NUCL_MM; // nt mismatch
+				if (s < min) {
+					min = s; ymin = y;
+				}
+			}
+			h[curr<<2|x] = min; btarray[k<<2|x] = ymin;
+		}
+		last = curr; curr = 1 - curr; // swap
+	}
+	// back trace
+	hmin = 0x7fffffff; xmin = 0;
+	for (x = 0; x != 4; ++x) {
+		if (h[last<<2|x] < hmin) {
+			hmin = h[last<<2|x]; xmin = x;
+		}
+	}
+	nt_read[size] = xmin;
+	for (k = size - 1; k >= 0; --k)
+		nt_read[k] = btarray[(k+1)<<2 | nt_read[k+1]];
+}
+/*
+  nt_read[0..size]: nucleotide read sequence: 0/1/2/3
+  cs_read[0..size-1]: color read+qual sequence: base<<6|qual; qual==63 for N
+  tarray[0..size*2-1]: temporary array
+ */
+uint8_t *cs2nt_nt_qual(int size, const uint8_t *nt_read, const uint8_t *cs_read, uint8_t *tarray)
+{
+	int k, c1, c2;
+	uint8_t *t2array = tarray + size;
+	// get the color sequence of nt_read
+	c1 = nt_read[0];
+	for (k = 1; k <= size; ++k) {
+		c2 = nt_read[k]; // in principle, there is no 'N' in nt_read[]; just in case
+		tarray[k-1] = (c1 >= 4 || c2 >= 4)? 4 : nst_ntnt2cs_table[1<<c1 | 1<<c2];
+		c1 = c2;
+	}
+	for (k = 1; k != size; ++k) {
+		int q = 0;
+		if (tarray[k-1] == cs_read[k-1]>>6 && tarray[k] == cs_read[k]>>6) {
+			q = (int)(cs_read[k-1]&0x3f) + (int)(cs_read[k]&0x3f) + 10;
+		} else if (tarray[k-1] == cs_read[k-1]>>6) {
+			q = (int)(cs_read[k-1]&0x3f) - (int)(cs_read[k]&0x3f);
+		} else if (tarray[k] == cs_read[k]>>6) {
+			q = (int)(cs_read[k]&0x3f) - (int)(cs_read[k-1]&0x3f);
+		} // else, q = 0
+		if (q < 0) q = 0;
+		if (q > 60) q = 60;
+		t2array[k] = nt_read[k]<<6 | q;
+		if ((cs_read[k-1]&0x3f) == 63 || (cs_read[k]&0x3f) == 63) t2array[k] = 0;
+	}
+	return t2array + 1; // of size-2
+}
+
+// this function will be called when p->seq has been reversed by refine_gapped()
+void bwa_cs2nt_core(bwa_seq_t *p, bwtint_t l_pac, ubyte_t *pac)
+{
+	uint8_t *ta, *nt_read, *btarray, *tarray, *nt_ref, *cs_read, *new_nt_read;
+	int i, len;
+	uint8_t *seq;
+
+	// set temporary arrays
+	if (p->type == BWA_TYPE_NO_MATCH) return;
+	len = p->len + p->n_gapo + p->n_gape + 100; // leave enough space
+	ta = (uint8_t*)malloc(len * 7);
+	nt_ref = ta;
+	cs_read = nt_ref + len;
+	nt_read = cs_read + len;
+	btarray = nt_read + len;
+	tarray = nt_read + len;
+
+#define __gen_csbase(_cs, _i, _seq) do {							\
+		int q = p->qual[p->strand? p->len - 1 - (_i) : (_i)] - 33;	\
+		if (q > 60) q = 60;											\
+		if (_seq[_i] > 3) q = 63;									\
+		(_cs) = _seq[_i]<<6 | q;									\
+	} while (0)
+
+	// generate len, nt_ref[] and cs_read
+	seq = p->strand? p->rseq : p->seq;
+	nt_ref[0] = p->pos? bns_pac(pac, p->pos-1) : 4;
+	if (p->cigar == 0) { // no gap or clipping
+		len = p->len;
+		for (i = 0; i < p->len; ++i) {
+			__gen_csbase(cs_read[i], i, seq);
+			nt_ref[i+1] = bns_pac(pac, p->pos + i);
+		}
+	} else {
+		int k, z;
+		bwtint_t x, y;
+		x = p->pos; y = 0;
+		for (k = z = 0; k < p->n_cigar; ++k) {
+			int l = __cigar_len(p->cigar[k]);
+			if (__cigar_op(p->cigar[k]) == FROM_M) {
+				for (i = 0; i < l; ++i, ++x, ++y) {
+					__gen_csbase(cs_read[z], y, seq);
+					nt_ref[z+1] = bns_pac(pac, x);
+					++z;
+				}
+			} else if (__cigar_op(p->cigar[k]) == FROM_I) {
+				for (i = 0; i < l; ++i, ++y) {
+					__gen_csbase(cs_read[z], y, seq);
+					nt_ref[z+1] = 4;
+					++z;
+				}
+			} else if (__cigar_op(p->cigar[k]) == FROM_S) y += l;
+			else x += l;
+		}
+		len = z;
+	}
+
+	cs2nt_DP(len, nt_ref, cs_read, nt_read, btarray);
+	new_nt_read = cs2nt_nt_qual(len, nt_read, cs_read, tarray);
+
+	// update p
+	p->len = p->full_len = len - 1;
+	for (i = 0; i < p->len; ++i) {
+		if ((new_nt_read[i]&0x3f) == 63) {
+			p->qual[i] = 33; seq[i] = 4;
+		} else {
+			p->qual[i] = (new_nt_read[i]&0x3f) + 33;
+			seq[i] = new_nt_read[i]>>6;
+		}
+	}
+	p->qual[p->len] = seq[p->len] = 0;
+	if (p->strand) {
+		memcpy(p->seq, seq, p->len);
+		seq_reverse(p->len, p->seq, 1);
+		seq_reverse(p->len, p->qual, 0);
+	} else {
+		memcpy(p->rseq, seq, p->len);
+		seq_reverse(p->len, p->rseq, 1);
+	}
+	free(ta);
+}

data/ext/is.c

@@ -0,0 +1,218 @@
+/*
+ * sais.c for sais-lite
+ * Copyright (c) 2008 Yuta Mori All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <stdlib.h>
+
+typedef unsigned char ubyte_t;
+#define chr(i) (cs == sizeof(int) ? ((const int *)T)[i]:((const unsigned char *)T)[i])
+
+/* find the start or end of each bucket */
+static void getCounts(const unsigned char *T, int *C, int n, int k, int cs)
+{
+	int i;
+	for (i = 0; i < k; ++i) C[i] = 0;
+	for (i = 0; i < n; ++i) ++C[chr(i)];
+}
+static void getBuckets(const int *C, int *B, int k, int end)
+{
+	int i, sum = 0;
+	if (end) {
+		for (i = 0; i < k; ++i) {
+			sum += C[i];
+			B[i] = sum;
+		}
+	} else {
+		for (i = 0; i < k; ++i) {
+			sum += C[i];
+			B[i] = sum - C[i];
+		}
+	}
+}
+
+/* compute SA */
+static void induceSA(const unsigned char *T, int *SA, int *C, int *B, int n, int k, int cs)
+{
+	int *b, i, j;
+	int  c0, c1;
+	/* compute SAl */
+	if (C == B) getCounts(T, C, n, k, cs);
+	getBuckets(C, B, k, 0);	/* find starts of buckets */
+	j = n - 1;
+	b = SA + B[c1 = chr(j)];
+	*b++ = ((0 < j) && (chr(j - 1) < c1)) ? ~j : j;
+	for (i = 0; i < n; ++i) {
+		j = SA[i], SA[i] = ~j;
+		if (0 < j) {
+			--j;
+			if ((c0 = chr(j)) != c1) {
+				B[c1] = b - SA;
+				b = SA + B[c1 = c0];
+			}
+			*b++ = ((0 < j) && (chr(j - 1) < c1)) ? ~j : j;
+		}
+	}
+	/* compute SAs */
+	if (C == B) getCounts(T, C, n, k, cs);
+	getBuckets(C, B, k, 1);	/* find ends of buckets */
+	for (i = n - 1, b = SA + B[c1 = 0]; 0 <= i; --i) {
+		if (0 < (j = SA[i])) {
+			--j;
+			if ((c0 = chr(j)) != c1) {
+				B[c1] = b - SA;
+				b = SA + B[c1 = c0];
+			}
+			*--b = ((j == 0) || (chr(j - 1) > c1)) ? ~j : j;
+		} else SA[i] = ~j;
+	}
+}
+
+/*
+ * find the suffix array SA of T[0..n-1] in {0..k-1}^n use a working
+ * space (excluding T and SA) of at most 2n+O(1) for a constant alphabet
+ */
+static int sais_main(const unsigned char *T, int *SA, int fs, int n, int k, int cs)
+{
+	int *C, *B, *RA;
+	int  i, j, c, m, p, q, plen, qlen, name;
+	int  c0, c1;
+	int  diff;
+
+	/* stage 1: reduce the problem by at least 1/2 sort all the
+	 * S-substrings */
+	if (k <= fs) {
+		C = SA + n;
+		B = (k <= (fs - k)) ? C + k : C;
+	} else if ((C = B = (int *) malloc(k * sizeof(int))) == NULL) return -2;
+	getCounts(T, C, n, k, cs);
+	getBuckets(C, B, k, 1);	/* find ends of buckets */
+	for (i = 0; i < n; ++i) SA[i] = 0;
+	for (i = n - 2, c = 0, c1 = chr(n - 1); 0 <= i; --i, c1 = c0) {
+		if ((c0 = chr(i)) < (c1 + c)) c = 1;
+		else if (c != 0) SA[--B[c1]] = i + 1, c = 0;
+	}
+	induceSA(T, SA, C, B, n, k, cs);
+	if (fs < k) free(C);
+	/* compact all the sorted substrings into the first m items of SA
+	 * 2*m must be not larger than n (proveable) */
+	for (i = 0, m = 0; i < n; ++i) {
+		p = SA[i];
+		if ((0 < p) && (chr(p - 1) > (c0 = chr(p)))) {
+			for (j = p + 1; (j < n) && (c0 == (c1 = chr(j))); ++j);
+			if ((j < n) && (c0 < c1)) SA[m++] = p;
+		}
+	}
+	for (i = m; i < n; ++i) SA[i] = 0;	/* init the name array buffer */
+	/* store the length of all substrings */
+	for (i = n - 2, j = n, c = 0, c1 = chr(n - 1); 0 <= i; --i, c1 = c0) {
+		if ((c0 = chr(i)) < (c1 + c)) c = 1;
+		else if (c != 0) {
+			SA[m + ((i + 1) >> 1)] = j - i - 1;
+			j = i + 1;
+			c = 0;
+		}
+	}
+	/* find the lexicographic names of all substrings */
+	for (i = 0, name = 0, q = n, qlen = 0; i < m; ++i) {
+		p = SA[i], plen = SA[m + (p >> 1)], diff = 1;
+		if (plen == qlen) {
+			for (j = 0; (j < plen) && (chr(p + j) == chr(q + j)); j++);
+			if (j == plen) diff = 0;
+		}
+		if (diff != 0) ++name, q = p, qlen = plen;
+		SA[m + (p >> 1)] = name;
+	}
+
+	/* stage 2: solve the reduced problem recurse if names are not yet
+	 * unique */
+	if (name < m) {
+		RA = SA + n + fs - m;
+		for (i = n - 1, j = m - 1; m <= i; --i) {
+			if (SA[i] != 0) RA[j--] = SA[i] - 1;
+		}
+		if (sais_main((unsigned char *) RA, SA, fs + n - m * 2, m, name, sizeof(int)) != 0) return -2;
+		for (i = n - 2, j = m - 1, c = 0, c1 = chr(n - 1); 0 <= i; --i, c1 = c0) {
+			if ((c0 = chr(i)) < (c1 + c)) c = 1;
+			else if (c != 0) RA[j--] = i + 1, c = 0; /* get p1 */
+		}
+		for (i = 0; i < m; ++i) SA[i] = RA[SA[i]]; /* get index */
+	}
+	/* stage 3: induce the result for the original problem */
+	if (k <= fs) {
+		C = SA + n;
+		B = (k <= (fs - k)) ? C + k : C;
+	} else if ((C = B = (int *) malloc(k * sizeof(int))) == NULL) return -2;
+	/* put all left-most S characters into their buckets */
+	getCounts(T, C, n, k, cs);
+	getBuckets(C, B, k, 1);	/* find ends of buckets */
+	for (i = m; i < n; ++i) SA[i] = 0; /* init SA[m..n-1] */
+	for (i = m - 1; 0 <= i; --i) {
+		j = SA[i], SA[i] = 0;
+		SA[--B[chr(j)]] = j;
+	}
+	induceSA(T, SA, C, B, n, k, cs);
+	if (fs < k) free(C);
+	return 0;
+}
+
+/**
+ * Constructs the suffix array of a given string.
+ * @param T[0..n-1] The input string.
+ * @param SA[0..n] The output array of suffixes.
+ * @param n The length of the given string.
+ * @return 0 if no error occurred
+ */
+int is_sa(const ubyte_t *T, int *SA, int n)
+{
+	if ((T == NULL) || (SA == NULL) || (n < 0)) return -1;
+	SA[0] = n;
+	if (n <= 1) {
+		if (n == 1) SA[1] = 0;
+		return 0;
+	}
+	return sais_main(T, SA+1, 0, n, 256, 1);
+}
+
+/**
+ * Constructs the burrows-wheeler transformed string of a given string.
+ * @param T[0..n-1] The input string.
+ * @param n The length of the given string.
+ * @return The primary index if no error occurred, -1 or -2 otherwise.
+ */
+int is_bwt(ubyte_t *T, int n)
+{
+	int *SA, i, primary = 0;
+	SA = (int*)calloc(n+1, sizeof(int));
+	is_sa(T, SA, n);
+
+	for (i = 0; i <= n; ++i) {
+		if (SA[i] == 0) primary = i;
+		else SA[i] = T[SA[i] - 1];
+	}
+	for (i = 0; i < primary; ++i) T[i] = SA[i];
+	for (; i < n; ++i) T[i] = SA[i + 1];
+	free(SA);
+	return primary;
+}