ruby-minigraph 0.0.20.0

data/ext/minigraph/gfa.h

@@ -0,0 +1,166 @@
+#ifndef __GFA_H__
+#define __GFA_H__
+
+#include <stdio.h>
+#include <stdint.h>
+
+#define GFA_VERSION "0.5-r247-dirty"
+
+#define GFA_O_OV_EXT   0x1
+#define GFA_O_NO_SEQ   0x2
+
+/*
+  A segment is a sequence. A vertex is one side of a segment. In the code,
+  segment_id is an integer, and vertex_id=segment_id<<1|orientation. The
+  convention is to use variable u, v or w for a vertex, not for a segment. An
+  arc is a directed edge between two vertices in the graph. Each arc has a
+  complement arc. A link represents an arc and its complement. The following
+  diagram shows an arc v->w, and the lengths used in the gfa_arc_t struct:
+
+       |<--- lv --->|<-- ov -->|
+    v: ------------------------>
+                    ||overlap|||
+                 w: -------------------------->
+                    |<-- ow -->|<---- lw ---->|
+
+  The graph topology is solely represented by an array of gfa_arc_t objects
+  (see gfa_t::arc[]), where both an arc and its complement are present. The
+  array is sorted by gfa_arc_t::v_lv and indexed by gfa_t::idx[] most of time.
+  gfa_arc_a(g, v), of size gfa_arc_n(g, v), gives the array of arcs that leaves
+  a vertex v in the graph g.
+*/
+
+typedef struct {
+	uint64_t v_lv; // higher 32 bits: vertex_id; lower 32 bits: lv; packed together for sorting
+	uint32_t w;
+	int32_t rank;
+	int32_t ov, ow;
+	uint64_t link_id:61, strong:1, del:1, comp:1; // link_id: a pair of dual arcs are supposed to have the same link_id
+} gfa_arc_t;
+
+#define gfa_arc_head(a) ((uint32_t)((a).v_lv>>32))
+#define gfa_arc_tail(a) ((a).w)
+#define gfa_arc_len(a) ((uint32_t)(a).v_lv) // different from the original string graph
+#define gfa_arc_lw(g, a) ((g)->seg[(a).w>>1].len - (a).ow)
+
+#define gfa_arc_n(g, v) ((uint32_t)(g)->idx[(v)])
+#define gfa_arc_a(g, v) (&(g)->arc[(g)->idx[(v)]>>32])
+
+typedef struct {
+	uint32_t m_aux, l_aux;
+	uint8_t *aux;
+} gfa_aux_t;
+
+typedef struct {
+	uint32_t start, end; // start: starting vertex in the string graph; end: ending vertex
+	uint32_t len_comp, dummy; // len_comp: the length of the complement unitig
+	uint32_t m, n; // number of reads
+	uint64_t *a; // list of reads
+	uint64_t *r; // start and end on each read
+	char **name;
+} gfa_utg_t;
+
+typedef struct {
+	int32_t len;
+	uint32_t del:16, circ:16;
+	int32_t snid; // stable name ID
+	int32_t soff; // stable start position
+	int32_t rank; // stable rank
+	char *name, *seq;
+	gfa_utg_t *utg;
+	gfa_aux_t aux;
+} gfa_seg_t;
+
+typedef struct {
+	int32_t len, snid, soff, rank;
+	uint64_t end[2];
+	char *seq;
+} gfa_sfa_t;
+
+typedef struct {
+	char *name;
+	int32_t min, max, rank;
+} gfa_sseq_t;
+
+#define gfa_n_vtx(g) ((g)->n_seg << 1)
+
+typedef struct {
+	// segments
+	uint32_t m_seg, n_seg, max_rank;
+	gfa_seg_t *seg;
+	void *h_names;
+	// persistent names
+	uint32_t m_sseq, n_sseq;
+	gfa_sseq_t *sseq;
+	void *h_snames;
+	// links
+	uint64_t m_arc, n_arc;
+	gfa_arc_t *arc;
+	gfa_aux_t *link_aux;
+	uint64_t *idx;
+} gfa_t;
+
+typedef struct {
+	const char *seq;
+	int32_t len;
+} gfa_edseq_t;
+
+// graph augmentation
+
+typedef struct {
+	uint32_t v[2];
+	int32_t voff[2];
+	int32_t coff[2], ctg;
+} gfa_ins_t;
+
+extern int gfa_verbose;
+extern unsigned char gfa_comp_table[256];
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+gfa_t *gfa_init(void);
+void gfa_destroy(gfa_t *g);
+gfa_t *gfa_read(const char *fn);
+void gfa_print(const gfa_t *g, FILE *fp, int M_only);
+
+gfa_edseq_t *gfa_edseq_init(const gfa_t *g);
+void gfa_edseq_destroy(int32_t n_seg, gfa_edseq_t *es);
+
+int32_t gfa_name2id(const gfa_t *g, const char *name);
+uint8_t *gfa_aux_get(int l_data, const uint8_t *data, const char tag[2]);
+int gfa_aux_del(int l_data, uint8_t *data, uint8_t *s);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef kroundup32
+#define kroundup32(x) (--(x), (x)|=(x)>>1, (x)|=(x)>>2, (x)|=(x)>>4, (x)|=(x)>>8, (x)|=(x)>>16, ++(x))
+#endif
+
+static inline void gfa_arc_del(gfa_t *g, uint32_t v, uint32_t w, int del)
+{
+	uint32_t i, nv = gfa_arc_n(g, v);
+	gfa_arc_t *av = gfa_arc_a(g, v);
+	for (i = 0; i < nv; ++i)
+		if (av[i].w == w) av[i].del = !!del;
+}
+
+static inline void gfa_seg_del(gfa_t *g, uint32_t s)
+{
+	uint32_t k;
+	g->seg[s].del = 1;
+	for (k = 0; k < 2; ++k) {
+		uint32_t i, v = s<<1 | k;
+		uint32_t nv = gfa_arc_n(g, v);
+		gfa_arc_t *av = gfa_arc_a(g, v);
+		for (i = 0; i < nv; ++i) {
+			av[i].del = 1;
+			gfa_arc_del(g, av[i].w^1, v^1, 1);
+		}
+	}
+}
+
+#endif

data/ext/minigraph/ggen.c

@@ -0,0 +1,182 @@
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <ctype.h>
+#include "kthread.h"
+#include "kalloc.h"
+#include "sys.h"
+#include "bseq.h"
+#include "ggen.h"
+#include "mgpriv.h"
+#include "gfa-priv.h"
+
+typedef struct {
+	int n_seq;
+	mg_bseq1_t *seq;
+	mg_gchains_t **gcs;
+} maprst_t;
+
+typedef struct {
+	const mg_mapopt_t *opt;
+	const mg_idx_t *gi;
+	mg_tbuf_t **buf;
+	maprst_t *r;
+} step_t;
+
+static void worker_for(void *_data, long i, int tid) // kt_for() callback
+{
+    step_t *s = (step_t*)_data;
+	if (mg_dbg_flag & MG_DBG_QNAME)
+		fprintf(stderr, "QR\t%s\t%d\t%d\n", s->r->seq[i].name, tid, s->r->seq[i].l_seq);
+	if ((s->opt->flag & MG_M_SKIP_GCHECK) == 0 && mg_verbose >= 2) {
+		if (gfa_sseq_get(s->gi->g, s->r->seq[i].name) >= 0)
+			fprintf(stderr, "[W::%s] stable sequence \"%s\" already present in the graph. This will lead to inconsistent rGFA.\n",
+					__func__, s->r->seq[i].name);
+	}
+	s->r->gcs[i] = mg_map(s->gi, s->r->seq[i].l_seq, s->r->seq[i].seq, s->buf[tid], s->opt, s->r->seq[i].name);
+}
+
+static maprst_t *ggen_map(const mg_idx_t *gi, const mg_mapopt_t *opt, const char *fn, int n_threads)
+{
+	mg_bseq_file_t *fp;
+	maprst_t *r;
+	step_t s;
+	int i;
+
+	fp = mg_bseq_open(fn);
+	if (fp == 0) return 0;
+
+	KCALLOC(0, r, 1);
+	r->seq = mg_bseq_read(fp, 1ULL<<62, 0, 0, 0, &r->n_seq);
+	mg_bseq_close(fp);
+	if (mg_verbose >= 3)
+		fprintf(stderr, "[M::%s::%.3f*%.2f] loaded file \"%s\"\n", __func__,
+				realtime() - mg_realtime0, cputime() / (realtime() - mg_realtime0), fn);
+	for (i = 0; i < r->n_seq; ++i) {
+		r->seq[i].rid = i;
+		mg_toupper(r->seq[i].l_seq, r->seq[i].seq);
+	}
+	KCALLOC(0, r->gcs, r->n_seq);
+
+	s.gi = gi, s.opt = opt, s.r = r;
+	KCALLOC(0, s.buf, n_threads);
+	for (i = 0; i < n_threads; ++i) s.buf[i] = mg_tbuf_init();
+	kt_for(n_threads, worker_for, &s, r->n_seq);
+	if (mg_verbose >= 3)
+		fprintf(stderr, "[M::%s::%.3f*%.2f] mapped %d sequence(s) to the graph\n", __func__,
+				realtime() - mg_realtime0, cputime() / (realtime() - mg_realtime0), r->n_seq);
+	for (i = 0; i < n_threads; ++i) mg_tbuf_destroy(s.buf[i]);
+	free(s.buf);
+	return r;
+}
+
+static void mg_free_maprst(maprst_t *r)
+{
+	int i;
+	for (i = 0; i < r->n_seq; ++i) {
+		mg_gchain_free(r->gcs[i]);
+		free(r->seq[i].seq); free(r->seq[i].name);
+	}
+	free(r->gcs); free(r->seq);
+	free(r);
+}
+
+int mg_ggen_aug(gfa_t *g, int32_t n_fn, const char **fn, const mg_idxopt_t *ipt, const mg_mapopt_t *opt0, const mg_ggopt_t *go, int n_threads)
+{
+	int i;
+	mg_mapopt_t opt = *opt0;
+	if (g == 0) return -1;
+	for (i = 0; i < n_fn; ++i) {
+		mg_idx_t *gi;
+		maprst_t *r;
+		if ((gi = mg_index(g, ipt, n_threads, &opt)) == 0) return -1;
+		r = ggen_map(gi, &opt, fn[i], n_threads);
+		if (opt0->flag & MG_M_CIGAR)
+			mg_ggsimple_cigar(0, go, g, r->n_seq, r->seq, r->gcs);
+		else
+			mg_ggsimple(0, go, g, r->n_seq, r->seq, r->gcs);
+		mg_free_maprst(r);
+		mg_idx_destroy(gi);
+	}
+	return 0;
+}
+
+int mg_ggen_cov(gfa_t *g, int32_t n_fn, const char **fn, const mg_idxopt_t *ipt, const mg_mapopt_t *opt0, const mg_ggopt_t *go, int n_threads)
+{
+	int32_t i;
+	mg_mapopt_t opt = *opt0;
+	mg_idx_t *gi;
+	double *cov_seg, *cov_link;
+	int64_t j;
+	if ((gi = mg_index(g, ipt, n_threads, &opt)) == 0) return -1;
+	KCALLOC(0, cov_seg,  g->n_seg);
+	KCALLOC(0, cov_link, g->n_arc);
+	for (i = 0; i < n_fn; ++i) {
+		maprst_t *r;
+		r = ggen_map(gi, &opt, fn[i], n_threads);
+		mg_cov_asm(g, r->n_seq, r->gcs, go->min_mapq, go->min_map_len, cov_seg, cov_link);
+		mg_free_maprst(r);
+	}
+	mg_idx_destroy(gi);
+	for (j = 0; j < g->n_seg; ++j) cov_seg[j] /= n_fn;
+	for (j = 0; j < g->n_arc; ++j) cov_link[j] /= n_fn;
+	gfa_aux_update_cv(g, "cf", cov_seg, cov_link);
+	free(cov_seg); free(cov_link);
+	return 0;
+}
+
+int mg_ggen_call(gfa_t *g, const char *fn, const mg_idxopt_t *ipt, const mg_mapopt_t *opt0, const mg_ggopt_t *go, int n_threads)
+{
+	mg_mapopt_t opt = *opt0;
+	mg_idx_t *gi;
+	maprst_t *r;
+	if ((gi = mg_index(g, ipt, n_threads, &opt)) == 0) return -1;
+	r = ggen_map(gi, &opt, fn, n_threads);
+	mg_call_asm(g, r->n_seq, r->seq, r->gcs, go->min_mapq, go->min_map_len);
+	mg_free_maprst(r);
+	mg_idx_destroy(gi);
+	return 0;
+}
+
+int mg_ggen(gfa_t *g, int32_t n_fn, const char **fn, const mg_idxopt_t *ipt, const mg_mapopt_t *opt, const mg_ggopt_t *go, int n_threads)
+{
+	if (go->flag & MG_G_CALL) return mg_ggen_call(g, fn[0], ipt, opt, go, n_threads);
+	else if (go->flag & MG_G_CAL_COV) return mg_ggen_cov(g, n_fn, fn, ipt, opt, go, n_threads);
+	else return mg_ggen_aug(g, n_fn, fn, ipt, opt, go, n_threads);
+}
+
+int32_t mg_path2seq(void *km, const gfa_t *g, const mg_gchains_t *gcs, int32_t ls, int32_t le, int32_t voff[2], char **seq_, int32_t *cap_) // NB: [ls,le] is a CLOSED interval
+{
+	extern unsigned char gfa_comp_table[256];
+	int32_t i, k, l = 0, cap = *cap_;
+	char *seq = *seq_;
+	assert(0 <= ls && ls <= le && le < gcs->n_lc);
+	for (k = ls; k <= le; ++k) {
+		uint32_t v = gcs->lc[k].v, len = g->seg[v>>1].len;
+		int32_t st = 0, en = len, tmp;
+		if (k == ls) st = voff[0];
+		if (k == le) en = voff[1];
+		assert(0 <= st && st <= en && en <= len);
+		if (en - st + l + 1 > cap) {
+			cap = en - st + l + 1;
+			kroundup32(cap);
+			KREALLOC(km, seq, cap);
+		}
+		if (v&1) {
+			uint8_t *ss = (uint8_t*)g->seg[v>>1].seq;
+			tmp = st, st = len - en, en = len - tmp;
+			for (i = en - 1; i >= st; --i)
+				seq[l++] = gfa_comp_table[ss[i]];
+		} else {
+			memcpy(&seq[l], &g->seg[v>>1].seq[st], en - st);
+			l += en - st;
+		}
+	}
+	if (l == 0 && cap == 0) {
+		cap = 8;
+		KREALLOC(km, seq, cap);
+	}
+	seq[l] = 0;
+	*seq_ = seq, *cap_ = cap;
+	return l;
+}

data/ext/minigraph/ggen.h

@@ -0,0 +1,21 @@
+#ifndef MG_GGEN_H
+#define MG_GGEN_H
+
+#include "minigraph.h"
+#include "bseq.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int32_t mg_path2seq(void *km, const gfa_t *g, const mg_gchains_t *gcs, int32_t ls, int32_t le, int32_t voff[2], char **seq_, int32_t *cap_);
+void mg_ggsimple(void *km, const mg_ggopt_t *opt, gfa_t *g, int32_t n_seq, const mg_bseq1_t *seq, mg_gchains_t *const* gcs);
+void mg_ggsimple_cigar(void *km, const mg_ggopt_t *opt, gfa_t *g, int32_t n_seq, const mg_bseq1_t *seq, mg_gchains_t *const* gcs);
+
+void mg_call_asm(const gfa_t *g, int32_t n_seq, const mg_bseq1_t *seq, mg_gchains_t *const *gcs, int32_t min_mapq, int32_t min_blen);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif