xxay/hifiasm
1
0
Fork 0
mirror of https://github.com/chhylp123/hifiasm.git synced 2026-10-04 01:48:11 +08:00
Code Issues Packages Projects Releases Wiki Activity

rename for naming consistency

Browse Source
This commit is contained in:
Heng Li
2020-03-25 19:25:57 -04:00
parent e116f6e09d
commit 5a6b97145a
1 changed files with 60 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files
yak-count.cpp
+60 -60
View File
@@ -61,24 +61,24 @@ void yak_copt_init(yak_copt_t *o)
* Count hash table *
********************/
#define yak_ch_eq(a, b) ((a)>>YAK_COUNTER_BITS == (b)>>YAK_COUNTER_BITS) // lower 8 bits for counts; higher bits for k-mer
#define yak_ch_hash(a) ((a)>>YAK_COUNTER_BITS)
KHASHL_SET_INIT(static klib_unused, yak_ht_t, yak_ht, uint64_t, yak_ch_hash, yak_ch_eq)
#define yak_ct_eq(a, b) ((a)>>YAK_COUNTER_BITS == (b)>>YAK_COUNTER_BITS) // lower 8 bits for counts; higher bits for k-mer
#define yak_ct_hash(a) ((a)>>YAK_COUNTER_BITS)
KHASHL_SET_INIT(static klib_unused, yak_ht_t, yak_ht, uint64_t, yak_ct_hash, yak_ct_eq)
typedef struct {
yak_ht_t *h;
yak_bf_t *b;
} yak_ch1_t;
} ha_ct1_t;
typedef struct {
int k, pre, n_hash, n_shift;
uint64_t tot;
yak_ch1_t *h;
} yak_ch_t;
ha_ct1_t *h;
} ha_ct_t;
static yak_ch_t *yak_ch_init(int k, int pre, int n_hash, int n_shift)
static ha_ct_t *ha_ct_init(int k, int pre, int n_hash, int n_shift)
{
yak_ch_t *h;
ha_ct_t *h;
int i;
if (pre < YAK_COUNTER_BITS) return 0;
CALLOC(h, 1);
@@ -94,7 +94,7 @@ static yak_ch_t *yak_ch_init(int k, int pre, int n_hash, int n_shift)
return h;
}
static void yak_ch_destroy_bf(yak_ch_t *h)
static void ha_ct_destroy_bf(ha_ct_t *h)
{
int i;
for (i = 0; i < 1<<h->pre; ++i) {
@@ -104,20 +104,20 @@ static void yak_ch_destroy_bf(yak_ch_t *h)
}
}
static void yak_ch_destroy(yak_ch_t *h)
static void ha_ct_destroy(ha_ct_t *h)
{
int i;
if (h == 0) return;
yak_ch_destroy_bf(h);
ha_ct_destroy_bf(h);
for (i = 0; i < 1<<h->pre; ++i)
yak_ht_destroy(h->h[i].h);
free(h->h); free(h);
}
static int yak_ch_insert_list(yak_ch_t *h, int create_new, int n, const uint64_t *a)
static int ha_ct_insert_list(ha_ct_t *h, int create_new, int n, const uint64_t *a)
{
int j, mask = (1<<h->pre) - 1, n_ins = 0;
yak_ch1_t *g;
ha_ct1_t *g;
if (n == 0) return 0;
g = &h->h[a[0]&mask];
for (j = 0; j < n; ++j) {
@@ -150,7 +150,7 @@ typedef struct {
} buf_cnt_t;
typedef struct {
const yak_ch_t *h;
const ha_ct_t *h;
buf_cnt_t *cnt;
} hist_aux_t;
@@ -165,7 +165,7 @@ static void worker_hist(void *data, long i, int tid) // callback for kt_for()
++cnt[kh_key(g, k)&YAK_MAX_COUNT];
}
static void yak_ch_hist(const yak_ch_t *h, int64_t cnt[YAK_N_COUNTS], int n_thread)
static void ha_ct_hist(const ha_ct_t *h, int64_t cnt[YAK_N_COUNTS], int n_thread)
{
hist_aux_t a;
int i, j;
@@ -184,13 +184,13 @@ static void yak_ch_hist(const yak_ch_t *h, int64_t cnt[YAK_N_COUNTS], int n_thre
typedef struct {
int min, max;
yak_ch_t *h;
ha_ct_t *h;
} shrink_aux_t;
static void worker_shrink(void *data, long i, int tid) // callback for kt_for()
{
shrink_aux_t *a = (shrink_aux_t*)data;
yak_ch_t *h = a->h;
ha_ct_t *h = a->h;
yak_ht_t *g = h->h[i].h, *f;
khint_t k;
f = yak_ht_init();
@@ -206,7 +206,7 @@ static void worker_shrink(void *data, long i, int tid) // callback for kt_for()
h->h[i].h = f;
}
static void yak_ch_shrink(yak_ch_t *h, int min, int max, int n_thread)
static void ha_ct_shrink(ha_ct_t *h, int min, int max, int n_thread)
{
int i;
shrink_aux_t a;
@@ -220,7 +220,7 @@ static void yak_ch_shrink(yak_ch_t *h, int min, int max, int n_thread)
* Position hash table *
***********************/
KHASHL_MAP_INIT(static klib_unused, yak_pt_t, yak_pt, uint64_t, uint64_t, yak_ch_hash, yak_ch_eq)
KHASHL_MAP_INIT(static klib_unused, yak_pt_t, yak_pt, uint64_t, uint64_t, yak_ct_hash, yak_ct_eq)
typedef struct {
yak_pt_t *h;
@@ -235,15 +235,15 @@ typedef struct {
} ha_pt_t;
typedef struct {
const yak_ch_t *ch;
ha_pt_t *ph;
const ha_ct_t *ct;
ha_pt_t *pt;
} pt_gen_aux_t;
static void worker_pt_gen(void *data, long i, int tid) // callback for kt_for()
{
pt_gen_aux_t *a = (pt_gen_aux_t*)data;
ha_pt1_t *b = &a->ph->h[i];
yak_ht_t *g = a->ch->h[i].h;
ha_pt1_t *b = &a->pt->h[i];
yak_ht_t *g = a->ct->h[i].h;
khint_t k;
for (k = 0, b->n = 0; k != kh_end(g); ++k) {
if (kh_exist(g, k)) {
@@ -257,21 +257,21 @@ static void worker_pt_gen(void *data, long i, int tid) // callback for kt_for()
CALLOC(b->a, b->n);
}
ha_pt_t *ha_pt_gen(const yak_ch_t *ch, int n_thread)
ha_pt_t *ha_pt_gen(const ha_ct_t *ct, int n_thread)
{
pt_gen_aux_t a;
int i;
ha_pt_t *ph;
CALLOC(ph, 1);
ph->k = ch->k, ph->pre = ch->pre, ph->tot = ch->tot;
CALLOC(ph->h, 1<<ph->pre);
for (i = 0; i < 1<<ph->pre; ++i) {
ph->h[i].h = yak_pt_init();
yak_pt_resize(ph->h[i].h, kh_size(ch->h[i].h));
ha_pt_t *pt;
CALLOC(pt, 1);
pt->k = ct->k, pt->pre = ct->pre, pt->tot = ct->tot;
CALLOC(pt->h, 1<<pt->pre);
for (i = 0; i < 1<<pt->pre; ++i) {
pt->h[i].h = yak_pt_init();
yak_pt_resize(pt->h[i].h, kh_size(ct->h[i].h));
}
a.ch = ch, a.ph = ph;
kt_for(n_thread, worker_pt_gen, &a, 1<<ph->pre);
return ph;
a.ct = ct, a.pt = pt;
kt_for(n_thread, worker_pt_gen, &a, 1<<pt->pre);
return pt;
}
static int ha_pt_insert_list(ha_pt_t *h, int n, const ha_mz1_t *a)
@@ -376,8 +376,8 @@ typedef struct { // global data structure for kt_pipeline()
const void *flt_tab;
int create_new, is_store;
kseq_t *ks;
yak_ch_t *h;
ha_pt_t *ph;
ha_ct_t *ct;
ha_pt_t *pt;
} pl_data_t;
typedef struct { // data structure for each step in kt_pipeline()
@@ -394,10 +394,10 @@ static void worker_for_insert(void *data, long i, int tid) // callback for kt_fo
{
st_data_t *s = (st_data_t*)data;
ch_buf_t *b = &s->buf[i];
if (s->p->ph)
b->n_ins += ha_pt_insert_list(s->p->ph, b->n, b->b);
if (s->p->pt)
b->n_ins += ha_pt_insert_list(s->p->pt, b->n, b->b);
else
b->n_ins += yak_ch_insert_list(s->p->h, s->p->create_new, b->n, b->a);
b->n_ins += ha_ct_insert_list(s->p->ct, s->p->create_new, b->n, b->a);
}
static void worker_for_mz(void *data, long i, int tid)
@@ -466,7 +466,7 @@ static void *worker_count(void *data, int step, void *in) // callback for kt_pip
free(s->mz_buf[i].a);
free(s->mz_buf);
// insert minimizers
if (p->ph) {
if (p->pt) {
for (i = 0; i < s->n_seq; ++i)
for (j = 0; j < s->mz[i].n; ++j)
pt_insert_buf(s->buf, p->opt->pre, &s->mz[i].a[j]);
@@ -493,16 +493,16 @@ static void *worker_count(void *data, int step, void *in) // callback for kt_pip
n_ins += s->buf[i].n_ins;
free(s->buf[i].a);
}
p->h->tot += n_ins;
p->ct->tot += n_ins;
free(s->buf);
fprintf(stderr, "[M::%s::%.3f*%.2f] processed %d sequences; %ld distinct k-mers in the hash table\n", __func__,
yak_realtime(), yak_cputime() / yak_realtime(), s->n_seq, (long)p->h->tot);
yak_realtime(), yak_cputime() / yak_realtime(), s->n_seq, (long)p->ct->tot);
free(s);
}
return 0;
}
static yak_ch_t *yak_count(const char *fn, const yak_copt_t *opt, yak_ch_t *h0, const void *flt_tab)
static ha_ct_t *yak_count(const char *fn, const yak_copt_t *opt, ha_ct_t *h0, const void *flt_tab)
{
pl_data_t pl;
gzFile fp;
@@ -512,33 +512,33 @@ static yak_ch_t *yak_count(const char *fn, const yak_copt_t *opt, yak_ch_t *h0,
pl.flt_tab = flt_tab;
pl.opt = opt;
if (h0) {
pl.h = h0, pl.create_new = 0;
pl.ct = h0, pl.create_new = 0;
assert(h0->k == opt->k && h0->pre == opt->pre);
} else {
pl.create_new = 1;
pl.h = yak_ch_init(opt->k, opt->pre, opt->bf_n_hash, opt->bf_shift);
pl.ct = ha_ct_init(opt->k, opt->pre, opt->bf_n_hash, opt->bf_shift);
}
kt_pipeline(3, worker_count, &pl, 3);
kseq_destroy(pl.ks);
gzclose(fp);
return pl.h;
return pl.ct;
}
static yak_ch_t *yak_count_file(const yak_copt_t *opt, int n_fn, char **fn, const void *flt_tab)
static ha_ct_t *yak_count_file(const yak_copt_t *opt, int n_fn, char **fn, const void *flt_tab)
{
int i;
yak_ch_t *h = 0;
ha_ct_t *h = 0;
for (i = 0; i < n_fn; ++i)
h = yak_count(fn[i], opt, h, flt_tab);
if (opt->bf_shift > 0)
yak_ch_destroy_bf(h);
ha_ct_destroy_bf(h);
return h;
}
yak_ch_t *ha_count(const hifiasm_opt_t *asm_opt, int is_exact, int count_all, const void *flt_tab)
ha_ct_t *ha_count(const hifiasm_opt_t *asm_opt, int is_exact, int count_all, const void *flt_tab)
{
yak_copt_t opt;
yak_ch_t *h;
ha_ct_t *h;
yak_copt_init(&opt);
opt.k = asm_opt->k_mer_length;
opt.is_HPC = !asm_opt->no_HPC;
@@ -555,7 +555,7 @@ yak_ch_t *ha_count(const hifiasm_opt_t *asm_opt, int is_exact, int count_all, co
KHASHL_SET_INIT(static klib_unused, yak_ft_t, yak_ft, uint64_t, kh_hash_dummy, kh_eq_generic)
static yak_ft_t *gen_hh(const yak_ch_t *h)
static yak_ft_t *gen_hh(const ha_ct_t *h)
{
int i;
yak_ft_t *hh;
@@ -597,16 +597,16 @@ void *ha_gen_flt_tab(const hifiasm_opt_t *asm_opt)
yak_ft_t *flt_tab;
int64_t cnt[YAK_N_COUNTS];
int peak_hom, peak_het, cutoff;
yak_ch_t *h;
ha_ct_t *h;
h = ha_count(asm_opt, 0, 1, 0);
yak_ch_hist(h, cnt, asm_opt->thread_num);
ha_ct_hist(h, cnt, asm_opt->thread_num);
peak_hom = yak_analyze_count(YAK_N_COUNTS, cnt, &peak_het);
if (peak_hom > 0) fprintf(stderr, "[M::%s] peak_hom: %d; peak_het: %d\n", __func__, peak_hom, peak_het);
cutoff = (int)(peak_hom * asm_opt->high_factor);
if (cutoff > YAK_MAX_COUNT - 1) cutoff = YAK_MAX_COUNT - 1;
yak_ch_shrink(h, cutoff, YAK_MAX_COUNT, asm_opt->thread_num);
ha_ct_shrink(h, cutoff, YAK_MAX_COUNT, asm_opt->thread_num);
flt_tab = gen_hh(h);
yak_ch_destroy(h);
ha_ct_destroy(h);
fprintf(stderr, "[M::%s] filtered out %ld k-mers occurring %d or more times\n",
__func__, (long)kh_size(flt_tab), cutoff);
return (void*)flt_tab;
@@ -616,13 +616,13 @@ void *ha_gen_mzidx(const hifiasm_opt_t *asm_opt, const void *flt_tab)
{
int64_t cnt[YAK_N_COUNTS];
int peak_hom, peak_het;
yak_ch_t *h;
ha_ct_t *h;
h = ha_count(asm_opt, 1, 0, flt_tab);
yak_ch_hist(h, cnt, asm_opt->thread_num);
ha_ct_hist(h, cnt, asm_opt->thread_num);
fprintf(stderr, "[M::%s] count[%d] = %ld (for sanity check)\n", __func__, YAK_MAX_COUNT, (long)cnt[YAK_MAX_COUNT]);
peak_hom = yak_analyze_count(YAK_N_COUNTS, cnt, &peak_het);
if (peak_hom > 0) fprintf(stderr, "[M::%s] peak_hom: %d; peak_het: %d\n", __func__, peak_hom, peak_het);
yak_ch_shrink(h, 2, YAK_MAX_COUNT - 1, asm_opt->thread_num);
yak_ch_destroy(h);
ha_ct_shrink(h, 2, YAK_MAX_COUNT - 1, asm_opt->thread_num);
ha_ct_destroy(h);
return 0;
}