minimap2 0.2.27.0 → 0.2.29.0

data/ext/minimap2/jump.c

@@ -0,0 +1,201 @@
+#include <stdio.h>
+#include "mmpriv.h"
+#include "kalloc.h"
+
+#define MM_MIN_EXON_LEN 20
+
+static int32_t mm_jump_check(void *km, const mm_idx_t *mi, int32_t qlen, const uint8_t *qseq0, const mm_reg1_t *r, int32_t ext, int32_t is_left) // TODO: check close N
+{
+	int32_t clip, clen, e = !r->rev ^ !is_left; // 0 for left of the alignment; 1 for right
+	uint32_t cigar;
+	if (!r->p || r->p->n_cigar <= 0) return -1; // only working with CIGAR
+	clip = e == 0? r->qs : qlen - r->qe;
+	cigar = r->p->cigar[is_left? 0 : r->p->n_cigar - 1];
+	clen = (cigar&0xf) == MM_CIGAR_MATCH? cigar>>4 : 0;
+	if (clen <= ext) return -1;
+	if (is_left) {
+		if (clip >= r->rs) return -1; // no space to jump
+	} else {
+		if (clip >= mi->seq[r->rid].len - r->re) return -1; // no space to jump
+	}
+	return 0;
+}
+
+static uint8_t *mm_jump_get_qseq_seq(void *km, int32_t qlen, const uint8_t *qseq0, const mm_reg1_t *r, int32_t is_left, int32_t ql0, uint8_t *qseq)
+{
+	extern unsigned char seq_nt4_table[256];
+	int32_t i, k = 0;
+	if (!r->rev) {
+		if (is_left)
+			for (i = 0; i < ql0; ++i)
+				qseq[k++] = seq_nt4_table[(uint8_t)qseq0[i]];
+		else
+			for (i = qlen - ql0; i < qlen; ++i)
+				qseq[k++] = seq_nt4_table[(uint8_t)qseq0[i]];
+	} else {
+		if (is_left)
+			for (i = qlen - 1; i >= qlen - ql0; --i) {
+				uint8_t c = seq_nt4_table[(uint8_t)qseq0[i]];
+				qseq[k++] = c >= 4? c : 3 - c;
+			}
+		else
+			for (i = ql0 - 1; i >= 0; --i) {
+				uint8_t c = seq_nt4_table[(uint8_t)qseq0[i]];
+				qseq[k++] = c >= 4? c : 3 - c;
+			}
+	}
+	return qseq;
+}
+
+static void mm_jump_split_left(void *km, const mm_idx_t *mi, const mm_mapopt_t *opt, int32_t qlen, const uint8_t *qseq0, mm_reg1_t *r, int32_t ts_strand)
+{
+	uint8_t *tseq = 0, *qseq = 0;
+	int32_t i, n, l, i0, m, mm0;
+	int32_t i0_anno = -1, n_anno = 0, mm0_anno = 0, i0_misc = -1, n_misc = 0, mm0_misc = 0;
+	int32_t ext = 1 + (opt->b + opt->a - 1) / opt->a + 1;
+	int32_t clip = !r->rev? r->qs : qlen - r->qe;
+	int32_t extt = clip < ext? clip : ext;
+	const mm_idx_jjump1_t *a;
+
+	if (mm_jump_check(km, mi, qlen, qseq0, r, ext + MM_MIN_EXON_LEN, 1) < 0) return;
+	a = mm_idx_jump_get(mi, r->rid, r->rs - extt, r->rs + ext, &n);
+	if (n == 0) return;
+
+	for (i = 0; i < n; ++i) { // traverse possible jumps
+		const mm_idx_jjump1_t *ai = &a[i];
+		int32_t tlen, tl1, j, mm1, mm2;
+		assert(ai->off >= r->rs - extt && ai->off <= r->rs + ext);
+		if (ts_strand * ai->strand < 0) continue; // wrong strand
+		if (ai->off2 >= ai->off) continue; // wrong direction
+		if (ai->off - ai->off2 < 6) continue; // intron too small
+		if (ai->off2 < clip + ext) continue; // not long enough
+		if (tseq == 0) {
+			tseq = Kcalloc(km, uint8_t, (clip + ext) * 2); // tseq and qseq are allocated together
+			qseq = tseq + clip + ext;
+			mm_jump_get_qseq_seq(km, qlen, qseq0, r, 1, clip + ext, qseq);
+		}
+		tl1 = clip + (ai->off - r->rs);
+		tlen = mm_idx_getseq2(mi, 0, r->rid, ai->off, r->rs + ext, &tseq[tl1]);
+		assert(tlen == r->rs + ext - ai->off);
+		tlen = mm_idx_getseq2(mi, 0, r->rid, ai->off2 - tl1, ai->off2, tseq);
+		assert(tlen == tl1);
+		for (j = 0, mm1 = 0; j < tl1; ++j)
+			if (qseq[j] != tseq[j] || qseq[j] > 3 || tseq[j] > 3)
+				++mm1;
+		for (mm2 = 0; j < clip + ext; ++j)
+			if (qseq[j] != tseq[j] || qseq[j] > 3 || tseq[j] > 3)
+				++mm2;
+		if (mm1 == 0 && mm2 <= 1) {
+			if (ai->flag & MM_JUNC_ANNO)
+				i0_anno = i, mm0_anno = mm1 + mm2, ++n_anno; // i0 points to the rightmost i
+			else
+				i0_misc = i, mm0_misc = mm1 + mm2, ++n_misc;
+		}
+	}
+	if (n_anno > 0) m = n_anno, i0 = i0_anno, mm0 = mm0_anno;
+	else m = n_misc, i0 = i0_misc, mm0 = mm0_misc;
+	kfree(km, tseq);
+
+	l = m > 0? a[i0].off - r->rs : 0; // may be negative
+	if (m == 1 && clip + l >= opt->jump_min_match) { // add one more exon
+		mm_enlarge_cigar(r, 2);
+		memmove(r->p->cigar + 2, r->p->cigar, r->p->n_cigar * 4);
+		r->p->cigar[0] = (clip + l) << 4 | MM_CIGAR_MATCH;
+		r->p->cigar[1] = (a[i0].off - a[i0].off2) << 4 | MM_CIGAR_N_SKIP;
+		r->p->cigar[2] = ((r->p->cigar[2]>>4) - l) << 4 | MM_CIGAR_MATCH;
+		r->p->n_cigar += 2;
+		r->rs = a[i0].off2 - (clip + l);
+		if (!r->rev) r->qs = 0;
+		else r->qe = qlen;
+		r->blen += clip, r->mlen += clip - mm0;
+		r->p->dp_max0 += (clip - mm0) * opt->a - mm0 * opt->b;
+		r->p->dp_max += (clip - mm0) * opt->a - mm0 * opt->b;
+		if (!r->is_spliced) r->is_spliced = 1, r->p->dp_max += (opt->a + opt->b) + ((opt->a + opt->b) >> 1);
+	} else if (m > 0 && a[i0].off > r->rs) { // trim by l; l is always positive
+		r->p->cigar[0] -= l << 4 | MM_CIGAR_MATCH;
+		r->rs += l;
+		if (!r->rev) r->qs += l;
+		else r->qe -= l;
+	}
+}
+
+static void mm_jump_split_right(void *km, const mm_idx_t *mi, const mm_mapopt_t *opt, int32_t qlen, const uint8_t *qseq0, mm_reg1_t *r, int32_t ts_strand)
+{
+	uint8_t *tseq = 0, *qseq = 0;
+	int32_t i, n, l, i0, m, mm0;
+	int32_t i0_anno = -1, n_anno = 0, mm0_anno = 0, i0_misc = -1, n_misc = 0, mm0_misc = 0;
+	int32_t ext = 1 + (opt->b + opt->a - 1) / opt->a + 1;
+	int32_t clip = !r->rev? qlen - r->qe : r->qs;
+	int32_t extt = clip < ext? clip : ext;
+	const mm_idx_jjump1_t *a;
+
+	if (mm_jump_check(km, mi, qlen, qseq0, r, ext + MM_MIN_EXON_LEN, 0) < 0) return;
+	a = mm_idx_jump_get(mi, r->rid, r->re - ext, r->re + extt, &n);
+	if (n == 0) return;
+
+	for (i = 0; i < n; ++i) { // traverse possible jumps
+		const mm_idx_jjump1_t *ai = &a[i];
+		int32_t tlen, tl1, j, mm1, mm2;
+		assert(ai->off >= r->re - ext && ai->off <= r->re + extt);
+		if (ts_strand * ai->strand < 0) continue; // wrong strand
+		if (ai->off2 <= ai->off) continue; // wrong direction
+		if (ai->off2 - ai->off < 6) continue; // intron too small
+		if (ai->off2 + clip + ext > mi->seq[r->rid].len) continue; // not long enough
+		if (tseq == 0) {
+			tseq = Kcalloc(km, uint8_t, (clip + ext) * 2); // tseq and qseq are allocated together
+			qseq = tseq + clip + ext;
+			mm_jump_get_qseq_seq(km, qlen, qseq0, r, 0, clip + ext, qseq);
+		}
+		tl1 = clip + (r->re - ai->off);
+		tlen = mm_idx_getseq2(mi, 0, r->rid, r->re - ext, ai->off, tseq);
+		assert(tlen == ai->off - (r->re - ext));
+		tlen = mm_idx_getseq2(mi, 0, r->rid, ai->off2, ai->off2 + tl1, &tseq[clip + ext - tl1]);
+		assert(tlen == tl1);
+		for (j = 0, mm2 = 0; j < clip + ext - tl1; ++j)
+			if (qseq[j] != tseq[j] || qseq[j] > 3 || tseq[j] > 3)
+				++mm2;
+		for (mm1 = 0; j < clip + ext; ++j)
+			if (qseq[j] != tseq[j] || qseq[j] > 3 || tseq[j] > 3)
+				++mm1;
+		if (mm1 == 0 && mm2 <= 1) {
+			if (ai->flag & MM_JUNC_ANNO) {
+				if (i0_anno < 0) i0_anno = i, mm0_anno = mm1 + mm2;
+				++n_anno;
+			} else {
+				if (i0_misc < 0) i0_misc = i, mm0_misc = mm1 + mm2;
+				++n_misc;
+			}
+		}
+	}
+	if (n_anno > 0) m = n_anno, i0 = i0_anno, mm0 = mm0_anno;
+	else m = n_misc, i0 = i0_misc, mm0 = mm0_misc;
+	kfree(km, tseq);
+
+	l = m > 0? r->re - a[i0].off : 0; // may be negative
+	if (m == 1 && clip + l >= opt->jump_min_match) { // add one more exon
+		mm_enlarge_cigar(r, 2);
+		r->p->cigar[r->p->n_cigar - 1] = ((r->p->cigar[r->p->n_cigar - 1]>>4) - l) << 4 | MM_CIGAR_MATCH;
+		r->p->cigar[r->p->n_cigar] = (a[i0].off2 - a[i0].off) << 4 | MM_CIGAR_N_SKIP;
+		r->p->cigar[r->p->n_cigar + 1] = (clip + l) << 4 | MM_CIGAR_MATCH;
+		r->p->n_cigar += 2;
+		r->re = a[i0].off2 + (clip + l);
+		if (!r->rev) r->qe = qlen;
+		else r->qs = 0;
+		r->blen += clip, r->mlen += clip - mm0;
+		r->p->dp_max0 += (clip - mm0) * opt->a - mm0 * opt->b;
+		r->p->dp_max += (clip - mm0) * opt->a - mm0 * opt->b;
+		if (!r->is_spliced) r->is_spliced = 1, r->p->dp_max += (opt->a + opt->b) + ((opt->a + opt->b) >> 1);
+	} else if (m > 0 && r->re > a[i0].off) { // trim by l; l is always positive
+		r->p->cigar[r->p->n_cigar - 1] -= l << 4 | MM_CIGAR_MATCH;
+		r->re -= l;
+		if (!r->rev) r->qe -= l;
+		else r->qs += l;
+	}
+}
+
+void mm_jump_split(void *km, const mm_idx_t *mi, const mm_mapopt_t *opt, int32_t qlen, const uint8_t *qseq, mm_reg1_t *r, int32_t ts_strand)
+{
+	assert((opt->flag & MM_F_EQX) == 0);
+	mm_jump_split_left(km,  mi, opt, qlen, qseq, r, ts_strand);
+	mm_jump_split_right(km, mi, opt, qlen, qseq, r, ts_strand);
+}

data/ext/minimap2/kalloc.h

@@ -31,6 +31,14 @@ void km_stat_print(const void *km);
 #define Kcalloc(km, type, cnt)       ((type*)kcalloc((km), (cnt), sizeof(type)))
 #define Krealloc(km, type, ptr, cnt) ((type*)krealloc((km), (ptr), (cnt) * sizeof(type)))
 
+#define Kgrow(km, type, ptr, __i, __m) do { \
+		if ((__i) >= (__m)) { \
+			(__m) = (__i) + 1; \
+			(__m) += ((__m)>>1) + 16; \
+			(ptr) = Krealloc(km, type, ptr, (__m)); \
+		} \
+	} while (0)
+
 #define Kexpand(km, type, a, m) do { \
 		(m) = (m) >= 4? (m) + ((m)>>1) : 16; \
 		(a) = Krealloc(km, type, (a), (m)); \

data/ext/minimap2/ksw2.h

@@ -15,7 +15,8 @@
 #define KSW_EZ_SPLICE_FOR  0x100
 #define KSW_EZ_SPLICE_REV  0x200
 #define KSW_EZ_SPLICE_FLANK 0x400
-#define KSW_EZ_SPLICE_CMPLX 0x800
+#define KSW_EZ_SPLICE_CMPLX 0x800  // use the miniprot splice model
+#define KSW_EZ_SPLICE_SCORE 0x1000 // use splice score
 
 // The subset of CIGAR operators used by ksw code.
 // Use MM_CIGAR_* from minimap.h if you need the full list.
@@ -24,6 +25,8 @@
 #define KSW_CIGAR_DEL    2
 #define KSW_CIGAR_N_SKIP 3
 
+#define KSW_SPSC_OFFSET  64
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -69,7 +72,7 @@ void ksw_extd2_sse(void *km, int qlen, const uint8_t *query, int tlen, const uin
 				   int8_t gapo, int8_t gape, int8_t gapo2, int8_t gape2, int w, int zdrop, int end_bonus, int flag, ksw_extz_t *ez);
 
 void ksw_exts2_sse(void *km, int qlen, const uint8_t *query, int tlen, const uint8_t *target, int8_t m, const int8_t *mat,
-				   int8_t gapo, int8_t gape, int8_t gapo2, int8_t noncan, int zdrop, int8_t junc_bonus, int flag, const uint8_t *junc, ksw_extz_t *ez);
+				   int8_t gapo, int8_t gape, int8_t gapo2, int8_t noncan, int zdrop, int end_bonus, int8_t junc_bonus, int8_t junc_pen, int flag, const uint8_t *junc, ksw_extz_t *ez);
 
 void ksw_extf2_sse(void *km, int qlen, const uint8_t *query, int tlen, const uint8_t *target, int8_t mch, int8_t mis, int8_t e, int w, int xdrop, ksw_extz_t *ez);
 

data/ext/minimap2/ksw2_dispatch.c

@@ -80,17 +80,17 @@ void ksw_extd2_sse(void *km, int qlen, const uint8_t *query, int tlen, const uin
 }
 
 void ksw_exts2_sse(void *km, int qlen, const uint8_t *query, int tlen, const uint8_t *target, int8_t m, const int8_t *mat,
-				   int8_t q, int8_t e, int8_t q2, int8_t noncan, int zdrop, int8_t junc_bonus, int flag, const uint8_t *junc, ksw_extz_t *ez)
+				   int8_t q, int8_t e, int8_t q2, int8_t noncan, int zdrop, int end_bonus, int8_t junc_bonus, int8_t junc_pen, int flag, const uint8_t *junc, ksw_extz_t *ez)
 {
 	extern void ksw_exts2_sse2(void *km, int qlen, const uint8_t *query, int tlen, const uint8_t *target, int8_t m, const int8_t *mat,
-				   int8_t q, int8_t e, int8_t q2, int8_t noncan, int zdrop, int8_t junc_bonus, int flag, const uint8_t *junc, ksw_extz_t *ez);
+				   int8_t q, int8_t e, int8_t q2, int8_t noncan, int zdrop, int end_bonus, int8_t junc_bonus, int8_t junc_pen, int flag, const uint8_t *junc, ksw_extz_t *ez);
 	extern void ksw_exts2_sse41(void *km, int qlen, const uint8_t *query, int tlen, const uint8_t *target, int8_t m, const int8_t *mat,
-				   int8_t q, int8_t e, int8_t q2, int8_t noncan, int zdrop, int8_t junc_bonus, int flag, const uint8_t *junc, ksw_extz_t *ez);
+				   int8_t q, int8_t e, int8_t q2, int8_t noncan, int zdrop, int end_bonus, int8_t junc_bonus, int8_t junc_pen, int flag, const uint8_t *junc, ksw_extz_t *ez);
 	if (ksw_simd < 0) ksw_simd = x86_simd();
 	if (ksw_simd & SIMD_SSE4_1)
-		ksw_exts2_sse41(km, qlen, query, tlen, target, m, mat, q, e, q2, noncan, zdrop, junc_bonus, flag, junc, ez);
+		ksw_exts2_sse41(km, qlen, query, tlen, target, m, mat, q, e, q2, noncan, zdrop, end_bonus, junc_bonus, junc_pen, flag, junc, ez);
 	else if (ksw_simd & SIMD_SSE2)
-		ksw_exts2_sse2(km, qlen, query, tlen, target, m, mat, q, e, q2, noncan, zdrop, junc_bonus, flag, junc, ez);
+		ksw_exts2_sse2(km, qlen, query, tlen, target, m, mat, q, e, q2, noncan, zdrop, end_bonus, junc_bonus, junc_pen, flag, junc, ez);
 	else abort();
 }
 #endif

data/ext/minimap2/ksw2_exts2_sse.c

@@ -24,14 +24,14 @@
 #ifdef KSW_CPU_DISPATCH
 #ifdef __SSE4_1__
 void ksw_exts2_sse41(void *km, int qlen, const uint8_t *query, int tlen, const uint8_t *target, int8_t m, const int8_t *mat,
-				   int8_t q, int8_t e, int8_t q2, int8_t noncan, int zdrop, int8_t junc_bonus, int flag, const uint8_t *junc, ksw_extz_t *ez)
+				   int8_t q, int8_t e, int8_t q2, int8_t noncan, int zdrop, int end_bonus, int8_t junc_bonus, int8_t junc_pen, int flag, const uint8_t *junc, ksw_extz_t *ez)
 #else
 void ksw_exts2_sse2(void *km, int qlen, const uint8_t *query, int tlen, const uint8_t *target, int8_t m, const int8_t *mat,
-				   int8_t q, int8_t e, int8_t q2, int8_t noncan, int zdrop, int8_t junc_bonus, int flag, const uint8_t *junc, ksw_extz_t *ez)
+				   int8_t q, int8_t e, int8_t q2, int8_t noncan, int zdrop, int end_bonus, int8_t junc_bonus, int8_t junc_pen, int flag, const uint8_t *junc, ksw_extz_t *ez)
 #endif
 #else
 void ksw_exts2_sse(void *km, int qlen, const uint8_t *query, int tlen, const uint8_t *target, int8_t m, const int8_t *mat,
-				   int8_t q, int8_t e, int8_t q2, int8_t noncan, int zdrop, int8_t junc_bonus, int flag, const uint8_t *junc, ksw_extz_t *ez)
+				   int8_t q, int8_t e, int8_t q2, int8_t noncan, int zdrop, int end_bonus, int8_t junc_bonus, int8_t junc_pen, int flag, const uint8_t *junc, ksw_extz_t *ez)
 #endif // ~KSW_CPU_DISPATCH
 {
 #define __dp_code_block1 \
@@ -191,7 +191,14 @@ void ksw_exts2_sse(void *km, int qlen, const uint8_t *query, int tlen, const uin
 		}
 	}
 
-	if (junc) {
+	if (junc && (flag & KSW_EZ_SPLICE_SCORE)) { // junc[] keeps the donor score
+		uint8_t donor_val = !!(flag & KSW_EZ_SPLICE_FOR) == !(flag & KSW_EZ_REV_CIGAR)? 0 : 1;
+		for (t = 0; t < tlen - 1; ++t)
+			((int8_t*)donor)[t]    += junc[t+1] == 0xff || (junc[t+1]&1) !=  donor_val? -junc_pen : (int8_t)(junc[t+1]>>1) - (int8_t)KSW_SPSC_OFFSET;
+		for (t = 0; t < tlen - 1; ++t)
+			((int8_t*)acceptor)[t] += junc[t+1] == 0xff || (junc[t+1]&1) != !donor_val? -junc_pen : (int8_t)(junc[t+1]>>1) - (int8_t)KSW_SPSC_OFFSET;
+		//for (t = 0; t < tlen - 1; ++t) if (junc[t+1] != 0xff) fprintf(stderr, "Y2\t%d\t%d\t%c\t%d\n", ((int8_t*)donor)[t], ((int8_t*)acceptor)[t], "DA"[junc[t+1]&1], (int8_t)(junc[t+1]>>1) - (int8_t)KSW_SPSC_OFFSET);
+	} else if (junc) { // junc[] keeps the splice sites
 		if (!(flag & KSW_EZ_REV_CIGAR)) {
 			for (t = 0; t < tlen - 1; ++t)
 				if (((flag & KSW_EZ_SPLICE_FOR) && (junc[t+1]&1)) || ((flag & KSW_EZ_SPLICE_REV) && (junc[t+1]&8)))
@@ -445,10 +452,14 @@ void ksw_exts2_sse(void *km, int qlen, const uint8_t *query, int tlen, const uin
 	if (!approx_max) kfree(km, H);
 	if (with_cigar) { // backtrack
 		int rev_cigar = !!(flag & KSW_EZ_REV_CIGAR);
-		if (!ez->zdropped && !(flag&KSW_EZ_EXTZ_ONLY))
+		if (!ez->zdropped && !(flag&KSW_EZ_EXTZ_ONLY)) {
 			ksw_backtrack(km, 1, rev_cigar, long_thres, (uint8_t*)p, off, off_end, n_col_*16, tlen-1, qlen-1, &ez->m_cigar, &ez->n_cigar, &ez->cigar);
-		else if (ez->max_t >= 0 && ez->max_q >= 0)
+		} else if (!ez->zdropped && (flag&KSW_EZ_EXTZ_ONLY) && ez->mqe + end_bonus > (int)ez->max) {
+			ez->reach_end = 1;
+			ksw_backtrack(km, 1, rev_cigar, long_thres, (uint8_t*)p, off, off_end, n_col_*16, ez->mqe_t, qlen-1, &ez->m_cigar, &ez->n_cigar, &ez->cigar);
+		} else if (ez->max_t >= 0 && ez->max_q >= 0) {
 			ksw_backtrack(km, 1, rev_cigar, long_thres, (uint8_t*)p, off, off_end, n_col_*16, ez->max_t, ez->max_q, &ez->m_cigar, &ez->n_cigar, &ez->cigar);
+		}
 		kfree(km, mem2); kfree(km, off);
 	}
 }

data/ext/minimap2/lchain.c

@@ -149,7 +149,7 @@ mm128_t *mg_lchain_dp(int max_dist_x, int max_dist_y, int bw, int max_skip, int
 					  int is_cdna, int n_seg, int64_t n, mm128_t *a, int *n_u_, uint64_t **_u, void *km)
 { // TODO: make sure this works when n has more than 32 bits
 	int32_t *f, *t, *v, n_u, n_v, mmax_f = 0, max_drop = bw;
-	int64_t *p, i, j, max_ii, st = 0, n_iter = 0;
+	int64_t *p, i, j, max_ii, st = 0;
 	uint64_t *u;
 
 	if (_u) *_u = 0, *n_u_ = 0;
@@ -174,7 +174,6 @@ mm128_t *mg_lchain_dp(int max_dist_x, int max_dist_y, int bw, int max_skip, int
 		for (j = i - 1; j >= st; --j) {
 			int32_t sc;
 			sc = comput_sc(&a[i], &a[j], max_dist_x, max_dist_y, bw, chn_pen_gap, chn_pen_skip, is_cdna, n_seg);
-			++n_iter;
 			if (sc == INT32_MIN) continue;
 			sc += f[j];
 			if (sc > max_f) {
@@ -204,6 +203,7 @@ mm128_t *mg_lchain_dp(int max_dist_x, int max_dist_y, int bw, int max_skip, int
 		if (max_ii < 0 || (a[i].x - a[max_ii].x <= (int64_t)max_dist_x && f[max_ii] < f[i]))
 			max_ii = i;
 		if (mmax_f < max_f) mmax_f = max_f;
+		//fprintf(stderr, "X1\t%ld\t%ld:%d\t%ld\t%ld:%d\t%ld\t%ld\n", (long)i, (long)(a[i].x>>32), (int32_t)a[i].x, (long)max_j, max_j<0?-1L:(long)(a[max_j].x>>32), max_j<0?-1:(int32_t)a[max_j].x, (long)max_f, (long)v[i]);
 	}
 
 	u = mg_chain_backtrack(km, n, f, p, v, t, min_cnt, min_sc, max_drop, &n_u, &n_v);
@@ -263,7 +263,8 @@ mm128_t *mg_lchain_rmq(int max_dist, int max_dist_inner, int bw, int max_chn_ski
 		return 0;
 	}
 	if (max_dist < bw) max_dist = bw;
-	if (max_dist_inner <= 0 || max_dist_inner >= max_dist) max_dist_inner = 0;
+	if (max_dist_inner < 0) max_dist_inner = 0;
+	if (max_dist_inner > max_dist) max_dist_inner = max_dist;
 	p = Kmalloc(km, int64_t, n);
 	f = Kmalloc(km, int32_t, n);
 	t = Kcalloc(km, int32_t, n);
@@ -325,12 +326,11 @@ mm128_t *mg_lchain_rmq(int max_dist, int max_dist_inner, int bw, int max_chn_ski
 				krmq_interval(lc_elem, root_inner, &s, &lo, &hi);
 				if (lo) {
 					const lc_elem_t *q;
-					int32_t width, n_rmq_iter = 0;
+					int32_t width;
 					krmq_itr_t(lc_elem) itr;
 					krmq_itr_find(lc_elem, root_inner, lo, &itr);
 					while ((q = krmq_at(&itr)) != 0) {
 						if (q->y < (int32_t)a[i].y - max_dist_inner) break;
-						++n_rmq_iter;
 						j = q->i;
 						sc = f[j] + comput_sc_simple(&a[i], &a[j], chn_pen_gap, chn_pen_skip, 0, &width);
 						if (width <= bw) {

data/ext/minimap2/main.c

@@ -35,12 +35,12 @@ static ko_longopt_t long_options[] = {
 	{ "splice",         ko_no_argument,       310 },
 	{ "cost-non-gt-ag", ko_required_argument, 'C' },
 	{ "no-long-join",   ko_no_argument,       312 },
-	{ "sr",             ko_no_argument,       313 },
+	{ "sr",             ko_optional_argument, 313 },
 	{ "frag",           ko_required_argument, 314 },
 	{ "secondary",      ko_required_argument, 315 },
 	{ "cs",             ko_optional_argument, 316 },
 	{ "end-bonus",      ko_required_argument, 317 },
-	{ "no-pairing",     ko_no_argument,       318 },
+	{ "no-pairing",     ko_no_argument,       318 }, // deprecated but reserved for backward compatibility
 	{ "splice-flank",   ko_required_argument, 319 },
 	{ "idx-no-seq",     ko_no_argument,       320 },
 	{ "end-seed-pen",   ko_required_argument, 321 },
@@ -78,6 +78,14 @@ static ko_longopt_t long_options[] = {
 	{ "no-hash-name",   ko_no_argument,       353 },
 	{ "secondary-seq",  ko_no_argument,       354 },
 	{ "ds",             ko_no_argument,       355 },
+	{ "rmq-inner",      ko_required_argument, 356 },
+	{ "spsc",           ko_required_argument, 357 },
+	{ "junc-pen",       ko_required_argument, 358 },
+	{ "pairing",        ko_required_argument, 359 },
+	{ "jump-min-match", ko_required_argument, 360 },
+	{ "write-junc",     ko_no_argument,       361 },
+	{ "pass1",          ko_required_argument, 362 },
+	{ "dbg-seed-occ",   ko_no_argument,       501 },
 	{ "help",           ko_no_argument,       'h' },
 	{ "max-intron-len", ko_required_argument, 'G' },
 	{ "version",        ko_no_argument,       'V' },
@@ -121,12 +129,12 @@ static inline void yes_or_no(mm_mapopt_t *opt, int64_t flag, int long_idx, const
 
 int main(int argc, char *argv[])
 {
-	const char *opt_str = "2aSDw:k:K:t:r:f:Vv:g:G:I:d:XT:s:x:Hcp:M:n:z:A:B:b:O:E:m:N:Qu:R:hF:LC:yYPo:e:U:J:";
+	const char *opt_str = "2aSDw:k:K:t:r:f:Vv:g:G:I:d:XT:s:x:Hcp:M:n:z:A:B:b:O:E:m:N:Qu:R:hF:LC:yYPo:e:U:J:j:";
 	ketopt_t o = KETOPT_INIT;
 	mm_mapopt_t opt;
 	mm_idxopt_t ipt;
 	int i, c, n_threads = 3, n_parts, old_best_n = -1;
-	char *fnw = 0, *rg = 0, *junc_bed = 0, *s, *alt_list = 0;
+	char *fnw = 0, *rg = 0, *fn_bed_junc = 0, *fn_bed_jump = 0, *fn_bed_pass1 = 0, *fn_spsc = 0, *s, *alt_list = 0;
 	FILE *fp_help = stderr;
 	mm_idx_reader_t *idx_rdr;
 	mm_idx_t *mi;
@@ -188,6 +196,7 @@ int main(int argc, char *argv[])
 		else if (c == 'R') rg = o.arg;
 		else if (c == 'h') fp_help = stdout;
 		else if (c == '2') opt.flag |= MM_F_2_IO_THREADS;
+		else if (c == 'j') fn_bed_jump = o.arg;
 		else if (c == 'J') {
 			int t;
 			t = atoi(o.arg);
@@ -212,9 +221,8 @@ int main(int argc, char *argv[])
 		else if (c == 309) mm_dbg_flag |= MM_DBG_PRINT_QNAME | MM_DBG_PRINT_ALN_SEQ, n_threads = 1; // --print-aln-seq
 		else if (c == 310) opt.flag |= MM_F_SPLICE; // --splice
 		else if (c == 312) opt.flag |= MM_F_NO_LJOIN; // --no-long-join
-		else if (c == 313) opt.flag |= MM_F_SR; // --sr
 		else if (c == 317) opt.end_bonus = atoi(o.arg); // --end-bonus
-		else if (c == 318) opt.flag |= MM_F_INDEPEND_SEG; // --no-pairing
+		else if (c == 318) opt.flag |= MM_F_INDEPEND_SEG; // --no-pairing (deprecated)
 		else if (c == 320) ipt.flag |= MM_I_NO_SEQ; // --idx-no-seq
 		else if (c == 321) opt.anchor_ext_shift = atoi(o.arg); // --end-seed-pen
 		else if (c == 322) opt.flag |= MM_F_FOR_ONLY; // --for-only
@@ -230,8 +238,9 @@ int main(int argc, char *argv[])
 		else if (c == 336) opt.flag |= MM_F_HARD_MLEVEL; // --hard-mask-level
 		else if (c == 337) opt.max_sw_mat = mm_parse_num(o.arg); // --cap-sw-mat
 		else if (c == 338) opt.max_qlen = mm_parse_num(o.arg); // --max-qlen
-		else if (c == 340) junc_bed = o.arg; // --junc-bed
+		else if (c == 340) fn_bed_junc = o.arg; // --junc-bed
 		else if (c == 341) opt.junc_bonus = atoi(o.arg); // --junc-bonus
+		else if (c == 358) opt.junc_pen = atoi(o.arg); // --junc-pen
 		else if (c == 342) opt.flag |= MM_F_SAM_HIT_ONLY; // --sam-hit-only
 		else if (c == 343) opt.chain_gap_scale = atof(o.arg); // --chain-gap-scale
 		else if (c == 351) opt.chain_skip_scale = atof(o.arg); // --chain-skip-scale
@@ -245,8 +254,25 @@ int main(int argc, char *argv[])
 		else if (c == 353) opt.flag |= MM_F_NO_HASH_NAME; // --no-hash-name
 		else if (c == 354) opt.flag |= MM_F_SECONDARY_SEQ; // --secondary-seq
 		else if (c == 355) opt.flag |= MM_F_OUT_DS; // --ds
+		else if (c == 356) opt.rmq_inner_dist = mm_parse_num(o.arg); // --rmq-inner
+		else if (c == 357) fn_spsc = o.arg; // --spsc
+		else if (c == 360) opt.jump_min_match = mm_parse_num(o.arg); // --jump-min-match
+		else if (c == 361) opt.flag |= MM_F_OUT_JUNC | MM_F_CIGAR; // --write-junc
+		else if (c == 362) fn_bed_pass1 = o.arg; // --jump-pass1
+		else if (c == 501) mm_dbg_flag |= MM_DBG_SEED_FREQ; // --dbg-seed-occ
 		else if (c == 330) {
 			fprintf(stderr, "[WARNING] \033[1;31m --lj-min-ratio has been deprecated.\033[0m\n");
+		} else if (c == 313) { // --sr
+			if (o.arg == 0 || strcmp(o.arg, "dna") == 0) {
+				opt.flag |= MM_F_SR;
+			} else if (strcmp(o.arg, "rna") == 0) {
+				opt.flag |= MM_F_SR_RNA;
+			} else if (strcmp(o.arg, "no") == 0) {
+				opt.flag &= ~(uint64_t)(MM_F_SR|MM_F_SR_RNA);
+			} else if (mm_verbose >= 2) {
+				opt.flag |= MM_F_SR;
+				fprintf(stderr, "[WARNING]\033[1;31m --sr only takes 'dna' or 'rna'. Invalid values are assumed to be 'dna'.\033[0m\n");
+			}
 		} else if (c == 314) { // --frag
 			yes_or_no(&opt, MM_F_FRAG_MODE, o.longidx, o.arg, 1);
 		} else if (c == 315) { // --secondary
@@ -271,6 +297,14 @@ int main(int argc, char *argv[])
 		} else if (c == 347) { // --rmq
 			if (o.arg) yes_or_no(&opt, MM_F_RMQ, o.longidx, o.arg, 1);
 			else opt.flag |= MM_F_RMQ;
+		} else if (c == 359) { // --pairing
+			if (strcmp(o.arg, "no") == 0) opt.flag |= MM_F_INDEPEND_SEG;
+			else if (strcmp(o.arg, "weak") == 0) opt.flag |= MM_F_WEAK_PAIRING, opt.flag &= ~(uint64_t)MM_F_INDEPEND_SEG;
+			else {
+				if (strcmp(o.arg, "strong") != 0 && mm_verbose >= 2)
+					fprintf(stderr, "[WARNING]\033[1;31m unrecognized argument for --pairing; assuming 'strong'.\033[0m\n");
+				opt.flag &= ~(uint64_t)(MM_F_INDEPEND_SEG|MM_F_WEAK_PAIRING);
+			}
 		} else if (c == 'S') {
 			opt.flag |= MM_F_OUT_CS | MM_F_CIGAR | MM_F_OUT_CS_LONG;
 			if (mm_verbose >= 2)
@@ -311,10 +345,6 @@ int main(int argc, char *argv[])
 			if (*s == ',') opt.e2 = strtol(s + 1, &s, 10);
 		}
 	}
-	if ((opt.flag & MM_F_SPLICE) && (opt.flag & MM_F_FRAG_MODE)) {
-		fprintf(stderr, "[ERROR]\033[1;31m --splice and --frag should not be specified at the same time.\033[0m\n");
-		return 1;
-	}
 	if (!fnw && !(opt.flag&MM_F_CIGAR))
 		ipt.flag |= MM_I_NO_SEQ;
 	if (mm_check_opt(&ipt, &opt) < 0)
@@ -354,6 +384,7 @@ int main(int argc, char *argv[])
 		fprintf(fp_help, "    -s INT       minimal peak DP alignment score [%d]\n", opt.min_dp_max);
 		fprintf(fp_help, "    -u CHAR      how to find GT-AG. f:transcript strand, b:both strands, n:don't match GT-AG [n]\n");
 		fprintf(fp_help, "    -J INT       splice mode. 0: original minimap2 model; 1: miniprot model [1]\n");
+		fprintf(fp_help, "    -j FILE      junctions in BED12 to extend *short* RNA-seq alignment []\n");
 		fprintf(fp_help, "  Input/Output:\n");
 		fprintf(fp_help, "    -a           output in the SAM format (PAF by default)\n");
 		fprintf(fp_help, "    -o FILE      output alignments to FILE [stdout]\n");
@@ -365,6 +396,7 @@ int main(int argc, char *argv[])
 		fprintf(fp_help, "    --MD         output the MD tag\n");
 		fprintf(fp_help, "    --eqx        write =/X CIGAR operators\n");
 		fprintf(fp_help, "    -Y           use soft clipping for supplementary alignments\n");
+		fprintf(fp_help, "    -y           copy FASTA/Q comments to output SAM\n");
 		fprintf(fp_help, "    -t INT       number of threads [%d]\n", n_threads);
 		fprintf(fp_help, "    -K NUM       minibatch size for mapping [500M]\n");
 //		fprintf(fp_help, "    -v INT       verbose level [%d]\n", mm_verbose);
@@ -373,6 +405,7 @@ int main(int argc, char *argv[])
 		fprintf(fp_help, "    -x STR       preset (always applied before other options; see minimap2.1 for details) []\n");
 		fprintf(fp_help, "                 - lr:hq - accurate long reads (error rate <1%%) against a reference genome\n");
 		fprintf(fp_help, "                 - splice/splice:hq - spliced alignment for long reads/accurate long reads\n");
+		fprintf(fp_help, "                 - splice:sr - spliced alignment for short RNA-seq reads\n");
 		fprintf(fp_help, "                 - asm5/asm10/asm20 - asm-to-ref mapping, for ~0.1/1/5%% sequence divergence\n");
 		fprintf(fp_help, "                 - sr - short reads against a reference\n");
 		fprintf(fp_help, "                 - map-pb/map-hifi/map-ont/map-iclr - CLR/HiFi/Nanopore/ICLR vs reference mapping\n");
@@ -427,7 +460,26 @@ int main(int argc, char *argv[])
 					__func__, realtime() - mm_realtime0, cputime() / (realtime() - mm_realtime0), mi->n_seq);
 		if (argc != o.ind + 1) mm_mapopt_update(&opt, mi);
 		if (mm_verbose >= 3) mm_idx_stat(mi);
-		if (junc_bed) mm_idx_bed_read(mi, junc_bed, 1);
+		if (fn_bed_junc) {
+			mm_idx_bed_read(mi, fn_bed_junc, 1);
+			if (mi->I == 0 && mm_verbose >= 2)
+				fprintf(stderr, "[WARNING] failed to load the junction BED file\n");
+		}
+		if (fn_bed_jump) {
+			mm_idx_jjump_read(mi, fn_bed_jump, MM_JUNC_ANNO, -1);
+			if (mi->J == 0 && mm_verbose >= 2)
+				fprintf(stderr, "[WARNING] failed to load the jump BED file\n");
+		}
+		if (fn_bed_pass1) {
+			mm_idx_jjump_read(mi, fn_bed_pass1, MM_JUNC_MISC, 5);
+			if (mi->J == 0 && mm_verbose >= 2)
+				fprintf(stderr, "[WARNING] failed to load the pass-1 jump BED file\n");
+		}
+		if (fn_spsc) {
+			mm_idx_spsc_read(mi, fn_spsc, mm_max_spsc_bonus(&opt));
+			if (mi->spsc == 0 && mm_verbose >= 2)
+				fprintf(stderr, "[WARNING] failed to load the splice score file\n");
+		}
 		if (alt_list) mm_idx_alt_read(mi, alt_list);
 		if (argc - (o.ind + 1) == 0) {
 			mm_idx_destroy(mi);

data/ext/minimap2/map.c

@@ -224,10 +224,10 @@ static mm_reg1_t *align_regs(const mm_mapopt_t *opt, const mm_idx_t *mi, void *k
 	return regs;
 }
 
-void mm_map_frag(const mm_idx_t *mi, int n_segs, const int *qlens, const char **seqs, int *n_regs, mm_reg1_t **regs, mm_tbuf_t *b, const mm_mapopt_t *opt, const char *qname)
+void mm_map_frag_core(const mm_idx_t *mi, int n_segs, const int *qlens, const char **seqs, int *n_regs, mm_reg1_t **regs, mm_tbuf_t *b, const mm_mapopt_t *opt, const char *qname)
 {
 	int i, j, rep_len, qlen_sum, n_regs0, n_mini_pos;
-	int max_chain_gap_qry, max_chain_gap_ref, is_splice = !!(opt->flag & MM_F_SPLICE), is_sr = !!(opt->flag & MM_F_SR);
+	int max_chain_gap_qry, max_chain_gap_ref, is_splice = !!(opt->flag & MM_F_SPLICE), is_sr = !!(opt->flag & MM_F_SR), is_sr_rna = !!(opt->flag & MM_F_SR_RNA);
 	uint32_t hash;
 	int64_t n_a;
 	uint64_t *u, *mini_pos;
@@ -338,7 +338,7 @@ void mm_map_frag(const mm_idx_t *mi, int n_segs, const int *qlens, const char **
 	if (n_segs == 1) { // uni-segment
 		regs0 = align_regs(opt, mi, b->km, qlens[0], seqs[0], &n_regs0, regs0, a);
 		regs0 = (mm_reg1_t*)realloc(regs0, sizeof(*regs0) * n_regs0);
-		mm_set_mapq(b->km, n_regs0, regs0, opt->min_chain_score, opt->a, rep_len, is_sr);
+		mm_set_mapq2(b->km, n_regs0, regs0, opt->min_chain_score, opt->a, rep_len, is_sr || is_sr_rna, is_splice);
 		n_regs[0] = n_regs0, regs[0] = regs0;
 	} else { // multi-segment
 		mm_seg_t *seg;
@@ -347,7 +347,7 @@ void mm_map_frag(const mm_idx_t *mi, int n_segs, const int *qlens, const char **
 		for (i = 0; i < n_segs; ++i) {
 			mm_set_parent(b->km, opt->mask_level, opt->mask_len, n_regs[i], regs[i], opt->a * 2 + opt->b, opt->flag&MM_F_HARD_MLEVEL, opt->alt_drop); // update mm_reg1_t::parent
 			regs[i] = align_regs(opt, mi, b->km, qlens[i], seqs[i], &n_regs[i], regs[i], seg[i].a);
-			mm_set_mapq(b->km, n_regs[i], regs[i], opt->min_chain_score, opt->a, rep_len, is_sr);
+			mm_set_mapq2(b->km, n_regs[i], regs[i], opt->min_chain_score, opt->a, rep_len, is_sr || is_sr_rna, is_splice);
 		}
 		mm_seg_free(b->km, n_segs, seg);
 		if (n_segs == 2 && opt->pe_ori >= 0 && (opt->flag&MM_F_CIGAR))
@@ -359,6 +359,10 @@ void mm_map_frag(const mm_idx_t *mi, int n_segs, const int *qlens, const char **
 	kfree(b->km, u);
 	kfree(b->km, mini_pos);
 
+	if (mi->J && n_segs == 1 && is_splice)
+		for (i = 0; i < n_regs0; ++i)
+			mm_jump_split(b->km, mi, opt, qlens[0], (const uint8_t*)seqs[0], &regs0[i], 0);
+
 	if (b->km) {
 		km_stat(b->km, &kmst);
 		if (mm_dbg_flag & MM_DBG_PRINT_QNAME)
@@ -373,6 +377,18 @@ void mm_map_frag(const mm_idx_t *mi, int n_segs, const int *qlens, const char **
 	}
 }
 
+void mm_map_frag(const mm_idx_t *mi, int n_segs, const int *qlens, const char **seqs, int *n_regs, mm_reg1_t **regs, mm_tbuf_t *b, const mm_mapopt_t *opt, const char *qname)
+{
+	if ((opt->flag & MM_F_WEAK_PAIRING) && n_segs == 2 && opt->pe_ori >= 0 && (opt->flag&MM_F_CIGAR)) {
+		int i;
+		for (i = 0; i < n_segs; ++i)
+			mm_map_frag_core(mi, 1, &qlens[i], &seqs[i], &n_regs[i], &regs[i], b, opt, qname);
+		mm_pair(b->km, opt->max_gap_ref, opt->pe_bonus, opt->a * 2 + opt->b, opt->a, qlens, n_regs, regs);
+	} else {
+		mm_map_frag_core(mi, n_segs, qlens, seqs, n_regs, regs, b, opt, qname);
+	}
+}
+
 mm_reg1_t *mm_map(const mm_idx_t *mi, int qlen, const char *seq, int *n_regs, mm_tbuf_t *b, const mm_mapopt_t *opt, const char *qname)
 {
 	mm_reg1_t *regs;
@@ -447,6 +463,10 @@ static void worker_for(void *_data, long i, int tid) // kt_for() callback
 				r->qs = qlens[j] - r->qe;
 				r->qe = qlens[j] - t;
 				r->rev = !r->rev;
+				if (r->p) {
+					if (r->p->trans_strand == 1) r->p->trans_strand = 2;
+					else if (r->p->trans_strand == 2) r->p->trans_strand = 1;
+				}
 			}
 		}
 	if (mm_dbg_flag & MM_DBG_PRINT_QNAME)
@@ -509,7 +529,7 @@ static void merge_hits(step_t *s)
 				mm_select_sub(km, opt->pri_ratio, s->p->mi->k*2, opt->best_n, 0, opt->max_gap * 0.8, &s->n_reg[k], s->reg[k]);
 				mm_set_sam_pri(s->n_reg[k], s->reg[k]);
 			}
-			mm_set_mapq(km, s->n_reg[k], s->reg[k], opt->min_chain_score, opt->a, rep_len, !!(opt->flag & MM_F_SR));
+			mm_set_mapq2(km, s->n_reg[k], s->reg[k], opt->min_chain_score, opt->a, rep_len, !!(opt->flag & (MM_F_SR|MM_F_SR_RNA)), !!(opt->flag & MM_F_SPLICE));
 		}
 		if (s->n_seg[f] == 2 && opt->pe_ori >= 0 && (opt->flag&MM_F_CIGAR))
 			mm_pair(km, frag_gap_part[0], opt->pe_bonus, opt->a * 2 + opt->b, opt->a, qlens, &s->n_reg[k0], &s->reg[k0]);
@@ -578,23 +598,30 @@ static void *worker_pipeline(void *shared, int step, void *in)
 							mm_err_fwrite(r->p, r->p->capacity, 4, p->fp_split);
 						}
 					}
+				} else if (p->opt->flag & MM_F_OUT_JUNC) { // extra logic for --write-junc
+					for (j = 0; j < s->n_reg[i]; ++j) {
+						const mm_reg1_t *r = &s->reg[i][j];
+						if (r->id != r->parent || r->mapq < 10) continue;
+						mm_write_junc(&p->str, mi, t, r);
+						if (p->str.l > 0) mm_err_puts(p->str.s);
+					}
 				} else if (s->n_reg[i] > 0) { // the query has at least one hit
 					for (j = 0; j < s->n_reg[i]; ++j) {
-						mm_reg1_t *r = &s->reg[i][j];
+						const mm_reg1_t *r = &s->reg[i][j];
 						assert(!r->sam_pri || r->id == r->parent);
 						if ((p->opt->flag & MM_F_NO_PRINT_2ND) && r->id != r->parent)
 							continue;
 						if (p->opt->flag & MM_F_OUT_SAM)
 							mm_write_sam3(&p->str, mi, t, i - seg_st, j, s->n_seg[k], &s->n_reg[seg_st], (const mm_reg1_t*const*)&s->reg[seg_st], km, p->opt->flag, s->rep_len[i]);
 						else
-							mm_write_paf3(&p->str, mi, t, r, km, p->opt->flag, s->rep_len[i]);
+							mm_write_paf4(&p->str, mi, t, r, km, p->opt->flag, s->rep_len[i], s->n_seg[k], i - seg_st);
 						mm_err_puts(p->str.s);
 					}
 				} else if ((p->opt->flag & MM_F_PAF_NO_HIT) || ((p->opt->flag & MM_F_OUT_SAM) && !(p->opt->flag & MM_F_SAM_HIT_ONLY))) { // output an empty hit, if requested
 					if (p->opt->flag & MM_F_OUT_SAM)
 						mm_write_sam3(&p->str, mi, t, i - seg_st, -1, s->n_seg[k], &s->n_reg[seg_st], (const mm_reg1_t*const*)&s->reg[seg_st], km, p->opt->flag, s->rep_len[i]);
 					else
-						mm_write_paf3(&p->str, mi, t, 0, 0, p->opt->flag, s->rep_len[i]);
+						mm_write_paf4(&p->str, mi, t, 0, 0, p->opt->flag, s->rep_len[i], s->n_seg[k], i - seg_st);
 					mm_err_puts(p->str.s);
 				}
 			}