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

tmp cache

Browse Source
This commit is contained in:
chhylp123
2022-11-10 19:37:52 -05:00
parent 46acc8a2f6
commit 2c7b164f11
11 changed files with 1919 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Assembly.cpp
+3 -2
View File
@@ -1784,8 +1784,9 @@ int ha_assemble(void)
ha_extract_print_list(&R_INF, asm_opt.extract_iter, asm_opt.extract_list);
exit(0);
}
if (!(asm_opt.flag & HA_F_SKIP_TRIOBIN) && !(asm_opt.flag & HA_F_VERBOSE_GFA)) ha_triobin(&asm_opt);
///if (!(asm_opt.flag & HA_F_SKIP_TRIOBIN)) ha_triobin(&asm_opt), ovlp_loaded = 2;
// if (!(asm_opt.flag & HA_F_SKIP_TRIOBIN) && !(asm_opt.flag & HA_F_VERBOSE_GFA)) ha_triobin(&asm_opt);
if (!(asm_opt.flag & HA_F_SKIP_TRIOBIN)) ha_triobin(&asm_opt);
// if (!(asm_opt.flag & HA_F_SKIP_TRIOBIN)) ha_triobin(&asm_opt), ovlp_loaded = 2;
if (asm_opt.flag & HA_F_WRITE_EC) Output_corrected_reads();
if (asm_opt.flag & HA_F_WRITE_PAF) Output_PAF();
if (asm_opt.het_cov == -1024) hap_recalculate_peaks(asm_opt.output_file_name), ovlp_loaded = 2;
CommandLines.h
+1 -1
View File
@@ -4,7 +4,7 @@
#include <pthread.h>
#include <stdint.h>
#define HA_VERSION "0.17.2-r432"
#define HA_VERSION "0.17.2-r433"
#define VERBOSE 0
Correct.cpp
+147 -12
View File
@@ -15508,6 +15508,24 @@ void push_sec_aln(overlap_region *z, int64_t s, int64_t e, int64_t sec_err)
p->x_start = s; p->x_end = e; p->clen += sec_err;
}
void push_sec_aln_robust(overlap_region *z, int64_t s, int64_t e, int64_t sec_err)
{
window_list *p;
if(z->align_length > 0) {
p = z->w_list.a + z->w_list.n + z->align_length - 1;
if((p->x_end == s) && (p->clen == 0) && ((!!(p->clen)) == (!!sec_err))) {
p->x_end = e; p->clen += sec_err;
return;
}
}
if((z->w_list.n+z->align_length)==z->w_list.m) {
z->w_list.m = z->w_list.m? z->w_list.m<<1 : 2;
z->w_list.a = (window_list*)realloc(z->w_list.a, sizeof(window_list)*z->w_list.m);
}
p = &(z->w_list.a[z->w_list.n+z->align_length]); z->align_length++; memset(p, 0, sizeof((*p)));
p->x_start = s; p->x_end = e; p->clen += sec_err;
}
// #define id_mm ((uint64_t)0x7fffffffffffffff)
#define id_set ((uint64_t)0x8000000000000000)
#define id_get(a) ((uint32_t)(a))
@@ -15564,6 +15582,8 @@ uint64_t gen_region_phase(overlap_region* ol, uint64_t *id_a, uint64_t id_n, uin
// fprintf(stderr, "---[M::%s::utg%.6dl] wid::%u, xoff::%u, coff::%u, err::%ld\n", __func__,
// (int32_t)ol[ovlp_id(*p)].y_id+1, ovlp_cur_wid(*p), ovlp_cur_xoff(*p), ovlp_cur_coff(*p), err);
fprintf(stderr, "---[M::%s::utg%.6dl] xoff::[%lu, %lu), err::%ld\n", __func__,
(int32_t)ol[ovlp_id(*p)].y_id+1, s, e, err);
assert(err >= 0);
if(err < msc) {
msc = err; msc_k = k; msc_n = 1;
@@ -15604,7 +15624,7 @@ uint64_t gen_region_phase(overlap_region* ol, uint64_t *id_a, uint64_t id_n, uin
// (int32_t)ol[oid].y_id+1, s, e);
}
for (k = 0; k < mn; k++) {
for (k = 0; k < mn; k++) {///best alignment
z = &(ol[id_get(buf->a[k])]);
reassign_sec_err(ol, ovidx, buf, k);
push_sec_aln(z, s, e, 0);
@@ -15634,6 +15654,111 @@ uint64_t gen_region_phase(overlap_region* ol, uint64_t *id_a, uint64_t id_n, uin
}
///[s, e)
uint64_t gen_region_phase_robust(overlap_region* ol, uint64_t *id_a, uint64_t id_n, uint64_t s, uint64_t e, uint64_t dp, ul_ov_t *c_idx, asg64_v *buf)
{
if(!id_n) return id_n;
uint64_t k, m, mn, q[2], buf_n, rm_n, oid; int64_t err, msc, msc_k, msc_n;
overlap_region *z; ul_ov_t *p; buf->n = 0; kv_resize(uint64_t, *buf, dp);
for (k = buf_n = rm_n = 0; k < id_n; k++) {
p = &(c_idx[id_a[k]]);
q[0] = ol[ovlp_id(*p)].w_list.a[ovlp_min_wid(*p)].x_start;
q[1] = ol[ovlp_id(*p)].w_list.a[ovlp_max_wid(*p)].x_end+1;
if(q[0]<=s && q[1]>=e) {
kv_push(uint64_t, *buf, id_a[k]);
// buf[buf_n++] = id_a[k];
}
if(q[1] < e) rm_n++;
}
buf_n = buf->n;
assert(buf_n == dp);//not right
if(buf_n > 0) {
for (k = 0, msc = INT32_MAX, msc_k = -1, msc_n = 0; k < buf_n; k++) {
p = &(c_idx[(uint32_t)buf->a[k]]); z = &(ol[ovlp_id(*p)]);
// fprintf(stderr, "+++[M::%s::utg%.6dl] wid::%u, xoff::%u, coff::%u\n", __func__,
// (int32_t)ol[ovlp_id(*p)].y_id+1, ovlp_cur_wid(*p), ovlp_cur_xoff(*p), ovlp_cur_coff(*p));
err = extract_sub_cigar_err(z, s, e, p);
// int64_t debug_err = extract_sub_cigar_err_debug(z, s, e);
// assert(err == debug_err);
// fprintf(stderr, "[M::%s::] err::%ld, debug_err::%ld\n", __func__, err, debug_err);
// fprintf(stderr, "---[M::%s::utg%.6dl] wid::%u, xoff::%u, coff::%u, err::%ld\n", __func__,
// (int32_t)ol[ovlp_id(*p)].y_id+1, ovlp_cur_wid(*p), ovlp_cur_xoff(*p), ovlp_cur_coff(*p), err);
// fprintf(stderr, "---[M::%s::utg%.6dl] xoff::[%lu, %lu), err::%ld\n", __func__,
// (int32_t)ol[ovlp_id(*p)].y_id+1, s, e, err);
assert(err >= 0);
if(err < msc) {
msc = err; msc_k = k; msc_n = 1;
} else if(err == msc) {
msc_n++;
}
buf->a[k] |= (((uint64_t)err)<<32);
}
if(msc_n == 1) {
p = &(c_idx[(uint32_t)buf->a[msc_k]]);
z = &(ol[ovlp_id(*p)]); mn = 1;
if(msc_k != 0) {
m = buf->a[msc_k];
buf->a[msc_k] = buf->a[0];
buf->a[0] = m;
}
} else {
for (k = mn = 0; k < buf_n && (int64_t)mn < msc_n; k++) {
p = &(c_idx[(uint32_t)buf->a[k]]);
z = &(ol[ovlp_id(*p)]);
if((buf->a[k]>>32) == (uint64_t)msc) {
if(mn != k) {
m = buf->a[k];
buf->a[k] = buf->a[mn];
buf->a[mn] = m;
}
mn++;
}
}
}
// fprintf(stderr, "[M::%s] buf_n::%ld, msc_n::%ld, mn::%lu\n", __func__, buf_n, msc_n, mn);
for (k = 0; k < buf_n; k++) {
oid = ovlp_id((c_idx[(uint32_t)buf->a[k]]));
buf->a[k] >>= 32; buf->a[k] <<= 32; buf->a[k] |= oid;
// ol[oid].overlapLen = k;//no need to set
// if(s == 158482) fprintf(stderr, "k->%ld::oid->%ld[M::%s::utg%.6dl] pos::[%lu, %lu)\n", k, oid, __func__,
// (int32_t)ol[oid].y_id+1, s, e);
}
for (k = 0; k < mn; k++) {///best alignment
z = &(ol[id_get(buf->a[k])]);
// reassign_sec_err(ol, ovidx, buf, k);
// push_sec_aln(z, s, e, 0);
push_sec_aln_robust(z, s, e, 0);
}
for (k = mn; k < buf_n; k++) {
z = &(ol[id_get(buf->a[k])]);
// push_sec_aln(z, s, e, ((buf->a[k]&id_set)?(0):(err_get(buf->a[k])-msc)));
push_sec_aln_robust(z, s, e, (err_get(buf->a[k])-msc));
}
// for (k = 0; k < buf_n; k++) {
// ol[id_get(buf->a[k])].overlapLen = (uint32_t)-1;
// }
}
if(rm_n) {
for (k = m = 0; k < id_n; k++) {
p = &(c_idx[id_a[k]]);
q[1] = ol[ovlp_id(*p)].w_list.a[ovlp_max_wid(*p)].x_end+1;
if(q[1] < e) continue;
id_a[m++] = id_a[k];
}
id_n = m;
}
return id_n;
}
int64_t infer_rovlp(ul_ov_t *li, ul_ov_t *lj, uc_block_t *bi, uc_block_t *bj, All_reads *ridx, ma_ug_t *ug)
{
int64_t in, is, ie, irev, iqs, iqe, jn, js, je, jrev, jqs, jqe, ir, jr, ts, te, max_s, min_e, s_shift, e_shift;
@@ -15830,7 +15955,7 @@ void gen_gov_idx(overlap_region_alloc* ol, const ul_idx_t *uref, const ug_opt_t
// }
}
void prt_overlap_region_stat(overlap_region *z)
void prt_overlap_region_stat(overlap_region *z, int64_t sid)
{
uint64_t k = 0, aln = 0, ualn = 0, err = 0;
for (k = 0; k < z->w_list.n; k++) {
@@ -15841,21 +15966,20 @@ void prt_overlap_region_stat(overlap_region *z)
err += z->w_list.a[k].error;
}
}
fprintf(stderr, "[M::%s::utg%.6dl::%c] q::[%d, %d), t::[%d, %d), aln::%lu, ualn::%lu, err::%lu, flen::%u, blen::%u, sec_err::%u\n", __func__,
(int32_t)z->y_id+1, "+-"[z->y_pos_strand], z->x_pos_s, z->x_pos_e+1, z->y_pos_s, z->y_pos_e+1, aln, ualn, err,
z->overlapLen, z->align_length, z->non_homopolymer_errors);
fprintf(stderr, "[M::%s::utg%.6dl::%c] sid::%ld, q::[%d, %d), t::[%d, %d), aln::%lu, ualn::%lu, err::%lu\n",
__func__, (int32_t)z->y_id+1, "+-"[z->y_pos_strand], sid, z->x_pos_s, z->x_pos_e+1,
z->y_pos_s, z->y_pos_e+1, aln, ualn, err);
}
void prt_overlap_region_phase_stat(overlap_region *z)
void prt_overlap_region_phase_stat(overlap_region *z, int64_t sid)
{
uint64_t k = 0;
fprintf(stderr, "[M::%s::utg%.6dl::%c] q::[%d, %d), t::[%d, %d), best::%u, sec::%u\n", __func__,
(int32_t)z->y_id+1, "+-"[z->y_pos_strand], z->x_pos_s, z->x_pos_e+1, z->y_pos_s, z->y_pos_e+1,
z->align_length, z->non_homopolymer_errors);
fprintf(stderr, "[M::%s::utg%.6dl::%c] sid::%ld, q::[%d, %d), t::[%d, %d)\n", __func__,
(int32_t)z->y_id+1, "+-"[z->y_pos_strand], sid, z->x_pos_s, z->x_pos_e+1, z->y_pos_s, z->y_pos_e+1);
for (k = 0; k < z->w_list.n; k++) {
fprintf(stderr, "[k::%lu] q::[%d, %d), sec::%u\n", k,
fprintf(stderr, "[k::%lu] sid::%ld, q::[%d, %d), sec::%u\n", k, sid,
z->w_list.a[k].x_start, z->w_list.a[k].x_end, z->w_list.a[k].clen);
}
}
@@ -15868,6 +15992,7 @@ void region_phase(overlap_region_alloc* ol, const ul_idx_t *uref, const ug_opt_t
kv_resize(ul_ov_t, *c_idx, ol->length);
for (k = idx->n = c_idx->n = 0; k < on; k++) {
z = &(ol->list[k]); zwn = z->w_list.n;
// prt_overlap_region_stat(z, ulid);
// if(ulid == 35437 && z->y_id == 109111) {
// fprintf(stderr, "+0+[M::%s::utg%.6dl::%c] ulid::%ld, all::%u, non-best::%ld, best::%u\n", __func__,
// (int32_t)z->y_id+1, "+-"[z->y_pos_strand], ulid, z->overlapLen, zwn, z->align_length);
@@ -15927,7 +16052,8 @@ void region_phase(overlap_region_alloc* ol, const ul_idx_t *uref, const ug_opt_t
// }
}
radix_sort_bc64(idx->a, idx->a+idx->n);
gen_gov_idx(ol, uref, uopt, G_CHAIN_BW, N_GCHAIN_RATE, buf1);
//this is used with gen_region_phase, now give up
//gen_gov_idx(ol, uref, uopt, G_CHAIN_BW, N_GCHAIN_RATE, buf1);
// for (m = 0; m < c_idx->n; m++) {
// fprintf(stderr, "+++[M::%s::utg%.6dl] q[%d, %d), t[%d, %d), wn::%d\n", __func__,
// (int32_t)ol->list[ovlp_id(c_idx->a[m])].y_id+1,
@@ -15954,7 +16080,8 @@ void region_phase(overlap_region_alloc* ol, const ul_idx_t *uref, const ug_opt_t
if((end > beg) && (old_dp >= 2)) {
// fprintf(stderr, "\n[M::%s::] beg::%ld, end::%ld, old_dp::%ld\n", __func__, beg, end, old_dp);
// kv_resize(uint64_t, *buf, ((uint32_t)old_dp)<<1);
idx->n = srt_n + gen_region_phase(ol->list, idx->a+srt_n, idx->n-srt_n, beg, end, old_dp, c_idx->a, buf, buf1);
// idx->n = srt_n + gen_region_phase(ol->list, idx->a+srt_n, idx->n-srt_n, beg, end, old_dp, c_idx->a, buf, buf1);
idx->n = srt_n + gen_region_phase_robust(ol->list, idx->a+srt_n, idx->n-srt_n, beg, end, old_dp, c_idx->a, buf);
}
beg = end;
}
@@ -15990,6 +16117,7 @@ void region_phase(overlap_region_alloc* ol, const ul_idx_t *uref, const ug_opt_t
// }
assert(zwn <= z->overlapLen);
z->align_length = z->overlapLen - zwn;
// prt_overlap_region_phase_stat(z, ulid);
// fprintf(stderr, "[M::%s::utg%.6dl::%c] all::%u, non-best::%ld, best::%u\n", __func__,
// (int32_t)z->y_id+1, "+-"[z->y_pos_strand], z->overlapLen, zwn, z->align_length);
// prt_overlap_region_phase_stat(&(ol->list[k]));
@@ -16328,6 +16456,13 @@ void ul_lalign(overlap_region_alloc* ol, Candidates_list *cl, const ul_idx_t *ur
ol->list[i] = t;
}
ol->list[k].is_match = 1; ol->list[k].non_homopolymer_errors = re;
// fprintf(stderr, "+[M::%s] on::%lu\n", __func__, ol->length);
/****for debug****/
// z = &(ol->list[k]);
// fprintf(stderr, "[M::%s::utg%.6dl::%c] sid::%ld, q::[%d, %d), t::[%d, %d), err::%u\n",
// __func__, (int32_t)z->y_id+1, "+-"[z->y_pos_strand], sid, z->x_pos_s, z->x_pos_e+1, z->y_pos_s, z->y_pos_e+1,
// z->non_homopolymer_errors);
/****for debug****/
k++;
}
}
Overlaps.cpp
+10 -6
View File
@@ -17798,6 +17798,7 @@ char *f_prefix, uint8_t *kpt_buf, kvec_asg_arc_t_warp *r_edges)
return NULL;
}
void filter_set_kug(uint8_t* trio_flag, asg_t *rg, uint8_t *rf, kvec_asg_arc_t_warp *r_edges, float f_rate, ma_ug_t **ug)
{
asg_t* nsg = (*ug)->g; ma_utg_t *u = NULL;
@@ -24843,14 +24844,16 @@ int load_ruIndex(R_to_U* ruIndex, char* read_file_name)
(ruIndex)->index = (uint32_t*)malloc(sizeof(uint32_t)*(ruIndex)->len);
f_flag += fread((ruIndex)->index, sizeof((ruIndex)->index[0]), (ruIndex)->len, fp);
R_INF.trio_flag = (uint8_t*)malloc(sizeof(uint8_t)*(ruIndex)->len);
f_flag += fread(R_INF.trio_flag, sizeof(R_INF.trio_flag[0]), (ruIndex)->len, fp);
if(!(asm_opt.ar)) {
R_INF.trio_flag = (uint8_t*)malloc(sizeof(uint8_t)*(ruIndex)->len);
f_flag += fread(R_INF.trio_flag, sizeof(R_INF.trio_flag[0]), (ruIndex)->len, fp);
}
// CALLOC(ruIndex->is_het, ruIndex->len);
// f_flag += fread(ruIndex->is_het, 1, ruIndex->len, fp);
f_flag += fread(&(asm_opt.hom_global_coverage_set), sizeof(asm_opt.hom_global_coverage_set), 1, fp);
f_flag += fread(&(asm_opt.hom_global_coverage), sizeof(asm_opt.hom_global_coverage), 1, fp);
// f_flag += fread(&(asm_opt.hom_global_coverage_set), sizeof(asm_opt.hom_global_coverage_set), 1, fp);
// f_flag += fread(&(asm_opt.hom_global_coverage), sizeof(asm_opt.hom_global_coverage), 1, fp);
free(index_name);
fflush(fp);
@@ -25187,7 +25190,7 @@ uint32_t is_collect_trans)
MALLOC(x->pos_idx, x->n); memset(x->pos_idx, -1, x->n*sizeof(uint64_t));
CALLOC(set, read_g->n_seq<<1);
CALLOC(x->cov, x->n);
for (i = 0; i < n_ux; i++)
for (i = 0; i < n_ux; i++)//get the coverage for each read
{
if(ug->g->seq[i].del) continue;
u = &(ug->u.a[i]);
@@ -31767,10 +31770,11 @@ ma_sub_t **coverage_cut_ptr, int debug_g)
debug_gfa:;
gen_ug_opt_t(&uopt, sources, reverse_sources, max_hang_length, mini_overlap_length, gap_fuzz, min_dp, readLen, coverage_cut, ruIndex,
(asm_opt.max_short_tip*2), 0.15, 3, 0.05, 0.9, &b_mask_t);
set_hom_global_coverage(&asm_opt, sg, coverage_cut, sources, reverse_sources, ruIndex, max_hang_length, mini_overlap_length);
}
if(asm_opt.ar) {
ul_realignment_gfa(&uopt, sg, clean_round, min_ovlp_drop_ratio, max_ovlp_drop_ratio,
asm_opt.max_short_tip, &b_mask_t, ha_opt_triobin(&asm_opt));
asm_opt.max_short_tip, &b_mask_t, ha_opt_triobin(&asm_opt), o_file);
}
// print_debug_gfa(sg, NULL, coverage_cut, "UL.debug", sources, ruIndex, max_hang_length, mini_overlap_length, 0, 0, 0);
/**
Overlaps.h
+4
View File
@@ -1141,6 +1141,10 @@ int64_t count_edges_v_w(asg_t *g, uint32_t v, uint32_t w);
void renew_utg(ma_ug_t **ug, asg_t* read_g, kvec_asg_arc_t_warp* edge);
void merge_unitig_content(ma_utg_t* collection, ma_ug_t* ug, asg_t* read_g, kvec_asg_arc_t_warp* edge);
// void break_ug_contig(ma_ug_t **ug, asg_t *read_g, All_reads *RNF, ma_sub_t *coverage_cut,
// ma_hit_t_alloc* sources, R_to_U* ruIndex, kvec_asg_arc_t_warp* edge, int max_hang, int min_ovlp,
// int* b_low_cov, int* b_high_cov, double m_rate);
#define JUNK_COV 5
#define DISCARD_RATE 0.8
gfa_ut.cpp
+1384 -62
View File
File diff suppressed because it is too large Load Diff
gfa_ut.h
+1 -1
View File
@@ -24,7 +24,7 @@ void asg_arc_cut_complex_bub_links(asg_t *g, asg64_v *in, float len_rat, float o
uint32_t asg_cut_large_indel(asg_t *g, asg64_v *in, int32_t max_ext, float ou_rat, uint32_t is_ou);
uint32_t asg_cut_semi_circ(asg_t *g, uint32_t lim_len, uint32_t is_clean);
void ul_realignment_gfa(ug_opt_t *uopt, asg_t *sg, int64_t clean_round, double min_ovlp_drop_ratio,
double max_ovlp_drop_ratio, int64_t max_tip, bub_label_t *b_mask_t, uint32_t is_trio);
double max_ovlp_drop_ratio, int64_t max_tip, bub_label_t *b_mask_t, uint32_t is_trio, char *o_file);
void recover_contain_g(asg_t *g, ma_hit_t_alloc *src, R_to_U* ruIndex, int64_t max_hang, int64_t min_ovlp, int64_t ul_occ);
void normalize_gou(asg_t *g);
void prt_specfic_sge(asg_t *g, uint32_t src, uint32_t dst, const char* cmd);
hic.cpp
+262
View File
@@ -2519,6 +2519,268 @@ void identify_bubbles(ma_ug_t* ug, bubble_type* bub, uint8_t *r_het_flag, kv_u_t
// fprintf(stderr, "-bub->index[18759]: %u, bub->num.n: %u\n", (uint32_t)bub->index[18759], bub->num.n);
}
uint32_t get_unitig_het_fly(ma_ug_t* ug, uint32_t uid, asg_t* sg, int64_t het_cov_thres,
ma_hit_t_alloc* sources, R_to_U* ruIndex, uint8_t* r_flag, uint32_t m_het_occ, uint32_t m_het_label,
uint32_t p_het_label, uint32_t n_het_label)
{
ma_utg_t *u = &(ug->u.a[uid]);
uint32_t k, i, j, rId, nv, tn, is_Unitig;
asg_arc_t *av = NULL; ma_hit_t *h;
int64_t R_bases = 0, C_bases = 0, cov;
///set
u = &(ug->u.a[uid]);
for (k = 0; k < u->n; k++) {
rId = u->a[k]>>33;
r_flag[rId] = 1;
}
for (i = 0; i < 2; i++) {
nv = asg_arc_n(ug->g, (uid<<1)+i);
av = asg_arc_a(ug->g, (uid<<1)+i);
for (j = 0; j < nv; j++) {
u = &(ug->u.a[av[j].v>>1]);
for (k = 0; k < u->n; k++) {
rId = u->a[k]>>33;
r_flag[rId] = 2;
}
}
}
u = &(ug->u.a[uid]);
for (k = 0; k < u->n; k++) {
if(u->a[k] == (uint64_t)-1) continue;
rId = u->a[k]>>33;
R_bases += sg->seq[rId].len;
for (j = 0; j < (uint64_t)(sources[rId].length); j++) {
h = &(sources[rId].buffer[j]);
if(h->el != 1) continue;
tn = Get_tn((*h));
if(sg->seq[tn].del == 1) {
///get the id of read that contains it
get_R_to_U(ruIndex, tn, &tn, &is_Unitig);
if(tn == (uint32_t)-1 || is_Unitig == 1 || sg->seq[tn].del == 1) continue;
}
if(sg->seq[tn].del == 1) continue;
if(r_flag[tn] == 0) continue;
if(r_flag[tn] == 1) {
C_bases += (Get_qe((*h)) - Get_qs((*h)));
}
if(r_flag[tn] == 2) {
C_bases += ((Get_qe((*h)) - Get_qs((*h)))/2);
}
}
}
///reset
u = &(ug->u.a[uid]);
for (k = 0; k < u->n; k++) {
rId = u->a[k]>>33;
r_flag[rId] = 0;
}
for (i = 0; i < 2; i++) {
nv = asg_arc_n(ug->g, (uid<<1)+i);
av = asg_arc_a(ug->g, (uid<<1)+i);
for (j = 0; j < nv; j++) {
u = &(ug->u.a[av[j].v>>1]);
for (k = 0; k < u->n; k++) {
rId = u->a[k]>>33;
r_flag[rId] = 0;
}
}
}
u = &(ug->u.a[uid]); cov = 0;
if(R_bases > 0) cov = C_bases/R_bases;
// if(uid == 9253) {
// fprintf(stderr, "[M::%s::uid->%u] u->n::%u, C_bases::%ld, R_bases::%ld, het_cov_thres::%ld, m_het_occ::%u\n",
// __func__, uid, (uint32_t)u->n, C_bases, R_bases, het_cov_thres, m_het_occ);
// }
if((cov <= (het_cov_thres*1.333333)) && (u->n >= m_het_occ)) return m_het_label; ///must het
if((cov >= (het_cov_thres*1.6))) return n_het_label; ///hom
return p_het_label; ///potential het
}
void identify_bubbles_recal(asg_t* sg, ma_ug_t* ug, bubble_type* bub, uint8_t *r_het_flag, ma_hit_t_alloc* sources, R_to_U* ruIndex,
kv_u_trans_t *ref)
{
asg_cleanup(ug->g);
if (!ug->g->is_symm) asg_symm(ug->g);
uint32_t v, n_vtx = ug->g->n_seq * 2, i, k, mode = (((uint32_t)-1)<<2);
uint32_t beg, sink, n, *a, n_occ;
uint64_t pathLen;
bub->ug = ug;
bub->b_bub = bub->b_end_bub = bub->tangle_bub = bub->cross_bub = bub->mess_bub = 0;
if(bub->round_id == 0)
{
buf_t b; memset(&b, 0, sizeof(buf_t)); b.a = (binfo_t*)calloc(n_vtx, sizeof(binfo_t));
uint64_t tLen = get_bub_pop_max_dist_advance(ug->g, &b);
kv_init(bub->list); kv_init(bub->num); kv_init(bub->pathLen);
kv_init(bub->b_s_idx); kv_malloc(bub->b_s_idx, ug->g->n_seq);
bub->b_ug = NULL; kv_init(bub->chain_weight);
bub->b_s_idx.n = ug->g->n_seq;
memset(bub->b_s_idx.a, -1, bub->b_s_idx.n * sizeof(uint64_t));
CALLOC(bub->index, n_vtx);
for (i = 0; i < ug->g->n_seq; i++) ug->g->seq[i].c = 0;
for (v = 0; v < n_vtx; ++v)
{
if(ug->g->seq[v>>1].del) continue;
if(asg_arc_n(ug->g, v) < 2) continue;
if((bub->index[v]&(uint32_t)3) != 0) continue;
if(asg_bub_pop1_primary_trio(ug->g, NULL, v, tLen, &b, (uint32_t)-1, (uint32_t)-1, 0, NULL, NULL, NULL, 0, 0, NULL))
{
//beg is v, end is b.S.a[0]
//note b.b include end, does not include beg
for (i = 0; i < b.b.n; i++)
{
if(b.b.a[i]==v || b.b.a[i]==b.S.a[0]) continue;
bub->index[b.b.a[i]] &= mode; bub->index[b.b.a[i]] += 1;
bub->index[b.b.a[i]^1] &= mode; bub->index[b.b.a[i]^1] += 1;
}
bub->index[v] &= mode; bub->index[v] += 2;
bub->index[b.S.a[0]^1] &= mode; bub->index[b.S.a[0]^1] += 3;
}
}
kvec_t_u32_warp stack, result;
kv_init(stack.a); kv_init(result.a);
for (v = 0; v < n_vtx; ++v)
{
if((bub->index[v]&(uint32_t)3) !=2) continue;
if(asg_bub_pop1_primary_trio(ug->g, ug, v, tLen, &b, (uint32_t)-1, (uint32_t)-1, 0, &pathLen, NULL, NULL, 0, 0, NULL))
{
//note b.b include end, does not include beg
i = b.b.n + 1;
if(b.b.n == 2 || b.b.n == 3 || b.b.n == 5)
{
for (i = 0; i < b.b.n; i++)
{
if(b.b.a[i]==v || b.b.a[i]==b.S.a[0]) continue;
dfs_bubble(ug->g, &stack, &result, b.b.a[i]>>1, v>>1, b.S.a[0]>>1);
if((result.a.n + 3) != b.b.n && (result.a.n + 2) != b.b.n) break;
}
}
if(i == b.b.n)
{
kv_push(uint32_t, bub->num, v);
}
else
{
kv_push(uint32_t, bub->num, v + (1<<31));
}
}
}
kv_destroy(stack.a); kv_destroy(result.a);
radix_sort_u32(bub->num.a, bub->num.a + bub->num.n);
bub->s_bub = 0;
for (k = 0; k < bub->num.n; k++)
{
if((bub->num.a[k]>>31) == 0) bub->s_bub++;
v = (bub->num.a[k]<<1)>>1;
bub->num.a[k] = bub->list.n;
if(asg_bub_pop1_primary_trio(ug->g, ug, v, tLen, &b, (uint32_t)-1, (uint32_t)-1, 0, &pathLen, NULL, NULL, 0, 0, NULL))
{
kv_push(uint64_t, bub->pathLen, pathLen);
//beg is v, end is b.S.a[0]
kv_push(uint32_t, bub->list, v);
kv_push(uint32_t, bub->list, b.S.a[0]^1);
//note b.b include end, does not include beg
for (i = 0; i < b.b.n; i++)
{
if(b.b.a[i]==v || b.b.a[i]==b.S.a[0]) continue;
kv_push(uint32_t, bub->list, b.b.a[i]);
}
}
}
kv_push(uint32_t, bub->num, bub->list.n);
free(b.a); free(b.S.a); free(b.T.a); free(b.b.a); free(b.e.a);
bub->f_bub = bub->num.n - 1; ///bub->s_bub = bub->num.n - 1;
uint64_t dip_thre_max;
memset(r_het_flag, 0, sizeof((*r_het_flag))*sg->n_seq);
if(asm_opt.hom_global_coverage_set) {
dip_thre_max = asm_opt.hom_global_coverage;
} else {
dip_thre_max = ((double)asm_opt.hom_global_coverage)/((double)HOM_PEAK_RATE);
}
// dip_thre_max = (double)(dip_thre_max) - (((double)(dip_thre_max)*0.5)/asm_opt.polyploidy);
dip_thre_max = (double)(dip_thre_max) - ((double)(dip_thre_max)/asm_opt.polyploidy);
for (i = 0; i < ug->g->n_seq; i++) {
bub->index[i] = get_unitig_het_fly(ug, i, sg, dip_thre_max, sources, ruIndex,
r_het_flag, 20, M_het(*bub), P_het(*bub), (uint32_t)-1);
}
for (i = 0; i < bub->f_bub; i++)
{
get_bubbles(bub, i, &beg, &sink, &a, &n, &pathLen);
for (v = n_occ = 0; v < n; v++)
{
bub->index[(a[v]>>1)] = i;
n_occ += ug->u.a[a[v]>>1].n;
}
// if((pathLen*2) >= ug->g->seq[beg>>1].len && (pathLen*2) >= ug->g->seq[sink>>1].len)
// {
// bub->index[(beg>>1)] = (uint32_t)-1;
// bub->index[(sink>>1)] = (uint32_t)-1;
// }
if(n_occ > 3)
{
if(bub->index[(beg>>1)] != M_het(*bub)) bub->index[(beg>>1)] = (uint32_t)-1;
if(bub->index[(sink>>1)] != M_het(*bub)) bub->index[(sink>>1)] = (uint32_t)-1;
}
v = beg>>1;
if(bub->b_s_idx.a[v] == (uint64_t)-1)
{
bub->b_s_idx.a[v] <<= 32;
bub->b_s_idx.a[v] |= i;
}
else if((bub->b_s_idx.a[v] & 0xffffffff00000000) == 0xffffffff00000000)
{
bub->b_s_idx.a[v] <<= 32;
bub->b_s_idx.a[v] |= i;
}
v = sink>>1;
if(bub->b_s_idx.a[v] == (uint64_t)-1)
{
bub->b_s_idx.a[v] <<= 32;
bub->b_s_idx.a[v] |= i;
}
else if((bub->b_s_idx.a[v] & 0xffffffff00000000) == 0xffffffff00000000)
{
bub->b_s_idx.a[v] <<= 32;
bub->b_s_idx.a[v] |= i;
}
}
for (i = 0; i < ug->g->n_seq; i++)
{
if(bub->index[i] == M_het(*bub)) bub->index[i] = P_het(*bub);
}
}
else
{
bub->num.n = bub->f_bub + 1;
bub->pathLen.n = bub->f_bub;
bub->list.n = bub->num.a[bub->num.n-1];
update_bub_b_s_idx(bub);
bub->check_het = 0;
asg_destroy(bub->b_g); bub->b_g = NULL;
ma_ug_destroy(bub->b_ug); bub->b_ug = NULL;
kv_destroy(bub->chain_weight); kv_init(bub->chain_weight);
}
bub->b_g = NULL;
bub->b_ug = NULL;
build_bub_graph(ug, bub);
// fprintf(stderr, "-bub->index[18759]: %u, bub->num.n: %u\n", (uint32_t)bub->index[18759], bub->num.n);
}
void print_bubbles(ma_ug_t* ug, bubble_type* bub, kvec_pe_hit* hits, hc_links* link, ha_ug_index* idx)
{
uint64_t tLen, t_utg, i, k;
hic.h
+2
View File
@@ -90,6 +90,8 @@ int load_hc_links(hc_links* link, const char *fn);
void write_hc_links(hc_links* link, const char *fn);
void destory_bubbles(bubble_type* bub);
void identify_bubbles(ma_ug_t* ug, bubble_type* bub, uint8_t *r_het_flag, kv_u_trans_t *ref);
void identify_bubbles_recal(asg_t* sg, ma_ug_t* ug, bubble_type* bub, uint8_t *r_het_flag, ma_hit_t_alloc* sources, R_to_U* ruIndex,
kv_u_trans_t *ref);
void resolve_bubble_chain_tangle(ma_ug_t* ug, bubble_type* bub);
uint32_t connect_bub_occ(bubble_type* bub, uint32_t root_id, uint32_t check_het);
void get_bub_id(bubble_type* bub, uint32_t root, uint64_t* id0, uint64_t* id1, uint32_t check_het);
inter.cpp
+102 -26
View File
@@ -4839,8 +4839,8 @@ void update_ul_vec_t_ug(const ul_idx_t *uref, ul_vec_t *rch, vec_mg_lchain_t *uc
z->qs = a[m].qs; z->qe = a[m].qe;
z->te = a[m].re; z->ts = a[m].rs;
z->pidx = k + 1 + m; z->pdis = z->aidx = (uint32_t)-1;
// fprintf(stderr, "[M::%s::k->%ld] m->%ld, utg%.6dl(%c)\n",
// __func__, k, m, (int32_t)z->hid+1, "+-"[z->rev]);
// fprintf(stderr, "[M::%s::k->%ld] m->%ld, utg%.6dl(%c), q::[%u, %u), t::[%u, %u)\n",
// __func__, k, m, (int32_t)z->hid+1, "+-"[z->rev], z->qs, z->qe, z->ts, z->te);
}
}
@@ -5058,7 +5058,7 @@ int64_t debug_i, int64_t tid, void *km)
}
// #define aln_sc(a, w) (((int64_t)((a).sec))-((int64_t)(((a).qe-(a).qs-(a).sec)*(w))))
#define aln_sc(a, w) (((int64_t)((a).align_length))-((int64_t)(((a).overlapLen-(a).align_length)*(w)))-(((int64_t)((a).non_homopolymer_errors))*UG_TRANS_ERR_W))
#define aln_sc(a, trans_w, err_w) (((int64_t)((a).align_length))-((int64_t)(((a).overlapLen-(a).align_length)*(trans_w)))-(((int64_t)((a).non_homopolymer_errors))*(err_w)))
void gen_gl_aln(overlap_region_alloc* olist, const ul_idx_t *uref, kv_ul_ov_t *res)
{
@@ -5090,7 +5090,7 @@ void gen_gg_aln(overlap_region_alloc* olist, const ul_idx_t *uref, int64_t trans
for (k = 0; k < olist->length; k++) {
p = &(res->a[res->n++]); memset(p, 0, sizeof((*p)));
p->v = ((olist->list[k].y_id<<1)|(olist->list[k].y_pos_strand)); p->off = k;
p->score = aln_sc((olist->list[k]), (trans_sc));
p->score = aln_sc((olist->list[k]), (trans_sc), UG_TRANS_ERR_W);
p->qs = olist->list[k].x_pos_s; p->qe = olist->list[k].x_pos_e+1;
if((p->v&1)) {
p->rs = uref->ug->u.a[p->v>>1].len - (olist->list[k].y_pos_e+1);
@@ -5177,16 +5177,69 @@ int64_t get_overlap_region_sub_err(overlap_region *o, rtrace_iter *it, int64_t q
return it->werr;
}
int64_t cal_gl_chain_lin_sc(ul_ov_t *li, ul_ov_t *lj, rtrace_iter *tc, overlap_region *ol, All_reads *ridx, ma_ug_t *ug,
const ul_idx_t *uref, const ug_opt_t *uopt, int64_t bw, double diff_ec_ul, uint64_t mode, int64_t trans_sc, int64_t sec_sec)
int64_t get_ecov_el(const ul_idx_t *uref, const ug_opt_t *uopt, uint32_t v, uint32_t w, int64_t bw, double diff_ec_ul, int64_t dq, uint64_t mode, int64_t *el)
{
int64_t dt = -1, dif, mm; (*el) = 0;
uint32_t nv, i; asg_arc_t *av = NULL; ///ma_hit_t *x = NULL;
if(!mode) {
const asg_t *g = uref?uref->ug->g:NULL;
nv = asg_arc_n(g, v); av = asg_arc_a(g, v);
for (i = 0; i < nv; i++) {
if(av[i].del || av[i].v != w) continue;
dt = av[i].ol; (*el) = av[i].el;
// if(v==1772 && w==1769) fprintf(stderr, "+++v:%u, w:%u, ou:%u\n", v, w, av[i].ou);
// if((v>>1) == 3012 && (w>>1) == 3011) fprintf(stderr, "******************\n");
break;
}
}else {
ma_hit_t_alloc* src = uopt->sources;
int64_t min_ovlp = uopt->min_ovlp;
int64_t max_hang = uopt->max_hang;
uint64_t z, qn, tn, x = v>>1; int32_t r = 1; asg_arc_t e;
for (z = 0; z < src[x].length; z++) {
qn = Get_qn(src[x].buffer[z]); tn = Get_tn(src[x].buffer[z]);
if(tn != (w>>1)) continue;
r = ma_hit2arc(&(src[x].buffer[z]), Get_READ_LENGTH(R_INF, qn), Get_READ_LENGTH(R_INF, tn), max_hang, asm_opt.max_hang_rate, min_ovlp, &e);
if(r < 0) continue;
if((e.ul>>32) != v || e.v != w) continue;
dt = e.ol; (*el) = src[x].buffer[z].el;
break;
}
}
if(dt < 0) return 0;
dif = (dq>dt? dq-dt:dt-dq);
mm = MAX(dq, dt); mm *= diff_ec_ul; if(mm < bw) mm = bw;
// if((v>>1) == 1163 && (w>>1) == 1168) fprintf(stderr, ">>>>>>dis_q:%ld, dis_t:%ld, dif:%ld, mm:%ld\n", dis_q, dis_t, dif, mm);
if(dif <= mm) return 1;
return 0;
}
//ai > aj
int64_t cal_gl_chain_lin_sc(ul_ov_t *a, int32_t ai, int32_t aj, rtrace_iter *tc, overlap_region *ol, All_reads *ridx, ma_ug_t *ug,
const ul_idx_t *uref, const ug_opt_t *uopt, int64_t bw, double diff_ec_ul, uint64_t mode, int64_t trans_sc, int64_t sec_sec,
int32_t *f)
{
ul_ov_t *li = &(a[ai]), *lj = &(a[aj]);
///li is the suffix of lj
if(lj->qs >= li->qs) return INT32_MIN;
uint32_t li_v = (li->tn<<1)|li->rev, lj_v = (lj->tn<<1)|lj->rev;
int64_t qo = infer_rovlp(li, lj, NULL, NULL, ridx, ug), trans_l = 0, sec_err = 0, sc; ///overlap length in query (UL read)
if(/**li_v != lj_v &&**/ get_ecov_adv(uref, uopt, li_v^1, lj_v^1, bw, diff_ec_ul, qo, mode, NULL)) {
int64_t qo = infer_rovlp(li, lj, NULL, NULL, ridx, ug), trans_l = 0, sec_err = 0, sc, sc0, el; ///overlap length in query (UL read)
///li_v == lj_v is possiable
if(get_ecov_el(uref, uopt, li_v^1, lj_v^1, bw, diff_ec_ul, qo, mode, &el)) {
trans_l = get_overlap_region_sub_err(&(ol[li->qn]), tc, lj->qe, &sec_err);
sc = f[aj] + ((int64_t)(li->qe - lj->qe)) - (trans_l*trans_sc) - (sec_err*sec_sec);
// fprintf(stderr, "+[M::utg%.6dl] utg%.6dl, liq::[%u, %u), ljq::[%u, %u), trans_l::%ld, sec_err::%ld, sc::%ld, f[aj]::%d\n",
// (int32_t)li->tn+1, (int32_t)lj->tn+1, li->qs, li->qe, lj->qs, lj->qe, trans_l, sec_err, sc, f[aj]);
if((el == 0) && ((trans_l > 0) || (sec_err > 0)) && (lj->qe > li->qs)) {
rtrace_iter tr; tr.k = INT32_MAX; sc0 = sc;
sc = f[aj] + aln_sc(ol[(*li).qn], trans_sc, sec_sec);
trans_l = get_overlap_region_sub_err(&(ol[lj->qn]), &tr, li->qs, &sec_err);
sc -= (((int64_t)(lj->qe - li->qs)) - (trans_l*trans_sc) - (sec_err*sec_sec));
if(sc < sc0) sc = sc0;
// fprintf(stderr, "-[M::utg%.6dl] utg%.6dl, liq::[%u, %u), ljq::[%u, %u), trans_l::%ld, sec_err::%ld, sc::%ld, f[aj]::%d, aln_sc::%ld\n",
// (int32_t)li->tn+1, (int32_t)lj->tn+1, li->qs, li->qe, lj->qs, lj->qe, trans_l, sec_err, sc, f[aj], aln_sc(ol[(*li).qn], trans_sc, sec_sec));
}
// int64_t trans_l_debug, sec_err_debug;
// trans_l_debug = get_overlap_region_sub_err_debug(&(ol[li->qn]), lj->qe, &sec_err_debug);
// if(!(trans_l_debug == trans_l && sec_err_debug == sec_err)) {
@@ -5194,8 +5247,6 @@ const ul_idx_t *uref, const ug_opt_t *uopt, int64_t bw, double diff_ec_ul, uint6
// __func__, lj->qe, trans_l, trans_l_debug, sec_err, sec_err_debug);
// }
// assert(trans_l_debug == trans_l && sec_err_debug == sec_err);
sc = (li->qe - lj->qe) - (trans_l*trans_sc) - (sec_err*sec_sec);
// if(li->tn == 308 || li->tn == 311 || lj->tn == 305 || lj->tn == 304) {
// fprintf(stderr, "[M::%s::utg%.6dl] utg%.6dl, liq::[%u, %u), ljq::[%u, %u), trans_l::%ld, sec_err::%ld, sc::%ld\n", __func__,
// (int32_t)li->tn+1, (int32_t)lj->tn+1, li->qs, li->qe, lj->qs, lj->qe, trans_l, sec_err, sc);
@@ -5235,16 +5286,19 @@ uint64_t mode, All_reads *ridx, ma_ug_t *ug, int64_t need_srt)
x += li->qs + mm_ovlp;
if (x > qlen+1) x = qlen+1;
x = find_ul_ov_max(i, res->a, x+G_CHAIN_INDEL);
csc = aln_sc(ol[(*li).qn], trans_sc);
csc = aln_sc(ol[(*li).qn], trans_sc, UG_TRANS_ERR_W);
// fprintf(stderr, "[M::%s::utg%.6dl] i::%ld, csc::%ld, q::[%u, %u), aln::%u, ol::%u, sec_e::%u\n",
// __func__, (int32_t)li->tn+1, i, csc, li->qs, li->qe,
// (ol[(*li).qn]).align_length, (ol[(*li).qn]).overlapLen,
// (ol[(*li).qn]).non_homopolymer_errors);
mm_sc = csc; mm_idx = -1;
n_skip = 0; end_j = -1; tc.k = INT32_MAX;
if ((x-st) > max_iter) st = x-max_iter;
for (j = x; j >= st; --j) { // collect potential destination vertices
lj = &(res->a[j]);
if(lj->qe+G_CHAIN_INDEL <= li->qs) break;//even this pair has a overlap, its length will be very small; just ignore
sc = cal_gl_chain_lin_sc(li, lj, &tc, ol, ridx, ug, uref, uopt, bw, diff_ec_ul, mode, trans_sc, UG_TRANS_ERR_W);
sc = cal_gl_chain_lin_sc(res->a, i, j, &tc, ol, ridx, ug, uref, uopt, bw, diff_ec_ul, mode, trans_sc, UG_TRANS_ERR_W, f);
if(sc == INT32_MIN) continue;
sc += f[j];
if(sc > mm_sc) {
mm_sc = sc, mm_idx = j;
if (n_skip > 0) --n_skip;
@@ -5268,9 +5322,8 @@ uint64_t mode, All_reads *ridx, ma_ug_t *ug, int64_t need_srt)
if (max_ii >= 0 && max_ii < end_j) {///just have a try with a[i]<->a[max_ii]
lj = &(res->a[max_ii]);
if(lj->qe+G_CHAIN_INDEL > li->qs && lj->qs < li->qs) {
sc = cal_gl_chain_lin_sc(li, lj, &tc, ol, ridx, ug, uref, uopt, bw, diff_ec_ul, mode, trans_sc, UG_TRANS_ERR_W);
sc = cal_gl_chain_lin_sc(res->a, i, max_ii, &tc, ol, ridx, ug, uref, uopt, bw, diff_ec_ul, mode, trans_sc, UG_TRANS_ERR_W, f);
if(sc != INT32_MIN) {
sc += f[max_ii];
if(sc > mm_sc) {
mm_sc = sc; mm_idx = max_ii;
}
@@ -5747,11 +5800,12 @@ st_mt_t *bf, Chain_Data* dp, int64_t max_skip, int64_t max_iter, int64_t max_dis
inline int32_t cal_gchain_sc_adv(overlap_region *ol, const mg_path_dst_t *dj, const mg_lchain_t *li, const mg_lchain_t *lc, int64_t *f, int64_t b_w, float diff_thre, float chn_pen_gap,
rtrace_iter *tc, int64_t trans_sc, int64_t sec_sec)
inline int32_t cal_gchain_sc_adv(const ma_ug_t *ug, const ul_idx_t *uref, const ug_opt_t *uopt,
overlap_region *ol, const mg_path_dst_t *dj, const mg_lchain_t *li, ul_ov_t *ui, mg_lchain_t *lc, int64_t *f,
int64_t b_w, float diff_thre, float chn_pen_gap, rtrace_iter *tc, int64_t trans_sc, int64_t sec_sec)
{
// const mg_lchain_t *lj;
int32_t gap, sc;
int32_t gap;
float lin_pen, log_pen;
if (dj->n_path == 0) return INT32_MIN;
gap = dj->dist - dj->target_dist;
@@ -5760,8 +5814,23 @@ rtrace_iter *tc, int64_t trans_sc, int64_t sec_sec)
if ((gap > ((dj->target_dist)*diff_thre)) && (gap > b_w)) return INT32_MIN;
// if (lj->qe <= li->qs) sc = li->score;
// else sc = (int32_t)((double)(li->qe - lj->qe) / (li->qe - li->qs) * li->score + .499); // dealing with overlap on query
int64_t trans_l = 0, sec_err = 0;
trans_l = get_overlap_region_sub_err(&(ol[li->off]), tc, lc[dj->meta].qe, &sec_err);
int64_t trans_l = 0, sec_err = 0, qo, el = 0, sc, sc0;
mg_lchain_t *lj = &(lc[dj->meta]); ul_ov_t uj;
trans_l = get_overlap_region_sub_err(&(ol[li->off]), tc, lj->qe, &sec_err);
sc = (li->qe - lj->qe) - (trans_l*trans_sc) - (sec_err*sec_sec); sc += f[dj->meta];
if(((trans_l > 0) || (sec_err > 0)) && (lj->qe > li->qs)) {
set_ul_ov_t_by_mg_lchain_t(&uj, lj);
qo = infer_rovlp(ui, &uj, NULL, NULL, NULL, (ma_ug_t *)ug);
if((!get_ecov_el(uref, uopt, li->v^1, lj->v^1, b_w, N_GCHAIN_RATE, qo, 0, &el)) || (el == 0)) {
rtrace_iter tr; tr.k = INT32_MAX; sc0 = sc;
sc = f[dj->meta] + li->score;
trans_l = get_overlap_region_sub_err(&(ol[lj->off]), &tr, li->qs, &sec_err);
sc -= (((int64_t)(lj->qe - li->qs)) - (trans_l*trans_sc) - (sec_err*sec_sec));
if(sc < sc0) sc = sc0;
}
}
// int64_t trans_l_debug, sec_err_debug;
// trans_l_debug = get_overlap_region_sub_err_debug(&(ol[li->off]), lc[dj->meta].qe, &sec_err_debug);
@@ -5771,14 +5840,13 @@ rtrace_iter *tc, int64_t trans_sc, int64_t sec_sec)
// }
// assert(trans_l_debug == trans_l && sec_err_debug == sec_err);
sc = (li->qe - lc[dj->meta].qe) - (trans_l*trans_sc) - (sec_err*sec_sec);
// sc = li->score;
//sc += dj->mlen; // TODO: is this line the right thing to do?
// if (dj->is_0) sc += ref_bonus;
lin_pen = chn_pen_gap * (float)gap;
log_pen = gap >= 2? mg_log2(gap) : 0.0f;
sc -= (int32_t)(lin_pen + log_pen);
sc += f[dj->meta];
return sc;
}
@@ -5900,7 +5968,7 @@ int64_t need_srt)
for (j = 0; j < dst_n; ++j) {
dj = &dst->a[j];
if (dj->n_path == 0) continue; // unreachable
sc = cal_gchain_sc_adv(ol, dj, li, lc->a, f, bw, diff_thre, W_CHN_PEN_GAP, &tc, trans_sc, sec_sec);
sc = cal_gchain_sc_adv(ug, uref, uopt, ol, dj, li, &ui, lc->a, f, bw, diff_thre, W_CHN_PEN_GAP, &tc, trans_sc, sec_sec);
if (sc == INT32_MIN) continue; // out of band
// if (sc < 0) continue;// negative score
@@ -8811,11 +8879,19 @@ static void worker_for_ul_rescall_alignment(void *data, long i, int tid) // call
// void *km = s->buf?(s->buf[tid]?s->buf[tid]->km:NULL):NULL;
// if(s->id+i!=3046/** && s->id+i!=3111**/) return;
// if((s->id+i!=871) && (s->id+i!=963) && (s->id+i!=980)) return;
// if(s->id+i!=963) return;
// if(s->id+i!=944) return;
// if(s->id+i != 35437) return;
// if((s->id+i != 7086) && (s->id+i != 51705) && (s->id+i != 266022) && (s->id+i != 353608)
// && (s->id+i != 399416) && (s->id+i != 403014) && (s->id+i != 420915) && (s->id+i != 603855)
// && (s->id+i != 680134) && (s->id+i != 766261) && (s->id+i != 794527)) {
// return;
// }
// fprintf(stderr, "\n[M::%s] rid::%ld, len::%lu, name::%.*s\n", __func__, s->id+i, s->len[i],
// (int32_t)UL_INF.nid.a[s->id+i].n, UL_INF.nid.a[s->id+i].a);
// fprintf(stderr, ">%.*s\n%.*s\n", (int32_t)UL_INF.nid.a[s->id+i].n, UL_INF.nid.a[s->id+i].a,
// (int32_t)s->len[i], s->seq[i]);
// if (memcmp(UL_INF.nid.a[s->id+i].a, "d0aab024-b3a7-40fb-83cc-22c3d6d951f8", UL_INF.nid.a[s->id+i].n-1)) return;
// fprintf(stderr, "[M::%s::] ==> len: %lu\n", __func__, s->len[i]);
// ha_get_ul_candidates_interface(b->abl, i, s->seq[i], s->len[i], s->opt->w, s->opt->k, s->uu, &b->olist, &b->olist_hp, &b->clist, s->opt->bw_thres,
@@ -14690,7 +14766,7 @@ ma_ug_t *ul_realignment(const ug_opt_t *uopt, asg_t *sg, uint32_t double_check_c
///for debug interval
if(!load_all_ul_t(&UL_INF, gfa_name, &R_INF, ug)) {
gen_UL_reovlps(&sl, ug, sg, gfa_name, cutoff);
exit(1);
// exit(1);
write_all_ul_t(&UL_INF, gfa_name, ug);
} else if(double_check_cache){
if(drenew_UL_reovlps(&sl, ug, sg, gfa_name, cutoff)) {
inter.h
+3 -1
View File
@@ -17,8 +17,10 @@
#define UG_SKIP_N 100
#define UG_ITER_N 5000
#define UG_DIS_N 50000
// #define UG_TRANS_W 2
#define UG_TRANS_W 2
#define UG_TRANS_ERR_W 512
// #define UG_TRANS_ERR_W 512
#define UG_TRANS_ERR_W 64
#define G_CHAIN_TRANS_RATE 0.25
#define G_CHAIN_TRANS_WEIGHT -1
#define G_CHAIN_INDEL 128