minimap2 0.2.30.3 → 1.2.31.0

data/ext/minimap2/misc/README.md

@@ -1,180 +0,0 @@
-## <a name="started"></a>Getting Started
-
-```sh
-# install minimap2
-git clone https://github.com/lh3/minimap2
-cd minimap2 && make
-# install the k8 javascript shell
-curl -L https://github.com/attractivechaos/k8/releases/download/v0.2.4/k8-0.2.4.tar.bz2 | tar -jxf -
-cp k8-0.2.4/k8-`uname -s` k8              # or copy it to a directory on your $PATH
-# export PATH="$PATH:`pwd`:`pwd`/misc"    # run this if k8, minimap2 or paftools.js not on your $PATH
-minimap2 --cs test/MT-human.fa test/MT-orang.fa | paftools.js view -     # view alignment
-minimap2 -c test/MT-human.fa test/MT-orang.fa | paftools.js stat -       # basic alignment statistics
-minimap2 -c --cs test/MT-human.fa test/MT-orang.fa \
-  | sort -k6,6 -k8,8n | paftools.js call -L15000 -     # calling variants from asm-to-ref alignment
-minimap2 -c test/MT-human.fa test/MT-orang.fa \
-  | paftools.js liftover -l10000 - <(echo -e "MT_orang\t2000\t5000")     # liftOver
-# no test data for the following examples
-paftools.js junceval -e anno.gtf splice.sam > out.txt  # compare splice junctions to annotations
-paftools.js splice2bed splice.sam > splice.bed             # convert PAF/SAM to BED12
-paftools.js gff2bed anno.gtf > anno.bed             # convert GTF/GFF3 to BED12
-```
-
-## Table of Contents
-
-- [Getting Started](#started)
-- [Introduction](#intro)
-- [Evaluation](#eval)
-  - [Evaluating mapping accuracy with simulated reads](#mapeval)
-  - [Evaluating read overlap sensitivity](#oveval)
-- [Calling Variants from Assemblies](#asmvar)
-
-## <a name="intro"></a>Introduction
-
-paftools.js is a script that processes alignments in the [PAF format][paf],
-such as converting between formats, evaluating mapping accuracy, lifting over
-BED files based on alignment, and calling variants from assembly-to-assembly
-alignment. This script *requires* the [k8 Javascript shell][k8] to run. On
-Linux or Mac, you can download the precompiled k8 binary with:
-
-```sh
-curl -L https://github.com/attractivechaos/k8/releases/download/v0.2.4/k8-0.2.4.tar.bz2 | tar -jxf -
-cp k8-0.2.4/k8-`uname -s` $HOME/bin/k8  # assuming $HOME/bin in your $PATH
-```
-
-It is highly recommended to copy the executable `k8` to a directory on your
-`$PATH` such as `/usr/bin/env` can find it. Like python scripts, once you
-install `k8`, you can launch paftools.js in one of the two ways:
-
-```sh
-path/to/paftools.js             # only if k8 is on your $PATH
-k8 path/to/paftools.js
-```
-
-In a nutshell, paftools.js has the following commands:
-
-```
-Usage: paftools.js <command> [arguments]
-Commands:
-  view       convert PAF to BLAST-like (for eyeballing) or MAF
-  splice2bed convert spliced alignment in PAF/SAM to BED12
-  sam2paf    convert SAM to PAF
-  delta2paf  convert MUMmer's delta to PAF
-  gff2bed    convert GTF/GFF3 to BED12
-
-  stat       collect basic mapping information in PAF/SAM
-  liftover   simplistic liftOver
-  call       call variants from asm-to-ref alignment with the cs tag
-  bedcov     compute the number of bases covered
-
-  mapeval    evaluate mapping accuracy using mason2/PBSIM-simulated FASTQ
-  mason2fq   convert mason2-simulated SAM to FASTQ
-  pbsim2fq   convert PBSIM-simulated MAF to FASTQ
-  junceval   evaluate splice junction consistency with known annotations
-  ov-eval    evaluate read overlap sensitivity using read-to-ref mapping
-```
-
-paftools.js seamlessly reads both plain text files and gzip'd text files.
-
-## <a name="eval"></a>Evaluation
-
-### <a name="mapeval"></a>Evaluating mapping accuracy with simulated reads
-
-The **pbsim2fq** command of paftools.js converts the MAF output of [pbsim][pbsim]
-to FASTQ and encodes the true mapping position in the read name in a format like
-`S1_33!chr1!225258409!225267761!-`. Similarly, the **mason2fq** command
-converts [mason2][mason2] simulated SAM to FASTQ.
-
-Command **mapeval** evaluates mapped SAM/PAF. Here is example output:
-
-```
-Q       60      32478   0       0.000000000     32478
-Q       22      16      1       0.000030775     32494
-Q       21      43      1       0.000061468     32537
-Q       19      73      1       0.000091996     32610
-Q       14      66      1       0.000122414     32676
-Q       10      27      3       0.000214048     32703
-Q       8       14      1       0.000244521     32717
-Q       7       13      2       0.000305530     32730
-Q       6       46      1       0.000335611     32776
-Q       3       10      1       0.000366010     32786
-Q       2       20      2       0.000426751     32806
-Q       1       248     94      0.003267381     33054
-Q       0       31      17      0.003778147     33085
-U       3
-```
-
-where each Q-line gives the quality threshold, the number of reads mapped with
-mapping quality equal to or greater than the threshold, number of wrong
-mappings, accumulative mapping error rate and the accumulative number of
-mapped reads. The U-line, if present, gives the number of unmapped reads if
-they are present in the SAM file.
-
-Suppose the reported mapping coordinate overlap with the true coordinate like
-the following:
-
-```
-truth:   --------------------
-mapper:           ----------------------
-         |<- l1 ->|<-- o -->|<-- l2 -->|
-```
-
-Let `r=o/(l1+o+l2)`. The reported mapping is considered correct if `r>0.1` by
-default.
-
-### <a name="oveval"></a>Evaluating read overlap sensitivity
-
-Command **ov-eval** takes *sorted* read-to-reference alignment and read
-overlaps in PAF as input, and evaluates the sensitivity. For example:
-
-```sh
-minimap2 -cx map-pb ref.fa reads.fq.gz | sort -k6,6 -k8,8n > reads-to-ref.paf
-minimap2 -x ava-pb reads.fq.gz reads.fq.gz > ovlp.paf
-k8 ov-eval.js reads-to-ref.paf ovlp.paf
-```
-
-## <a name="asmvar"></a>Calling Variants from Haploid Assemblies
-
-The **call** command of paftools.js calls variants from coordinate-sorted
-assembly-to-reference alignment. It calls variants from the [cs tag][cs] and
-identifies confident/callable regions as those covered by exactly one contig.
-Here are example command lines:
-
-```sh
-minimap2 -cx asm5 -t8 --cs ref.fa asm.fa > asm.paf  # keeping this file is recommended; --cs required!
-sort -k6,6 -k8,8n asm.paf > asm.srt.paf             # sort by reference start coordinate
-k8 paftools.js call asm.srt.paf > asm.var.txt
-```
-
-Here is sample output:
-
-```
-V   chr1    2276040 2276041 1   60  c   g   LJII01000171.1  1217409 1217410 +
-V   chr1    2280409 2280410 1   60  a   g   LJII01000171.1  1221778 1221779 +
-V   chr1    2280504 2280505 1   60  a   g   LJII01000171.1  1221873 1221874 +
-R   chr1    2325140 2436340
-V   chr1    2325287 2325287 1   60  -   ct  LJII01000171.1  1272894 1272896 +
-V   chr1    2325642 2325644 1   60  tt  -   LJII01000171.1  1273251 1273251 +
-V   chr1    2326051 2326052 1   60  c   t   LJII01000171.1  1273658 1273659 +
-V   chr1    2326287 2326288 1   60  c   t   LJII01000171.1  1273894 1273895 +
-```
-
-where a line starting with `R` gives regions covered by one query contig, and a
-V-line encodes a variant in the following format: chr, start, end, query depth,
-mapping quality, REF allele, ALT allele, query name, query start, end and the
-query orientation. Generally, you should only look at variants where column 5
-is one.
-
-By default, when calling variants, "paftools.js call" ignores alignments 50kb
-or shorter; when deriving callable regions, it ignores alignments 10kb or
-shorter.  It uses two thresholds to avoid edge effects. These defaults are
-designed for long-read assemblies. For short reads, both should be reduced.
-
-
-
-[paf]: https://github.com/lh3/miniasm/blob/master/PAF.md
-[cs]: https://github.com/lh3/minimap2#cs
-[k8]: https://github.com/attractivechaos/k8
-[maf]: https://genome.ucsc.edu/FAQ/FAQformat#format5
-[pbsim]: https://github.com/pfaucon/PBSIM-PacBio-Simulator
-[mason2]: https://github.com/seqan/seqan/tree/master/apps/mason2

data/ext/minimap2/misc/pafcluster.js

@@ -1,241 +0,0 @@
-#!/usr/bin/env k8
-
-"use strict";
-
-Array.prototype.delete_at = function(i) {
-	for (let j = i; j < this.length - 1; ++j)
-		this[j] = this[j + 1];
-	--this.length;
-}
-
-function* getopt(argv, ostr, longopts) {
-	if (argv.length == 0) return;
-	let pos = 0, cur = 0;
-	while (cur < argv.length) {
-		let lopt = "", opt = "?", arg = "";
-		while (cur < argv.length) { // skip non-option arguments
-			if (argv[cur][0] == "-" && argv[cur].length > 1) {
-				if (argv[cur] == "--") cur = argv.length;
-				break;
-			} else ++cur;
-		}
-		if (cur == argv.length) break;
-		let a = argv[cur];
-		if (a[0] == "-" && a[1] == "-") { // a long option
-			pos = -1;
-			let c = 0, k = -1, tmp = "", o;
-			const pos_eq = a.indexOf("=");
-			if (pos_eq > 0) {
-				o = a.substring(2, pos_eq);
-				arg = a.substring(pos_eq + 1);
-			} else o = a.substring(2);
-			for (let i = 0; i < longopts.length; ++i) {
-				let y = longopts[i];
-				if (y[y.length - 1] == "=") y = y.substring(0, y.length - 1);
-				if (o.length <= y.length && o == y.substring(0, o.length)) {
-					k = i, tmp = y;
-					++c; // c is the number of matches
-					if (o == y) { // exact match
-						c = 1;
-						break;
-					}
-				}
-			}
-			if (c == 1) { // find a unique match
-				lopt = tmp;
-				if (pos_eq < 0 && longopts[k][longopts[k].length-1] == "=" && cur + 1 < argv.length) {
-					arg = argv[cur+1];
-					argv.delete_at(cur + 1);
-				}
-			}
-		} else { // a short option
-			if (pos == 0) pos = 1;
-			opt = a[pos++];
-			let k = ostr.indexOf(opt);
-			if (k < 0) {
-				opt = "?";
-			} else if (k + 1 < ostr.length && ostr[k+1] == ":") { // requiring an argument
-				if (pos >= a.length) {
-					arg = argv[cur+1];
-					argv.delete_at(cur + 1);
-				} else arg = a.substring(pos);
-				pos = -1;
-			}
-		}
-		if (pos < 0 || pos >= argv[cur].length) {
-			argv.delete_at(cur);
-			pos = 0;
-		}
-		if (lopt != "") yield { opt: `--${lopt}`, arg: arg };
-		else if (opt != "?") yield { opt: `-${opt}`, arg: arg };
-		else yield { opt: "?", arg: "" };
-	}
-}
-
-function* k8_readline(fn) {
-	let buf = new Bytes();
-	let file = new File(fn);
-	while (file.readline(buf) >= 0) {
-		yield buf.toString();
-	}
-	file.close();
-	buf.destroy();
-}
-
-function merge_hits(b) {
-	if (b.length == 1)
-		return { name1:b[0].name1, name2:b[0].name2, len1:b[0].len1, len2:b[0].len2, min_cov:b[0].min_cov, max_cov:b[0].max_cov, cov1:b[0].cov1, cov2:b[0].cov2, s1:b[0].s1, dv:b[0].dv };
-	b.sort(function(x, y) { return x.st1 - y.st1 });
-	let f = [], bt = [];
-	for (let i = 0; i < b.length; ++i)
-		f[i] = b[i].s1, bt[i] = -1;
-	for (let i = 0; i < b.length; ++i) {
-		for (let j = 0; j < i; ++j) {
-			if (b[j].st2 < b[i].st2) {
-				if (b[j].en1 >= b[i].en1) continue;
-				if (b[j].en2 >= b[i].en2) continue;
-				const ov1 = b[j].en1 <= b[i].st1? 0 : b[i].st1 - b[j].en1;
-				const li1 = b[i].en1 - b[i].st1;
-				const s11 = b[i].s1 / li1 * (li1 - ov1);
-				const ov2 = b[j].en2 <= b[i].st2? 0 : b[i].st2 - b[j].en2;
-				const li2 = b[i].en2 - b[i].st2;
-				const s12 = b[i].s1 / li2 * (li2 - ov2);
-				const s1 = s11 < s12? s11 : s12;
-				if (f[i] < f[j] + s1)
-					f[i] = f[j] + s1, bt[i] = j;
-			}
-		}
-	}
-	let max_i = -1, max_f = 0, d = [];
-	for (let i = 0; i < b.length; ++i)
-		if (max_f < f[i])
-			max_f = f[i], max_i = i;
-	for (let k = max_i; k >= 0; k = bt[k])
-		d.push(k);
-	d = d.reverse();
-	let dv = 0, tot = 0, cov1 = 0, cov2 = 0, st1 = 0, en1 = 0, st2 = 0, en2 = 0;
-	for (let k = 0; k < d.length; ++k) {
-		const i = d[k];
-		tot += b[i].blen;
-		dv += b[i].dv * b[i].blen;
-		if (b[i].st1 > en1) {
-			cov1 += en1 - st1;
-			st1 = b[i].st1, en1 = b[i].en1;
-		} else en1 = en1 > b[i].en1? en1 : b[i].en1;
-		if (b[i].st2 > en2) {
-			cov2 += en2 - st2;
-			st2 = b[i].st2, en2 = b[i].en2;
-		} else en2 = en2 > b[i].en2? en2 : b[i].en2;
-	}
-	dv /= tot;
-	cov1 = (cov1 + (en1 - st1)) / b[0].len1;
-	cov2 = (cov2 + (en2 - st2)) / b[0].len2;
-	const min_cov = cov1 < cov2? cov1 : cov2;
-	const max_cov = cov1 > cov2? cov1 : cov2;
-	//warn(d.length, b[0].name1, b[0].name2, min_cov, max_cov);
-	return { name1:b[0].name1, name2:b[0].name2, len1:b[0].len1, len2:b[0].len2, min_cov:min_cov, max_cov:max_cov, cov1:cov1, cov2:cov2, s1:max_f, dv:dv };
-}
-
-function main(args) {
-	let opt = { min_cov:.9, max_dv:.015, max_diff:20000 };
-	for (const o of getopt(args, "c:d:e:", [])) {
-		if (o.opt == '-c') opt.min_cov = parseFloat(o.arg);
-		else if (o.opt == '-d') opt.max_dv = parseFloat(o.arg);
-		else if (o.opt == '-e') opt.max_diff = parseFloat(o.arg);
-	}
-	if (args.length == 0) {
-		print("Usage: pafcluster.js [options] <ava.paf>");
-		print("Options:");
-		print(`  -c FLOAT     min coverage [${opt.min_cov}]`);
-		print(`  -d FLOAT     max divergence [${opt.max_dv}]`);
-		print(`  -e FLOAT     max difference [${opt.max_diff}]`);
-		return;
-	}
-
-	// read
-	let a = [], len = {}, name2len = {};
-	for (const line of k8_readline(args[0])) {
-		let m, t = line.split("\t");
-		if (t[4] != "+") continue;
-		for (let i = 1; i < 4;  ++i) t[i] = parseInt(t[i]);
-		for (let i = 6; i < 11; ++i) t[i] = parseInt(t[i]);
-		const len1 = t[1], len2 = t[6];
-		let s1 = -1, dv = -1.0;
-		for (let i = 12; i < t.length; ++i) {
-			if ((m = /^(s1|dv):\S:(\S+)/.exec(t[i])) != null) {
-				if (m[1] == "s1") s1 = parseInt(m[2]);
-				else if (m[1] == "dv") dv = parseFloat(m[2]);
-			}
-		}
-		if (s1 < 0 || dv < 0) continue;
-		const cov1 = (parseInt(t[3]) - parseInt(t[2])) / len1;
-		const cov2 = (parseInt(t[8]) - parseInt(t[7])) / len2;
-		const min_cov = cov1 < cov2? cov1 : cov2;
-		const max_cov = cov1 > cov2? cov1 : cov2;
-		name2len[t[0]] = len1;
-		name2len[t[5]] = len2;
-		a.push({ name1:t[0], name2:t[5], len1:len1, len2:len2, min_cov:min_cov, max_cov:max_cov, s1:s1, dv:dv, cov1:cov1, cov2:cov2, st1:t[2], en1:t[3], st2:t[7], en2:t[8], blen:t[10] });
-		len[t[0]] = len1, len[t[5]] = len2;
-	}
-	warn(`Read ${a.length} hits`);
-
-	// merge duplicated hits
-	let h = {};
-	for (let i = 0; i < a.length; ++i) {
-		const key = `${a[i].name1}\t${a[i].name2}`;
-		if (h[key] == null) h[key] = [];
-		h[key].push(a[i]);
-	}
-	a = [];
-	for (const key in h)
-		a.push(merge_hits(h[key]));
-
-	// core loop
-	while (a.length > 1) {
-		// select the sequence with the highest sum of s1
-		let h = {};
-		for (let i = 0; i < a.length; ++i) {
-			if (h[a[i].name1] == null) h[a[i].name1] = 0;
-			h[a[i].name1] += a[i].s1;
-		}
-		let max_s1 = 0, max_name = "";
-		for (const name in h)
-			if (max_s1 < h[name])
-				max_s1 = h[name], max_name = name;
-		// find contigs in the same group
-		h = {};
-		h[max_name] = 1;
-		for (let i = 0; i < a.length; ++i) {
-			if (a[i].name1 != max_name && a[i].name2 != max_name)
-				continue;
-			const diff1 = a[i].len1 * (1.0 - a[i].cov1);
-			const diff2 = a[i].len2 * (1.0 - a[i].cov2);
-			if (a[i].min_cov >= opt.min_cov && a[i].dv <= opt.max_dv && diff1 <= opt.max_diff && diff2 <= opt.max_diff)
-				h[a[i].name1] = h[a[i].name2] = 1;
-		}
-		let n = 0;
-		for (const key in h) {
-			++n;
-			delete name2len[key];
-		}
-		print(`SD\t${max_name}\t${n}`);
-		for (const key in h) print(`CL\t${key}\t${len[key]}`);
-		print("//");
-		// filter out redundant hits
-		let b = [];
-		for (let i = 0; i < a.length; ++i)
-			if (h[a[i].name1] == null && h[a[i].name2] == null)
-				b.push(a[i]);
-		warn(`Reduced the number of hits from ${a.length} to ${b.length}`);
-		a = b;
-	}
-
-	// output remaining singletons
-	for (const key in name2len) {
-		print(`SD\t${key}\t1`);
-		print(`CL\t${key}\t${name2len[key]}`);
-		print(`//`);
-	}
-}
-
-main(arguments);