xxay/hifiasm
1
0
Fork 0
mirror of https://github.com/chhylp123/hifiasm.git synced 2026-09-15 12:47:57 +08:00
Code Issues Packages Projects Releases Wiki Activity

extend ed alignment

Browse Source
This commit is contained in:
chhylp123
2022-09-13 17:29:27 -04:00
parent ee51a6dddc
commit 5da05f308f
11 changed files with 2348 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
CommandLines.cpp
View File

@@ -234,6 +234,7 @@ void init_opt(hifiasm_opt_t* asm_opt)
asm_opt->s_hap_cov = 3;
asm_opt->ul_error_rate = 0.2/**0.15**/;
asm_opt->ul_error_rate_low = 0.1;
asm_opt->ul_error_rate_hpc = 0.2;
asm_opt->ul_ec_round = 3;
asm_opt->is_dbg_het_cnt = 0;
}

2
CommandLines.h
View File

@@ -122,7 +122,7 @@ typedef struct {
int64_t hg_size;
float kpt_rate;
int64_t infor_cov, s_hap_cov;
double ul_error_rate, ul_error_rate_low;
double ul_error_rate, ul_error_rate_low, ul_error_rate_hpc;
int32_t ul_ec_round;
uint8_t is_dbg_het_cnt;
} hifiasm_opt_t;

1089
Correct.cpp
View File

File diff suppressed because it is too large Load Diff

5
Correct.h
View File

@@ -1130,6 +1130,10 @@ void correct_ul_overlap(overlap_region_alloc* overlap_list, const ul_idx_t *uref
kvec_t_u64_warp* v_idx, window_list_alloc* win_ciagr_buf,
int force_repeat, int is_consensus, int* fully_cov, int* abnormal,
double max_ov_diff_ec, long long winLen, void *km);
void ul_lalign(overlap_region_alloc* ol, Candidates_list *cl, const ul_idx_t *uref, char *qstr,
uint64_t ql, UC_Read* qu, UC_Read* tu, Correct_dumy* dumy,
haplotype_evdience_alloc* hap, kvec_t_u64_warp* v_idx,
double e_rate, int64_t wl, uint64_t is_base, void *km);
void lchain_align(overlap_region_alloc* overlap_list, const ul_idx_t *uref,
UC_Read* g_read, Correct_dumy* dumy, UC_Read* overlap_read,
@@ -1267,6 +1271,7 @@ inline void push_cigar_cell(window_list_alloc *res, uint8_t c, uint32_t len)
uint16_t p = c; p <<= 14; p += (uint16_t)len;
kv_push(uint16_t, res->c, p);
}
int64_t get_num_wins(int64_t s, int64_t e, int64_t block_s);
#define FORWARD_KSW 0
#define BACKWARD_KSW 1

4
Hash_Table.cpp
View File

@@ -1441,7 +1441,7 @@ uint64_t lchain_dp_fciagr(k_mer_hit* a, int64_t a_n, k_mer_hit* des, Chain_Data*
if (max_ii < 0 || ((int64_t)a[i].offset) - ((int64_t)a[max_ii].offset) > max_dis) {
max = INT32_MIN; max_ii = -1;
for (j = i - 1; j >= st; --j) {
for (j = i - 1; (j >= st) && ((((int64_t)a[i].offset)-((int64_t)a[j].offset))<=max_dis); --j) {
if (max < f[j]) {
max = f[j], max_ii = j;
}
@@ -1581,7 +1581,7 @@ uint64_t lchain_dp(k_mer_hit* a, int64_t a_n, k_mer_hit* des, Chain_Data* dp, ov
if (max_ii < 0 || ((int64_t)a[i].offset) - ((int64_t)a[max_ii].offset) > max_dis) {
max = INT32_MIN; max_ii = -1;
for (j = i - 1; j >= st; --j) {
for (j = i - 1; (j >= st) && ((((int64_t)a[i].offset)-((int64_t)a[j].offset))<=max_dis); --j) {
if (max < f[j]) {
max = f[j], max_ii = j;
}

1
Hash_Table.h
View File

@@ -12,6 +12,7 @@
#define WINDOW_UNCORRECT_SINGLE_SIDE_BOUNDARY 25
#define THRESHOLD 15
#define OVERLAP_THRESHOLD_FILTER 0.9
#define OVERLAP_THRESHOLD_FILTER_HPC 0.75
#define HIGH_HET_OVERLAP_THRESHOLD_FILTER 0.3
#define HIGH_HET_ERROR_RATE 0.08
#define THRESHOLD_MAX_SIZE 31

913
Levenshtein_distance.h
View File

@@ -8,9 +8,12 @@
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include "kvec.h"
extern const unsigned char seq_nt4_table[256];
typedef uint64_t Word;
typedef uint32_t Word_32;
typedef struct {size_t n, m; uint16_t *a; } asg16_v;
inline void get_error(int t_length, int errthold, int init_err, Word VP, Word VN,
unsigned int* return_err, int* back_site)
@@ -208,6 +211,151 @@ unsigned int* return_err, int* return_p_end, int* return_t_end)
return (*return_t_end);
}
inline int Reserve_Banded_BPM_Extension_REV
(char *pattern, int p_length, char *text, int t_length, unsigned short errthold,
unsigned int* return_err, int* return_p_end, int* return_t_end)
{
(*return_err) = (unsigned int)-1;
(*return_p_end) = -1;
(*return_t_end) = -1;
Word Peq[256];
unsigned int line_error = (unsigned int)-1;
int return_site;
int band_length = (errthold << 1) + 1;
int i = 0;
Word tmp_Peq_1 = (Word)1;
Peq[(uint8_t)'A'] = (Word)0;
Peq[(uint8_t)'T'] = (Word)0;
Peq[(uint8_t)'G'] = (Word)0;
Peq[(uint8_t)'C'] = (Word)0;
Word Peq_A;
Word Peq_T;
Word Peq_C;
Word Peq_G;
///band_length = 2k + 1
for (i = 0; i<band_length; i++)
{
Peq[(uint8_t)pattern[p_length-i-1]] = Peq[(uint8_t)pattern[p_length-i-1]] | tmp_Peq_1;
tmp_Peq_1 = tmp_Peq_1 << 1;
}
Peq_A = Peq[(uint8_t)'A'];
Peq_C = Peq[(uint8_t)'C'];
Peq_T = Peq[(uint8_t)'T'];
Peq_G = Peq[(uint8_t)'G'];
memset(Peq, 0, sizeof(Word)* 256);
Peq[(uint8_t)'A'] = Peq_A;
Peq[(uint8_t)'C'] = Peq_C;
Peq[(uint8_t)'T'] = Peq_T;
Peq[(uint8_t)'G'] = Peq_G;
Word Mask = ((Word)1 << (errthold << 1));
Word VP = 0;
Word VN = 0;
Word X = 0;
Word D0 = 0;
Word HN = 0;
Word HP = 0;
i = 0;
int err = 0;
Word err_mask = (Word)1;
int i_bd = (errthold << 1);
int last_high = (errthold << 1);
int t_length_1 = t_length - 1;
while (i<t_length_1)
{
X = Peq[(uint8_t)text[t_length-i-1]] | VN;
D0 = ((VP + (X&VP)) ^ VP) | X;
HN = VP&D0;
HP = VN | ~(VP | D0);
X = D0 >> 1;
VN = X&HP;
VP = HN | ~(X | HP);
if (!(D0&err_mask))
{
++err;
if ((err - last_high)>errthold)
{
return (*return_t_end);
}
}
get_error(i + 1, errthold, err, VP, VN, &line_error, &return_site);
if(line_error != (unsigned int)-1)
{
(*return_t_end) = t_length-i-1;
(*return_p_end) = p_length-return_site-1;
(*return_err) = line_error;
}
Peq[(uint8_t)'A'] = Peq[(uint8_t)'A'] >> 1;
Peq[(uint8_t)'C'] = Peq[(uint8_t)'C'] >> 1;
Peq[(uint8_t)'G'] = Peq[(uint8_t)'G'] >> 1;
Peq[(uint8_t)'T'] = Peq[(uint8_t)'T'] >> 1;
++i;
++i_bd;
Peq[(uint8_t)pattern[p_length-i_bd-1]] = Peq[(uint8_t)pattern[p_length-i_bd-1]] | Mask;
}
X = Peq[(uint8_t)text[t_length-i-1]] | VN;
D0 = ((VP + (X&VP)) ^ VP) | X;
HN = VP&D0;
HP = VN | ~(VP | D0);
X = D0 >> 1;
VN = X&HP;
VP = HN | ~(X | HP);
if (!(D0&err_mask))
{
++err;
if ((err - last_high)>errthold)
{
return (*return_t_end);
}
}
///i = t_length - 1
get_error(i + 1, errthold, err, VP, VN, &line_error, &return_site);
if(line_error != (unsigned int)-1)
{
(*return_t_end) = t_length-i-1;
(*return_p_end) = p_length-return_site-1;
(*return_err) = line_error;
}
return (*return_t_end);
}
inline void reverse_string(char* str, int strLen)
{
int i, Len;
@@ -267,7 +415,494 @@ int* return_t_end, int* return_aligned_t_len)
}
}
///p_length might be samller than t_length + 2 * errthold
/// pattern is longer than text
inline int32_t ed_band_cal_semi(char *pstr, int32_t pn, char *tstr, int32_t tn, int32_t thre, int32_t *re_err)
{
(*re_err) = INT32_MAX;
Word Peq[5] = {0}, mm = (Word)1, VP = 0, VN = 0, X = 0, D0 = 0, HN = 0, HP = 0;
int32_t bd = (thre<<1)+1, i, err = 0, i_bd = (thre<<1), last_high = (thre<<1), tn0 = tn - 1;
int32_t cut = thre+last_high;
for (i = 0; i < bd; i++) {
Peq[seq_nt4_table[(uint8_t)pstr[i]]] |= mm; mm <<= 1;
}
///should make Peq[4] = 0 if N is always an error
Peq[4] = 0;
i = 0; mm = ((Word)1 << (thre<<1));///for the incoming char/last char
while (i < tn0) {
X = Peq[seq_nt4_table[(uint8_t)tstr[i]]] | VN;
D0 = ((VP + (X&VP)) ^ VP) | X;
HN = VP&D0;
HP = VN | ~(VP | D0);
X = D0 >> 1;
VN = X&HP;
VP = HN | ~(X | HP);
if (!(D0&(1ULL))) {
++err;
if (err>cut) return -1;
}
Peq[0] >>= 1; Peq[1] >>= 1; Peq[2] >>= 1; Peq[3] >>= 1; ///Peq[4] >>= 1;
++i; ++i_bd;
Peq[seq_nt4_table[(uint8_t)pstr[i_bd]]] |= mm; Peq[4] = 0;
}
X = Peq[seq_nt4_table[(uint8_t)tstr[i]]] | VN;
D0 = ((VP + (X&VP)) ^ VP) | X;
HN = VP&D0;
HP = VN | ~(VP | D0);
X = D0 >> 1;
VN = X&HP;
VP = HN | ~(X | HP);
if (!(D0&(1ULL))) {
++err;
if (err>cut) return -1;
}
int32_t site = tn - 1, end = -1;///up bound
///in most cases, ai = (thre<<1)
int32_t ai = pn - tn, uge = INT32_MAX;
if ((err <= thre) && (err<=(*re_err))) {
*re_err = err; end = site;
}
i = 0;
while (i < ai) {
err += ((VP >> i)&(1ULL)); err -= ((VN >> i)&(1ULL)); ++i;
if ((err <= thre) && (err <= (*re_err))) {
*re_err = err; end = site + i;
}
if(i == thre) uge = err;
}
if((uge<=thre) && (uge == (*re_err))) end = site + thre;
return end;
}
inline void print_bit(Word z, int64_t w, const char *cmd)
{
int64_t k;//, w = (sizeof(Word)<<3);
fprintf(stderr, "%s\t", cmd);
for (k = 0; k < w; k++) fprintf(stderr, "%llu", (z>>k)&(1ULL));
fprintf(stderr, "\n");
}
inline void print_bits(Word *az, int64_t w, const char *cmd)
{
int64_t k, m, s = (sizeof(*az)<<3), sw = (w/s) + (!!(w%s)), ks;
fprintf(stderr, "%s\t", cmd);
for (m = k = 0; m < sw && k < w; m++) {
for (ks = 0; ks < s && k < w; ks++, k++) fprintf(stderr, "%llu", (az[m]>>ks)&(1ULL));
}
fprintf(stderr, "\n");
}
inline int32_t ed_band_cal_global(char *pstr, int32_t pn, char *tstr, int32_t tn, int32_t thre)
{
if((pn > tn + thre) || (tn > pn + thre)) return INT32_MAX;
if((pn < thre + 1) || (tn < thre + 1)) return INT32_MAX;
Word Peq[5] = {0}, mm, VP = 0, VN = 0, X = 0, D0 = 0, HN = 0, HP = 0;
int32_t i, err, tn0 = tn - 1, cut = thre+(thre<<1), bd = thre+1, i_bd = thre;
// fprintf(stderr, "\n[M::%s::]\n", __func__);
for (i = 0, mm = (((Word)1)<<thre); i < bd; i++) {
Peq[seq_nt4_table[(uint8_t)pstr[i]]] |= mm; mm <<= 1;
}
Peq[4] = 0;
err = thre;
VN = (((Word)1)<<(thre))-1;
VP = (((Word)1)<<((thre<<1)+1))-1; VP ^= VN;
// print_bit(Peq[0], (thre<<1)+1, "Peq[A]");
// print_bit(Peq[1], (thre<<1)+1, "Peq[C]");
// print_bit(Peq[2], (thre<<1)+1, "Peq[G]");
// print_bit(Peq[3], (thre<<1)+1, "Peq[T]");
// print_bit(Peq[4], (thre<<1)+1);
// print_bit(VN, (thre<<1)+1, "VN");
// print_bit(VP, (thre<<1)+1, "VP");
///should make Peq[4] = 0 if N is always an error
i = 0; mm = ((Word)1 << (thre<<1));///for the incoming char/last char
while (i < tn0) {
X = Peq[seq_nt4_table[(uint8_t)tstr[i]]] | VN;
D0 = ((VP + (X&VP)) ^ VP) | X;
HN = VP&D0;
HP = VN | ~(VP | D0);
X = D0 >> 1;
VN = X&HP;
VP = HN | ~(X | HP);
// fprintf(stderr, "\n[M::%s::i->%d]\n", __func__, i);
// print_bit(VN, (thre<<1)+1, "VN");
// print_bit(VP, (thre<<1)+1, "VP");
// print_bit(HN, (thre<<1)+1, "HN");
// print_bit(HP, (thre<<1)+1, "HP");
// print_bit(D0, (thre<<1)+1, "D0");
if (!(D0&(1ULL))) {
++err;
if (err>cut) return INT32_MAX;
}
// fprintf(stderr, "[M::%s::i->%d] err->%d\n", __func__, i, err);
Peq[0] >>= 1; Peq[1] >>= 1; Peq[2] >>= 1; Peq[3] >>= 1; ///Peq[4] >>= 1;
++i; ++i_bd;
if(i_bd < pn) {
Peq[seq_nt4_table[(uint8_t)pstr[i_bd]]] |= mm; Peq[4] = 0;
}
// if(i < pn) Peq[seq_nt4_table[(uint8_t)pstr[i]]] |= mm;
}
X = Peq[seq_nt4_table[(uint8_t)tstr[i]]] | VN;
D0 = ((VP + (X&VP)) ^ VP) | X;
HN = VP&D0;
HP = VN | ~(VP | D0);
X = D0 >> 1;
VN = X&HP;
VP = HN | ~(X | HP);
// fprintf(stderr, "\n[M::%s::i->%d]\n", __func__, i);
// print_bit(VN, (thre<<1)+1, "VN");
// print_bit(VP, (thre<<1)+1, "VP");
// print_bit(HN, (thre<<1)+1, "HN");
// print_bit(HP, (thre<<1)+1, "HP");
// print_bit(D0, (thre<<1)+1, "D0");
if (!(D0&(1ULL))) {
++err;
if (err>cut) return INT32_MAX;
}
// fprintf(stderr, "[M::%s::i->%d] err->%d\n", __func__, i, err);
int32_t site = tn - 1 - thre;///up bound
for (cut = pn - 1, i = 0; site < cut; site++, i++) {
// fprintf(stderr, "+[M::%s::site->%d] err->%d\n", __func__, site, err);
err += ((VP >> i)&(1ULL)); err -= ((VN >> i)&(1ULL));
// fprintf(stderr, "-[M::%s::site->%d] err->%d\n", __func__, site, err);
}
if (site == cut && err <= thre) return err;
return INT32_MAX;
}
typedef uint64_t w_sig;
typedef struct {w_sig a[2];} w128_t;
#define bitw (6)
#define bitwbit (64)
#define bitz (63)
// typedef uint32_t w_sig;
// typedef struct {w_sig a[2];} w128_t;
// #define bitw (5)
// #define bitwbit (32)
// #define bitz (31)
#define w128_bit(x, b) ((x).a[((b)>>bitw)]|=(((w_sig)1)<<((b)&bitz)))
#define w128_clear(x) ((x).a[0]=(x).a[1]=0)
#define w128_self_not(x) ((x).a[0]=~(x).a[0], \
(x).a[1]=~(x).a[1])
#define w128_self_or(x, y) ((x).a[0]|=(y).a[0], \
(x).a[1]|=(y).a[1])
#define w128_or(r, x, y) ((r).a[0] = (x).a[0]|(y).a[0], \
(r).a[1] = (x).a[1]|(y).a[1])
#define w128_and(r, x, y) ((r).a[0] = (x).a[0]&(y).a[0], \
(r).a[1] = (x).a[1]&(y).a[1])
#define w128_self_xor(x, y) ((x).a[0]^=(y).a[0], \
(x).a[1]^=(y).a[1])
// #define w128_self_lsft_l(x, l) ((x).a[1] = ((x).a[1]<<(l))|((x).a[0]>>(bitwbit-(l))), \
// (x).a[0] <<= (l))
#define w128_self_lsft_1(x) ((x).a[1] = ((x).a[1]<<1)|((x).a[0]>>bitz), \
(x).a[0] <<= 1)
#define w128_self_rsft_1(x) ((x).a[0] = ((x).a[0]>>1)|((x).a[1]<<bitz), \
(x).a[1] >>= 1)
#define w128_self_add(x, y) ((x).a[0]+=(y).a[0], \
(x).a[1]+=(y).a[1]+((x).a[0]<(y).a[0]))
#define w128_set_bit_lsub(x, l) do { \
(x).a[0] = (w_sig)-1, (x).a[1] = 0; \
if((l) <= bitwbit) (x).a[0] = (((w_sig)1)<<(l))-1; \
else (x).a[1] = (((w_sig)1)<<((l)-bitwbit))-1;\
} while (0) \
#define ed_core_w128(RE) { \
/**X = Peq[seq_nt4_table[(uint8_t)tstr[i]]] | VN;**/\
c = seq_nt4_table[(uint8_t)tstr[i]]; w128_or(X, Peq[c], VN);\
/**D0 = ((VP + (X&VP)) ^ VP) | X;**/\
w128_and(D0, X, VP);\
w128_self_add(D0, VP);\
w128_self_xor(D0, VP);\
w128_self_or(D0, X);\
/**HN = VP&D0;**/\
w128_and(HN, VP, D0);\
/**HP = VN | ~(VP | D0);**/\
w128_or(HP, VP, D0);\
w128_self_not(HP);\
w128_self_or(HP, VN);\
/**X = D0 >> 1;**/\
X = D0; w128_self_rsft_1(X);\
/**VN = X&HP;**/\
w128_and(VN, X, HP);\
/**VP = HN | ~(X | HP);**/\
w128_or(VP, X, HP);\
w128_self_not(VP);\
w128_self_or(VP, HN);\
/**if (!(D0&(1ULL)))**/\
if (!(D0.a[0]&(1ULL))) {\
++err;\
if (err>cut) return RE;\
}\
/** Peq[0] >>= 1; Peq[1] >>= 1; Peq[2] >>= 1; Peq[3] >>= 1;**/\
w128_self_rsft_1(Peq[0]); w128_self_rsft_1(Peq[1]);\
w128_self_rsft_1(Peq[2]); w128_self_rsft_1(Peq[3]);\
}
inline int32_t ed_band_cal_global_128bit(char *pstr, int32_t pn, char *tstr, int32_t tn, int32_t thre)
{
if((pn > tn + thre) || (tn > pn + thre)) return INT32_MAX;
if((pn < thre + 1) || (tn < thre + 1)) return INT32_MAX;
w128_t Peq[5], mm, VP, VN, X, D0, HN, HP; uint8_t c;
int32_t i, err, tn0 = tn - 1, cut = thre+(thre<<1), bd = thre+1, i_bd = thre;
w128_clear(Peq[0]); w128_clear(Peq[1]); w128_clear(Peq[2]); w128_clear(Peq[3]); w128_clear(Peq[4]);
w128_clear(mm); w128_bit(mm, thre); ///mm = (((Word)1)<<thre)
for (i = 0; i < bd; i++) {
w128_self_or(Peq[seq_nt4_table[(uint8_t)pstr[i]]], mm); w128_self_lsft_1(mm);
// Peq[seq_nt4_table[(uint8_t)pstr[i]]] |= mm; mm <<= 1;
}
w128_clear(Peq[4]);
err = thre;
w128_set_bit_lsub(VN, thre); ///VN = (((Word)1)<<(thre))-1;
w128_set_bit_lsub(VP, (thre<<1)+1); ///VP = (((Word)1)<<((thre<<1)+1))-1;
w128_self_xor(VP, VN); ///VP ^= VN;
// print_bits(Peq[0].a, (thre<<1)+1, "-Peq[A]");
// print_bits(Peq[1].a, (thre<<1)+1, "-Peq[C]");
// print_bits(Peq[2].a, (thre<<1)+1, "-Peq[G]");
// print_bits(Peq[3].a, (thre<<1)+1, "-Peq[T]");
// print_bits(VN.a, (thre<<1)+1, "-VN");
// print_bits(VP.a, (thre<<1)+1, "-VP");
///should make Peq[4] = 0 if N is always an error
i = 0;
///for the incoming char/last char
w128_clear(mm); w128_bit(mm, (thre<<1)); ///mm = ((Word)1 << (thre<<1));
//VP + ((Peq|VN)&VP)
while (i < tn0) {
///X = Peq[seq_nt4_table[(uint8_t)tstr[i]]] | VN;
c = seq_nt4_table[(uint8_t)tstr[i]]; w128_or(X, Peq[c], VN);
///D0 = ((VP + (X&VP)) ^ VP) | X;
w128_and(D0, X, VP);
w128_self_add(D0, VP);
w128_self_xor(D0, VP);
w128_self_or(D0, X);
// HN = VP&D0;
w128_and(HN, VP, D0);
// HP = VN | ~(VP | D0);
w128_or(HP, VP, D0);
w128_self_not(HP);
w128_self_or(HP, VN);
// X = D0 >> 1;
X = D0; w128_self_rsft_1(X);
// VN = X&HP;
w128_and(VN, X, HP);
// VP = HN | ~(X | HP);
w128_or(VP, X, HP);
w128_self_not(VP);
w128_self_or(VP, HN);
//if (!(D0&(1ULL)))
if (!(D0.a[0]&(1ULL))) {
++err;
if (err>cut) return INT32_MAX;
}
// fprintf(stderr, "[M::%s::i->%d] err->%d\n", __func__, i, err);
// Peq[0] >>= 1; Peq[1] >>= 1; Peq[2] >>= 1; Peq[3] >>= 1;
w128_self_rsft_1(Peq[0]); w128_self_rsft_1(Peq[1]);
w128_self_rsft_1(Peq[2]); w128_self_rsft_1(Peq[3]);
++i; ++i_bd;
if(i_bd < pn) {
c = seq_nt4_table[(uint8_t)pstr[i_bd]];
///if(c < 4) Peq[c] |= mm;
if(c < 4) w128_self_or(Peq[c], mm);
}
}
// X = Peq[seq_nt4_table[(uint8_t)tstr[i]]] | VN;
c = seq_nt4_table[(uint8_t)tstr[i]]; w128_or(X, Peq[c], VN);
// D0 = ((VP + (X&VP)) ^ VP) | X;
w128_and(D0, X, VP);
w128_self_add(D0, VP);
w128_self_xor(D0, VP);
w128_self_or(D0, X);
// HN = VP&D0;
w128_and(HN, VP, D0);
// HP = VN | ~(VP | D0);
w128_or(HP, VP, D0);
w128_self_not(HP);
w128_self_or(HP, VN);
// X = D0 >> 1;
X = D0; w128_self_rsft_1(X);
// VN = X&HP;
w128_and(VN, X, HP);
// VP = HN | ~(X | HP);
w128_or(VP, X, HP);
w128_self_not(VP);
w128_self_or(VP, HN);
// if (!(D0&(1ULL))) {
if (!(D0.a[0]&(1ULL))) {
++err;
if (err>cut) return INT32_MAX;
}
// fprintf(stderr, "[M::%s::i->%d] err->%d\n", __func__, i, err);
int32_t site = tn - 1 - thre;///up bound
for (cut = pn - 1, i = 0; site < cut; site++, i++) {
// err += ((VP >> i)&(1ULL));
err += VP.a[0]&(1ULL); w128_self_rsft_1(VP);
// err -= ((VN >> i)&(1ULL));
err -= VN.a[0]&(1ULL); w128_self_rsft_1(VN);
}
if (site == cut && err <= thre) return err;
return INT32_MAX;
}
inline int32_t ed_band_cal_semi_128bit(char *pstr, int32_t pn, char *tstr, int32_t tn, int32_t thre, int32_t *re_err)
{
(*re_err) = INT32_MAX;
w128_t Peq[5], mm, VP, VN, X, D0, HN, HP;
//Peq[5] = {0}, mm = (Word)1, VP = 0, VN = 0, X, D0, HN, HP;
w128_clear(VP); w128_clear(VN); w128_clear(mm); w128_bit(mm, 0);
w128_clear(Peq[0]); w128_clear(Peq[1]); w128_clear(Peq[2]); w128_clear(Peq[3]); w128_clear(Peq[4]);
int32_t bd = (thre<<1)+1, i, err = 0, i_bd = (thre<<1), last_high = (thre<<1), tn0 = tn - 1;
int32_t cut = thre+last_high; uint8_t c;
for (i = 0; i < bd; i++) {
w128_self_or(Peq[seq_nt4_table[(uint8_t)pstr[i]]], mm); w128_self_lsft_1(mm);
// Peq[seq_nt4_table[(uint8_t)pstr[i]]] |= mm; mm <<= 1;
}
///should make Peq[4] = 0 if N is always an error
// Peq[4] = 0;
w128_clear(Peq[4]);
//mm = ((Word)1 << (thre<<1));///for the incoming char/last char
w128_clear(mm); w128_bit(mm, (thre<<1));
i = 0;
while (i < tn0) {
// X = Peq[seq_nt4_table[(uint8_t)tstr[i]]] | VN;
c = seq_nt4_table[(uint8_t)tstr[i]]; w128_or(X, Peq[c], VN);
// D0 = ((VP + (X&VP)) ^ VP) | X;
w128_and(D0, X, VP);
w128_self_add(D0, VP);
w128_self_xor(D0, VP);
w128_self_or(D0, X);
// HN = VP&D0;
w128_and(HN, VP, D0);
// HP = VN | ~(VP | D0);
w128_or(HP, VP, D0);
w128_self_not(HP);
w128_self_or(HP, VN);
// X = D0 >> 1;
X = D0; w128_self_rsft_1(X);
// VN = X&HP;
w128_and(VN, X, HP);
// VP = HN | ~(X | HP);
w128_or(VP, X, HP);
w128_self_not(VP);
w128_self_or(VP, HN);
// if (!(D0&(1ULL))) {
if (!(D0.a[0]&(1ULL))) {
++err;
if (err>cut) return -1;
}
// Peq[0] >>= 1; Peq[1] >>= 1; Peq[2] >>= 1; Peq[3] >>= 1;
w128_self_rsft_1(Peq[0]); w128_self_rsft_1(Peq[1]);
w128_self_rsft_1(Peq[2]); w128_self_rsft_1(Peq[3]);
++i; ++i_bd;
// Peq[seq_nt4_table[(uint8_t)pstr[i_bd]]] |= mm; Peq[4] = 0;
c = seq_nt4_table[(uint8_t)pstr[i_bd]];
if(c < 4) w128_self_or(Peq[c], mm);
}
// X = Peq[seq_nt4_table[(uint8_t)tstr[i]]] | VN;
c = seq_nt4_table[(uint8_t)tstr[i]]; w128_or(X, Peq[c], VN);
// D0 = ((VP + (X&VP)) ^ VP) | X;
w128_and(D0, X, VP);
w128_self_add(D0, VP);
w128_self_xor(D0, VP);
w128_self_or(D0, X);
// HN = VP&D0;
w128_and(HN, VP, D0);
// HP = VN | ~(VP | D0);
w128_or(HP, VP, D0);
w128_self_not(HP);
w128_self_or(HP, VN);
// X = D0 >> 1;
X = D0; w128_self_rsft_1(X);
// VN = X&HP;
w128_and(VN, X, HP);
// VP = HN | ~(X | HP);
w128_or(VP, X, HP);
w128_self_not(VP);
w128_self_or(VP, HN);
// if (!(D0&(1ULL))) {
if (!(D0.a[0]&(1ULL))) {
++err;
if (err>cut) return -1;
}
int32_t site = tn - 1, end = -1;///up bound
///in most cases, ai = (thre<<1)
int32_t ai = pn - tn, uge = INT32_MAX;
if ((err <= thre) && (err<=(*re_err))) {
*re_err = err; end = site;
}
i = 0;
while (i < ai) {
// err += ((VP >> i)&(1ULL));
err += VP.a[0]&(1ULL); w128_self_rsft_1(VP);
// err -= ((VN >> i)&(1ULL));
err -= VN.a[0]&(1ULL); w128_self_rsft_1(VN);
++i;
if ((err <= thre) && (err <= (*re_err))) {
*re_err = err; end = site + i;
}
if(i == thre) uge = err;
}
if((uge<=thre) && (uge == (*re_err))) end = site + thre;
return end;
}
/**
@@ -277,7 +912,9 @@ inline int Reserve_Banded_BPM
(char *pattern, int p_length, char *text, int t_length, unsigned short errthold, unsigned int* return_err)
{
(*return_err) = (unsigned int)-1;
// int32_t rerr, rsite = ed_band_cal_semi_128bit(pattern, p_length, text, t_length, errthold, &rerr);
// if(rsite >= 0) (*return_err) = rerr;
// return rsite;
Word Peq[256];
int band_length = (errthold << 1) + 1;
@@ -888,7 +1525,6 @@ inline int Reserve_Banded_BPM_PATH
return return_site;
}
////four patterns have the same p_length
inline int Reserve_Banded_BPM_4_SSE_only(char *pattern1, char *pattern2, char *pattern3, char *pattern4, int p_length, char *text, int t_length,
int* return_sites, unsigned int* return_sites_error, unsigned short errthold, __m128i* Peq_SSE)
@@ -1198,4 +1834,277 @@ inline int Reserve_Banded_BPM_4_SSE_only(char *pattern1, char *pattern2, char *p
}
#define EAC_M 0
#define MIS_M 1
#define MOR_YP 2
#define MOR_XT 3
inline void push_trace(asg16_v *res, uint16_t c, uint32_t len)
{
uint16_t p; c <<= 14;
while (len >= (0x3fff)) {
p = (c + (0x3fff)); kv_push(uint16_t, *res, p); len -= (0x3fff);
}
if(len) {
p = (c + len); kv_push(uint16_t, *res, p);
}
}
// void move_trace_gap(uint16_t *trace, int32_t trace_n, int32_t trace_i,
// char *pstr, int32_t pi, char *tstr, int32_t ti, int32_t *err)
// {
// uint16_t c = trace[trace_i]>>14, l = (trace[trace_i]<<2)>>2;
// if(c != 3 && c != 2) return;
// trace_i--;
// if(c == 3) pi--;
// else if(c == 2) ti--;
// if()
// }
// void adjust_trace(uint16_t *trace, int32_t *trace_n, int32_t *p_beg, int32_t *p_end, int32_t *err, char *pstr, char *tstr)
// {
// if((*err) == 0) return;
// int32_t i, pi, ti; uint16_t c, l;
// for (i = 0; i < (*trace_n) && (trace[i]>>14) == 1; i++) {
// trace[i] <<= 2; trace[i] >>= 2; trace[i] += (((uint16_t)3)<<14);
// l = (trace[i]<<2)>>2; (*p_beg) += l;
// }
// for (i = (*trace_n) - 1; i >= 0 && (trace[i]>>14) == 1; i--) {
// trace[i] <<= 2; trace[i] >>= 2; trace[i] += (((uint16_t)3)<<14);
// l = (trace[i]<<2)>>2; (*p_end) -= l;
// }
// i = 0; pi = (*p_beg); ti = 0;
// for (i = 0; i < (*trace_n); i++) {
// c = trace[i]>>14; l = (trace[i]<<2)>>2;
// if(c == 0 || c == 1) {
// pi += l; ti += l;
// } else if(c == 2) {
// // move_trace_gap(trace, *trace_n, i, pstr, pi, tstr, ti, err);
// pi += l;
// } else if(c == 3) {
// // move_trace_gap(trace, *trace_n, i, pstr, pi, tstr, ti, err);
// ti += l;
// }
// }
// }
inline int32_t ungap_trace(char *pstr, int32_t pn, char *tstr, int32_t tn, int32_t know_err, int32_t know_end,
int32_t *r_err, int32_t *r_beg, asg16_v *cigar, int32_t *cigar_l)
{
int32_t cn = cigar->n, pk, tk, e, l;
(*r_err) = (*r_beg) = INT32_MAX; (*cigar_l) = 0;
if(know_err < 0 || know_end < 0) return -1;
if(know_err == 0) {
push_trace(cigar, EAC_M, tn);
(*r_err) = know_err; (*r_beg) = know_end + 1 - tn; (*cigar_l) = cigar->n - cn;
return know_end;
}
pk = know_end+1-tn; tk = 0; e = 0;
for (l = 0; tk < tn; tk++, pk++) {
if(pstr[pk]!=tstr[tk]) {
e++; if(e > know_err) break;
if(tk > l) push_trace(cigar, EAC_M, tk-l);
push_trace(cigar, MIS_M, 1); l = tk + 1;
}
}
if(tk == tn) {
if(tk > l) push_trace(cigar, EAC_M, tk-l);
(*r_err) = know_err; (*r_beg) = know_end + 1 - tn; (*cigar_l) = cigar->n - cn;
return know_end;
}
cigar->n = cn;
return -1;
}
// ///p_length might be samller than t_length + 2 * errthold
inline int32_t ed_band_cal_semi_trace(char *pstr, int32_t pn, char *tstr, int32_t tn, int32_t thre,
int32_t know_err, int32_t know_end, int32_t *r_err, int32_t *r_beg, Word *buf, asg16_v *cigar, int32_t *cigar_l) {
int32_t cn = cigar->n; (*r_err) = (*r_beg) = INT32_MAX; (*cigar_l) = 0;
Word Peq[5] = {0}, mm = (Word)1, VP = 0, VN = 0, X = 0, D0 = 0, HN = 0, HP = 0, i_col, i_col_dux;
int32_t bd = (thre<<1)+1, i, err = 0, i_bd = (thre<<1), last_high = (thre<<1), tn0 = tn - 1;
int32_t cut = thre+last_high; ///kv_resize(uint16_t, *cigar, cigar->n+(uint32_t)know_err+2);//pre-alloc
if(ungap_trace(pstr, pn, tstr, tn, know_err, know_end, r_err, r_beg, cigar, cigar_l) >= 0) {
return know_end;
}
for (i = 0; i < bd; i++) {
Peq[seq_nt4_table[(uint8_t)pstr[i]]] |= mm; mm <<= 1;
}
Peq[4] = 0;
///should make Peq[4] = 0 if N is always an error
i = i_col = 0; mm = ((Word)1 << (thre<<1));///for the incoming char/last char
while (i < tn0) {
X = Peq[seq_nt4_table[(uint8_t)tstr[i]]] | VN;
D0 = ((VP + (X&VP)) ^ VP) | X;
HN = VP&D0;
HP = VN | ~(VP | D0);
X = D0 >> 1;
VN = X&HP;
VP = HN | ~(X | HP);
if (!(D0&(1ULL))) {
++err;
if (err>cut) return -1;
}
Peq[0] >>= 1; Peq[1] >>= 1; Peq[2] >>= 1; Peq[3] >>= 1; ///Peq[4] >>= 1;
++i; ++i_bd;
Peq[seq_nt4_table[(uint8_t)pstr[i_bd]]] |= mm; Peq[4] = 0;
buf[i_col++] = D0; buf[i_col++] = VP; buf[i_col++] = VN; buf[i_col++] = HP; buf[i_col++] = HN;
}
X = Peq[seq_nt4_table[(uint8_t)tstr[i]]] | VN;
D0 = ((VP + (X&VP)) ^ VP) | X;
HN = VP&D0;
HP = VN | ~(VP | D0);
X = D0 >> 1;
VN = X&HP;
VP = HN | ~(X | HP);
if (!(D0&(1ULL))) {
++err;
if (err>cut) return -1;
}
buf[i_col++] = D0; buf[i_col++] = VP; buf[i_col++] = VN; buf[i_col++] = HP; buf[i_col++] = HN;
i_col_dux = i_col/tn;
int32_t site = tn - 1, end = -1;///up bound
///in most cases, ai = (thre<<1)
int32_t ai = pn - tn, uge = INT32_MAX;
if ((err <= thre) && (err<=(*r_err))) {
*r_err = err; end = site;
}
i = 0;
while (i < ai) {
err += ((VP >> i)&(1ULL)); err -= ((VN >> i)&(1ULL)); ++i;
if ((err <= thre) && (err <= (*r_err))) {
*r_err = err; end = site + i;
}
if(i == thre) uge = err;
}
if((uge<=thre) && (uge == (*r_err))) end = site + thre;
if ((*r_err) > thre) return end;
///need to correct pn here, since pn might be smaller than tn + 2* thre
pn = tn + (thre<<1);
int32_t beg = end, back_track_site = bd - (pn - end);
Word v_value, h_value, delta_value, min_value, current_value;
///Word direction; ///0 is match, 1 is mismatch, 2 is up, 3 is left
Word direction = 0, *ba, pd, pdl; ///0 is match, 1 is mismatch, 2 is up, 3 is left
i = tn; pd = (Word)-1; pdl = 0;
current_value = *r_err;
int32_t low_bound = bd - 1;
while (i > 0) {
if (current_value == 0) break;
ba = buf + ((i*i_col_dux) - i_col_dux);
delta_value = current_value - ((~(ba[0]>>back_track_site))&(1ULL));
if (back_track_site == 0) {
///HP
h_value = current_value - ((ba[3] >> back_track_site)&(1ULL));
//HN
h_value = h_value + ((ba[4] >> back_track_site)&1ULL);
min_value = delta_value; direction = 0;
if (h_value < min_value) {
min_value = h_value;
direction = 3;
}
} else if (back_track_site == low_bound) {
v_value = current_value - ((ba[1]>>(back_track_site-1))&(1ULL));
v_value = v_value + ((ba[2]>>(back_track_site-1))&(1ULL));
min_value = delta_value; direction = 0;
if (v_value < min_value) {
min_value = v_value;
direction = 2;
}
}
else {
h_value = current_value-((ba[3]>>back_track_site)&(1ULL));
h_value = h_value+((ba[4]>>back_track_site)&(1ULL));
v_value = current_value - ((ba[1]>>(back_track_site-1))&(1ULL));
v_value = v_value + ((ba[2]>>(back_track_site-1))&(1ULL));
min_value = delta_value; direction = 0;
if (v_value < min_value) {
min_value = v_value;
direction = 2;
}
if (h_value < min_value) {
min_value = h_value;
direction = 3;
}
}
if (direction == 0) {
if (delta_value != current_value) {
direction = 1;
}
i--; beg--;
}
if (direction == 2) {///ru guo xiang shang yi dong, bing bu huan lie
back_track_site--; beg--;
}
else if (direction == 3) {///ru guo xiang zuo yi dong
i--;
back_track_site++;
}
if(direction != pd) {
if(pdl > 0) push_trace(cigar, pd, pdl);
pd = direction; pdl = 1;
} else {
pdl++;
}
// path[path_length++] = direction;
current_value = min_value;
}
if (i > 0) {
direction = 0; beg -= i;
if(direction != pd) {
if(pdl > 0) push_trace(cigar, pd, pdl);
pd = direction; pdl = i;
} else {
pdl += i;
}
}
if(pdl > 0) push_trace(cigar, pd, pdl);
if (direction != 3) beg++;
uint16_t *trac = cigar->a + cn, tt; int32_t trac_n = cigar->n - cn; ai = trac_n>>1;
for (i = 0; i < ai; i++) {
tt = trac[i]; trac[i] = trac[trac_n-i-1]; trac[trac_n-i-1] = tt;
}
(*cigar_l) = cigar->n - cn;
(*r_beg) = beg; (*cigar_l) = cigar->n - cn;
return end;
}
#endif

17
anchor.cpp
View File

@@ -896,7 +896,7 @@ void lchain_gen(Candidates_list* cl, overlap_region_alloc* ol, uint32_t rid, uin
int64_t max_skip, int64_t max_iter, int64_t max_dis, double chn_pen_gap, double chn_pen_skip, double bw_rate, int64_t quick_check, uint32_t gen_off)
{
// fprintf(stderr, "+[M::%s]\n", __func__);
uint64_t i, k, l, m, sm, cn = cl->length, srt = 0; overlap_region *r;
uint64_t i, k, l, m, sm, cn = cl->length; overlap_region *r; ///srt = 0
clear_overlap_region_alloc(ol);
clear_fake_cigar(&(tf->f_cigar));
@@ -913,13 +913,11 @@ void lchain_gen(Candidates_list* cl, overlap_region_alloc* ol, uint32_t rid, uin
rl, rdb?Get_READ_LENGTH((*rdb), (*tf).y_id):udb->ug->u.a[(*tf).y_id].len, quick_check);
// assert(sm > 0);
if(ovlp_chain_gen(ol, tf, rl, rdb?Get_READ_LENGTH((*rdb), (*tf).y_id):udb->ug->u.a[(*tf).y_id].len, apend_be, cl->list+m, sm)) {
if(gen_off) {
r = &(ol->list[ol->length-1]);
if(r->y_pos_strand) {
reverse_k_mer_hit(cl->list+m, sm, rl, rdb?Get_READ_LENGTH((*rdb), r->y_id):udb->ug->u.a[r->y_id].len);
}
gen_fake_cigar(&(r->f_cigar), r, apend_be, cl->list+m, sm);
r = &(ol->list[ol->length-1]); r->non_homopolymer_errors = m;
if(r->y_pos_strand) {
reverse_k_mer_hit(cl->list+m, sm, rl, rdb?Get_READ_LENGTH((*rdb), r->y_id):udb->ug->u.a[r->y_id].len);
}
if(gen_off) gen_fake_cigar(&(r->f_cigar), r, apend_be, cl->list+m, sm);
m += sm;
}
}
@@ -933,7 +931,7 @@ void lchain_gen(Candidates_list* cl, overlap_region_alloc* ol, uint32_t rid, uin
if (ol->length > max_n_chain) {
int32_t w, n[4], s[4]; overlap_region t;
n[0] = n[1] = n[2] = n[3] = 0, s[0] = s[1] = s[2] = s[3] = 0;
ks_introsort_or_ss(ol->length, ol->list); srt = 1;
ks_introsort_or_ss(ol->length, ol->list); ///srt = 1;
for (i = 0; i < ol->length; ++i) {
r = &(ol->list[i]);
w = ha_ov_type(r, rl);
@@ -959,7 +957,7 @@ void lchain_gen(Candidates_list* cl, overlap_region_alloc* ol, uint32_t rid, uin
ol->length = k;
}
}
/**
if(!gen_off) {
if(srt) ks_introsort_or_id(ol->length, ol->list);
uint64_t cln = cl->length;
@@ -979,6 +977,7 @@ void lchain_gen(Candidates_list* cl, overlap_region_alloc* ol, uint32_t rid, uin
}
cl->length = m;
}
**/
ks_introsort_or_xs(ol->length, ol->list);
}

416
inter.cpp
View File

@@ -335,7 +335,7 @@ void hc_gdpchain_destroy(gdpchain_t *b)
}
void init_mg_opt(mg_idxopt_t *opt, int is_HPC, int k, int w, int hap_n, int max_n_chain, double bw_thres,
double diff_ec_ul, double diff_ec_ul_low, int ec_ul_round)
double diff_ec_ul, double diff_ec_ul_low, double diff_ec_ul_hpc, int ec_ul_round)
{
opt->k = k;
opt->w = w;
@@ -364,6 +364,7 @@ double diff_ec_ul, double diff_ec_ul_low, int ec_ul_round)
opt->bw_thres = bw_thres;
opt->diff_ec_ul = diff_ec_ul;
opt->diff_ec_ul_low = diff_ec_ul_low;
opt->diff_ec_ul_hpc = diff_ec_ul_hpc;
opt->ec_ul_round = ec_ul_round;
}
@@ -4936,7 +4937,7 @@ void update_ul_vec_t_ug(const ul_idx_t *uref, ul_vec_t *rch, vec_mg_lchain_t *uc
if(sp != (uint32_t)-1) l += ep - sp;
l = (int64_t)rch->rlen - l;
// if(ulid == 1756) fprintf(stderr, "-ulid:%ld, l:%ld, rch->rlen:%u\n", ulid, l, rch->rlen);
// fprintf(stderr, "-ulid:%ld, l:%ld, rch->rlen:%u\n", ulid, l, rch->rlen);
if(l == 0) {
rch->dd = 1;
} else if(l < ((int64_t)rch->rlen)*0.001) {
@@ -5062,6 +5063,7 @@ int64_t debug_i, int64_t tid, void *km)
ll->tk.n = ll->lo.n = 0;
kv_ul_ov_t *idx = &(ll->lo);
gl_chain_gen(olist, uref, idx, 0, hap, km);///no trans
// fprintf(stderr, "0-[M::%s] idx->n::%lu\n", __func__, (uint64_t)idx->n);
if(idx->n == 0) return 0;
// fprintf(stderr, "(beg0) [M::%s::tid:%ld] debug_i:%ld, qlen:%ld, # cis:%lu, # trans:%lu\n", __func__, tid, debug_i, qlen, (uint64_t)idx->n, o2);
int64_t max_idx, occ = 0, f = 0;
@@ -5076,6 +5078,7 @@ int64_t debug_i, int64_t tid, void *km)
f = l2g_res_chain(uref->ug, ll->tk.a+idx->a[idx->n-1].ts, idx->a[idx->n-1].te-idx->a[idx->n-1].ts, &(gdp->swap), -1/**N_GCHAIN_RATE**/);
}
}
// fprintf(stderr, "1-[M::%s] f::%ld\n", __func__, f);
// fprintf(stderr, "(beg1) [M::%s] debug_i:%ld, qlen:%ld\n", __func__, debug_i, qlen);
if(!f) {
gl_chain_gen(olist, uref, idx, 0, hap, km);///no trans
@@ -5099,6 +5102,376 @@ int64_t debug_i, int64_t tid, void *km)
return 1;
}
int64_t comput_err_partial_cigar(int64_t ol, overlap_region *z, int64_t *rk)
{
int64_t k = 0, err = 0, e = z->x_pos_s+ol, wn = z->w_list.n; (*rk) = -1;
for (k = 0; k < wn; k++) {
if(z->w_list.a[k].x_start >= e) break;
if(z->w_list.a[k].y_end != -1) {
err += z->w_list.a[k].error;
}
}
k--;
if(k < 0) return 0;
if(z->w_list.a[k].y_end != -1) {
err -= z->w_list.a[k].error;
}
if((int64_t)z->w_list.a[k].x_end+1 <= e) {
if(z->w_list.a[k].y_end != -1) {
err += z->w_list.a[k].error;
}
} else {
// assert(z->w_list.a[k].x_start < e);
if(z->w_list.a[k].y_end != -1) {
err += (((double)(e-z->w_list.a[k].x_start))/
((double)(z->w_list.a[k].x_end+1-z->w_list.a[k].x_start)))*z->w_list.a[k].error;
}
}
(*rk) = k;
return err;
}
int64_t sum_w_err(window_list *a, int64_t n)
{
int64_t k, err = 0;
for (k = 0; k < n; k++) {
if(a[k].y_end != -1) err += a[k].error;
}
return err;
}
int64_t comput_sc_partial_cigar(int64_t sc, int64_t ol, double err_sc_r, overlap_region *z, int64_t *wi, int64_t *werr)
{
int64_t k = wi?(*wi):0, wn = z->w_list.n, err = werr?(*werr):0, e = z->x_pos_s+ol;
if(ol == 0) return sc;
// int64_t pk, pe;
if((int64_t)(z->x_pos_e + 1 - z->x_pos_s) <= ol) return 0;
if(k == wn) {
k--;
if(z->w_list.a[k].y_end != -1) {
err -= z->w_list.a[k].error;
}
}
if(z->w_list.a[k].x_start >= e) {
if(z->w_list.a[k].y_end != -1) err += z->w_list.a[k].error;
for (;(k>=0) && (z->w_list.a[k].x_start>=e); k--) {
if(z->w_list.a[k].y_end != -1) {
err -= z->w_list.a[k].error;
}
}
} else {
for (;(k<wn) && (z->w_list.a[k].x_start<e); k++) {
if(z->w_list.a[k].y_end != -1) {
err += z->w_list.a[k].error;
}
}
k--;
}
// pk = (*wi); pe = (*werr);
if(k < 0) {
k = 0; err = 0;
if(wi) (*wi) = k; if(werr) (*werr) = err;
// assert(e <= z->w_list.a[0].x_start);
} else {
if(z->w_list.a[k].y_end != -1) {
err -= z->w_list.a[k].error;
}
if(wi) (*wi) = k; if(werr) (*werr) = err;
// if(!(err >= 0 && k >= 0 && k < wn && z->w_list.a[k].x_start < e && z->w_list.a[k].x_end + 1 >= e)){
// fprintf(stderr, "[M::%s] ol::%ld, e::%ld, z::[%u, %u], k::%ld, wn::%ld, w::[%d, %d], err::%ld\n", __func__,
// ol, e, z->x_pos_s, z->x_pos_e, k, wn, z->w_list.a[k].x_start, z->w_list.a[k].x_end, err);
// }
// assert(err >= 0 && k >= 0 && k < wn && z->w_list.a[k].x_start < e &&
// (e <= z->w_list.a[k+1].x_start));
if((int64_t)z->w_list.a[k].x_end+1 <= e) {
if(z->w_list.a[k].y_end != -1) {
err += z->w_list.a[k].error;
}
} else {
// assert(z->w_list.a[k].x_start < e);
if(z->w_list.a[k].y_end != -1) {
err += (((double)(e-z->w_list.a[k].x_start))/
((double)(z->w_list.a[k].x_end+1-z->w_list.a[k].x_start)))*z->w_list.a[k].error;
}
}
}
// int64_t dbg_k, dbg_e = comput_err_partial_cigar(ol, z, &dbg_k);
// if(err != dbg_e) {
// fprintf(stderr, "[M::%s] ol::%ld, e::%ld, z::[%u, %u], k::%ld, wn::%ld, w::[%d, %d], err::%ld, dbg_e::%ld, dbg_k::%ld, pe::%ld, pk::%ld, sum_pk_err::%ld, sum_k_err::%ld, werr::%ld\n",
// __func__, ol, e, z->x_pos_s, z->x_pos_e, k, wn, z->w_list.a[k].x_start, z->w_list.a[k].x_end, err, dbg_e, dbg_k, pe, pk,
// sum_w_err(z->w_list.a, pk), sum_w_err(z->w_list.a, k), *werr);
// }
// assert(err == dbg_e);
ol -= (err*err_sc_r); sc -= ol; if(sc <= 0) sc = 1;
return sc;
}
///mode: 0->ug; 1->read
int64_t ed_dp_c(overlap_region_alloc *o, kv_ul_ov_t *res, ul_ov_t *ex, const ul_idx_t *uref, const ug_opt_t *uopt, int64_t bw,
double diff_ec_ul, int64_t qlen, int64_t max_skip, uint64_t *srt, uint64_t *idx, uint64_t *track, double err_sc,
uint64_t mode, All_reads *ridx, ma_ug_t *ug)
{
if(res->n == 0) return 0;
uint32_t li_v, lj_v, rev_n;
int64_t mm_ovlp, x, i, j, k, sc, csc, mm_sc, mm_idx, qo, qovl, share, minus_sc, pj, n_skip, wi, werr;
ul_ov_t *li = NULL, *lj = NULL, rev_t;
radix_sort_ul_ov_srt_qe(res->a, res->a + res->n);
for (i = 1, j = 0; i <= (int64_t)res->n; i++) {
if (i == (int64_t)res->n || res->a[i].qe != res->a[j].qe) {
if(i - j > 1) radix_sort_ul_ov_srt_qs(res->a+j, res->a+i);
j = i;
}
}
///res->a[0].qe: min_qe; res->a[res->n-1].qs: max_qs
if(res->a[0].qe == qlen && res->a[res->n-1].qs == 0) {///all alignments are contained
for (i = 0; i < (int64_t)res->n; ++i) {
li = &(res->a[i]); assert(li->qs == 0 && li->qe == qlen);
csc = (li->qe-li->qs); minus_sc = (o->list[li->qn].non_homopolymer_errors*err_sc);
csc -= minus_sc; if(csc <= 0) csc = 1; mm_sc = csc; mm_idx = -1;
if(mm_sc > ((int64_t)0x7fffffff)) mm_sc = ((int64_t)0x7fffffff);
track[i] = push_sc_pre(mm_sc, mm_idx);
srt[i] = track[i]>>32; srt[i] <<= 32; srt[i] |= i;
}
} else {
memset(idx, 0, (sizeof((*idx))*res->n));
for (i = 0; i < (int64_t)res->n; ++i) {
li = &(res->a[i]); li_v = (li->tn<<1)|li->rev;
mm_ovlp = mode?max_ovlp_src(uopt, li_v^1):max_ovlp(uref->ug->g, li_v^1);
x = (li->qs + mm_ovlp)*diff_ec_ul;
if(x < bw) x = bw;
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 = (li->qe-li->qs); minus_sc = (o->list[li->qn].non_homopolymer_errors*err_sc);
csc -= minus_sc; if(csc <= 0) csc = 1;
mm_sc = csc; mm_idx = -1; n_skip = 0; wi = werr = 0;
for (j = x; j >= 0; --j) { // collect potential destination vertices
lj = &(res->a[j]); lj_v = (lj->tn<<1)|lj->rev;
if(lj->qe+G_CHAIN_INDEL <= li->qs) break;//even this pair has a overlap, its length will be very small; just ignore
if(lj->qs >= li->qs) continue;
qo = infer_rovlp(li, lj, NULL, NULL, ridx, ug); ///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, &share)) {
qovl = ((MIN(li->qe, lj->qe) > MAX(li->qs, lj->qs))? (MIN(li->qe, lj->qe) - MAX(li->qs, lj->qs)):0);
// fprintf(stderr, "[M::%s::] utg%.6dl->utg%.6dl, icsc::%ld, ierr::%u, ilen::%u, aln::%u, app_sc::%ld\n",
// __func__, (int32_t)li->tn+1, (int32_t)lj->tn+1, csc, o->list[li->qn].non_homopolymer_errors,
// li->qe - li->qs, o->list[li->qn].align_length, comput_sc_partial_cigar(csc, qovl, err_sc, &(o->list[li->qn]), &wi, &werr));
sc = comput_sc_partial_cigar(csc, qovl, err_sc, &(o->list[li->qn]), &wi, &werr)
+ pop_sc(track[j]);
if(sc > mm_sc) {
mm_sc = sc, mm_idx = j;
if (n_skip > 0) --n_skip;
} else if (idx[j] == (uint64_t)i) {
if (++n_skip > max_skip)
break;
}
pj = pop_pre(track[j]);
if(pj >= 0) idx[pj] = i;
}
}
if(mm_sc > ((int64_t)0x7fffffff)) mm_sc = ((int64_t)0x7fffffff);
track[i] = push_sc_pre(mm_sc, mm_idx);
srt[i] = track[i]>>32; srt[i] <<= 32; srt[i] |= i;
}
}
int64_t n_v, n_u, n_v0;
radix_sort_gfa64(srt, srt+res->n);
for (k = (int64_t)res->n-1, n_v = n_u = 0; k >= 0; --k) {
n_v0 = n_v;
for (i = (uint32_t)srt[k]; i >= 0 && (track[i]&((uint64_t)0x80000000)) == 0;) {
ex[n_v++] = res->a[i]; track[i] |= ((uint64_t)0x80000000);
i = pop_pre(track[i]);
}
if(n_v0 == n_v) continue;
sc = (i<0?(pop_sc(srt[k])):(pop_sc(srt[k])-pop_sc(track[i])));
if(sc < 0) {
n_v = n_v0;
continue;
}
idx[n_u++] = ((uint64_t)sc<<32)|(n_v-n_v0);
}
for (k = 0, n_v = n_v0 = 0; k < n_u; k++) {
n_v0 = n_v; n_v += (uint32_t)idx[k];
res->a[k].qn = idx[k]>>32;//score
res->a[k].ts = n_v0; res->a[k].te = n_v;///idx
rev_n = ((uint32_t)idx[k])>>1;
///we need to consider contained reads; so determining qs is not such easy
res->a[k].qs = (uint32_t)-1; res->a[k].qe = ex[n_v0].qe;
for (i = 0; i < rev_n; i++) {
rev_t = ex[n_v0+i]; ex[n_v0+i] = ex[n_v-i-1]; ex[n_v-i-1] = rev_t;
if(res->a[k].qs > ex[n_v0+i].qs) res->a[k].qs = ex[n_v0+i].qs;
if(res->a[k].qs > ex[n_v-i-1].qs) res->a[k].qs = ex[n_v-i-1].qs;
}
if(((uint32_t)idx[k])&1) {
if(res->a[k].qs > ex[n_v0+i].qs) res->a[k].qs = ex[n_v0+i].qs;
}
}
res->n = n_u;
radix_sort_ul_ov_srt_qn(res->a, res->a + res->n);//sort by score
// fprintf(stderr, "---[M::%s] n_u:%ld, n_v:%ld\n", __func__, n_u, n_v);
return n_v;
}
void set_w_e(overlap_region *z, uint64_t *w_idx, int64_t wl, int64_t ql)
{
int64_t wid, k, wn = z->w_list.n, ws, we;
for (k = 0; k < wn; k++) {
wid = z->w_list.a[k].x_start/wl;
ws = wid*wl; we = ws+wl; if(we > ql) we = ql; we--;
// fprintf(stderr, "[M::%s] ws::%ld, we::%ld, xs::%d, xe::%d, err::%d\n", __func__,
// ws, we, z->w_list.a[k].x_start, z->w_list.a[k].x_end, z->w_list.a[k].error);
if(ws == z->w_list.a[k].x_start && we == z->w_list.a[k].x_end && z->w_list.a[k].y_end != -1) {
if((w_idx[wid] == (uint64_t)-1) || (w_idx[wid] < (uint64_t)z->w_list.a[k].error)) {
w_idx[wid] = z->w_list.a[k].error;
}
}
}
}
uint32_t ck_w_err(overlap_region *z, uint64_t *w_idx, int64_t wl, int64_t ql)
{
int64_t wid, k, wn = z->w_list.n, ws, we, ol, e[2];
ol = e[0] = e[1] = 0;
for (k = 0; k < wn; k++) {
wid = z->w_list.a[k].x_start/wl;
if(w_idx[wid] == (uint64_t)-1) continue;
ws = wid*wl; we = ws+wl; if(we > ql) we = ql; we--;
if(ws == z->w_list.a[k].x_start && we == z->w_list.a[k].x_end) {
ol += we+1-ws; e[0] += w_idx[wid];
if(z->w_list.a[k].y_end != -1) e[1] += z->w_list.a[k].error;
else e[1] += THRESHOLD_MAX_SIZE + 1;
}
}
// fprintf(stderr, "[M::%s::utg%.6dl] x::[%u, %u), ol::%ld, e[0]::%ld, e[1]::%ld\n",
// __func__, (int32_t)z->y_id+1, z->x_pos_s, z->x_pos_e+1, ol, e[0], e[1]);
if(e[1] > (e[0]+32)) {
if(e[1] > (e[0]+(ol*0.01))) return 0;
if(e[1] > (e[0]+(e[0]*0.01))) return 0;
}
// if((e[1] > (e[0]+16)) && (e[1] > (e[0]+(ol*0.01)))) return 0;
return 1;
}
int64_t filter_sec(overlap_region_alloc *ol, ul_ov_t *idx, int64_t idx_n, ul_ov_t *a, uint64_t *w_idx, uint64_t nw, uint64_t wl, uint64_t ql)
{
if(idx_n <= 0) return 1;
int64_t on = ol->length, k, z, on_contain = 0, max_i = -1, max_k = -1, alt_occ = 0; overlap_region t;
memset(w_idx, -1, nw*sizeof((*w_idx)));
for (k = 0; k < on; k++) ol->list[k].is_match = 0;
for (k = 0; k < idx_n; k++) {
// fprintf(stderr, "[M::%s::pri_chain[%ld]] q_coord::[%u, %u), occ::%u\n",
// __func__, k, idx[k].qs, idx[k].qe, idx[k].te-idx[k].ts);
for (z = idx[k].ts; z < idx[k].te; z++) {
ol->list[a[z].qn].is_match = 2;
set_w_e(&(ol->list[a[z].qn]), w_idx, wl, ql);
// fprintf(stderr, "[M::%s::utg%.6dl]\n", __func__, (int32_t)a[z].tn+1);
}
on_contain += (((idx[k].te-idx[k].ts)==1)?1:0);
}
if(on_contain == idx_n) {///each primary chain only has one alignment
on_contain = 0;
} else {
on_contain = -on-1;///in this case, on_contain == z is always wrong
}
max_i = a[idx[idx_n-1].ts].qn;
for (k = z = 0; k < on; k++) {
if(!ol->list[k].is_match) ol->list[k].is_match = ck_w_err(&(ol->list[k]), w_idx, wl, ql);
if(!ol->list[k].is_match) continue;
if(z != k) {
t = ol->list[k];
ol->list[k] = ol->list[z];
ol->list[z] = t;
}
if(ol->list[z].x_pos_s == 0 && ol->list[z].x_pos_e == ql - 1) {
on_contain++;
if(max_i == k) max_k = z;
}
if(ol->list[z].is_match == 1) alt_occ++;
else ol->list[z].is_match = 1;
z++;
}
ol->length = z;
// fprintf(stderr, "+[M::%s] oln::%ld\n", __func__, ol->length);
if(on_contain == z) {///do not contribute to phase
k = max_k; z = 0;
if(z != k) {
t = ol->list[k];
ol->list[k] = ol->list[z];
ol->list[z] = t;
}
ol->length = 1;
}
// fprintf(stderr, "-[M::%s] oln::%ld\n", __func__, ol->length);
if(alt_occ == 0 || ol->length == 1) return 1;//if all alignments are primary or there is only one alignment
return 0;
}
int64_t gl_chain_flter(overlap_region_alloc* olist, Correct_dumy* dumy, st_mt_t *sps, glchain_t *ll, const ul_idx_t *uref, double diff_ec_ul, int64_t wl, int64_t ql, const ug_opt_t *uopt, uint32_t *need_phase)
{
(*need_phase) = 1;
uint64_t k, nw; ul_ov_t *p, *m; int64_t occ, i, ovlp, idx_n;
ll->tk.n = ll->lo.n = 0;
kv_ul_ov_t *idx = &(ll->lo); idx->n = 0;
kv_resize(ul_ov_t, *idx, olist->length);
for (k = 0; k < olist->length; k++) {
p = &(idx->a[idx->n++]);
p->qn = k; p->qs = olist->list[k].x_pos_s; p->qe = olist->list[k].x_pos_e+1;
p->tn = olist->list[k].y_id; p->el = 1; p->rev = olist->list[k].y_pos_strand;
p->sec = olist->list[k].non_homopolymer_errors;
if(p->rev) {
p->ts = uref->ug->u.a[p->tn].len - (olist->list[k].y_pos_e+1);
p->te = uref->ug->u.a[p->tn].len - olist->list[k].y_pos_s;
} else {
p->ts = olist->list[k].y_pos_s;
p->te = olist->list[k].y_pos_e+1;
}
}
if(idx->n == 0) return 0;
kv_resize(uint64_t, ll->srt.a, idx->n);
kv_resize(uint64_t, *sps, idx->n);
kv_resize(ul_ov_t, ll->tk, idx->n);
occ = ed_dp_c(olist, idx, ll->tk.a, uref, uopt, G_CHAIN_BW, N_GCHAIN_RATE, ql, 75, dumy->overlapID, ll->srt.a.a, sps->a, 1.25, 0, NULL, uref->ug);
if((!occ) || (!idx->n)) return 0;
idx_n = idx->n; p = &(idx->a[idx_n-1]);
// fprintf(stderr, "[M::%s] qs::%u, qe::%u, ql::%ld, occ::%u\n", __func__, p->qs, p->qe, ql, p->te - p->ts);
if(p->qe-p->qs <= (ql*0.25)) return 0;///primary chain is too short
i = idx_n-1; occ = p->te - p->ts;
if(p->qe-p->qs < ql && idx_n > 1) {
for (occ = 0; i >= 0; i--) {
p = &(idx->a[i]);
for (k = i + 1; k < idx->n; k++) {
m = &(idx->a[k]);
ovlp = ((MIN(m->qe, p->qe) > MAX(m->qs, p->qs))? (MIN(m->qe, p->qe) - MAX(m->qs, p->qs)):0);
if(((ovlp > ((m->qe-m->qs)*0.005)) || (ovlp > ((p->qe-p->qs)*0.015))) && ovlp > 32) break;
if((ovlp == (m->qe-m->qs)) || (ovlp == (p->qe-p->qs))) break;
}
if(k < idx->n) break;
occ += p->te - p->ts;
}
i++;
}
// fprintf(stderr, "[M::%s] i::%ld, idx_n::%ld\n", __func__, i, ((int64_t)idx->n));
if(occ == (int64_t)olist->length) return 1;
// if(i >= ((int64_t)idx->n)) return 0;
nw = get_num_wins(0, ql, wl); kv_resize(uint64_t, ll->srt.a, (uint64_t)nw);
if(filter_sec(olist, idx->a+i, idx->n-i, ll->tk.a, ll->srt.a.a, nw, wl, ql)) {
(*need_phase) = 0;
}
return 1;
}
uint64_t kv_ul_ov_t_statistics(kv_ul_ov_t *olist, uint64_t qn, int64_t *occ)
{
int64_t k, l = 0;
@@ -5216,9 +5589,9 @@ static void worker_for_ul_rescall_alignment(void *data, long i, int tid) // call
ha_ovec_buf_t *b = s->hab[tid];
glchain_t *bl = &(s->ll[tid]);
int64_t /**rid = s->id+i,**/ winLen = MIN((((double)THRESHOLD_MAX_SIZE)/s->opt->diff_ec_ul), WINDOW);
uint32_t high_occ = 2;
uint32_t high_occ = 2, phase = 1;
// uint64_t align = 0;
int fully_cov, abnormal;
// if(UL_INF.a[s->id+i].rlen != s->len[i]) {
// fprintf(stderr, "[M::%s] rid:%ld, s->len:%lu, UL_INF->rlen:%u\n", __func__, s->id+i, s->len[i], UL_INF.a[s->id+i].rlen);
// }
@@ -5227,7 +5600,7 @@ static void worker_for_ul_rescall_alignment(void *data, long i, int tid) // call
// if(s->id+i!=41927 && s->id+i!=47072 && s->id+i!=67641 && s->id+i!=90305 && s->id+i!=698342 && s->id+i!=329421) {
// return;
// }
// if(s->id+i!=47) return;
// if((s->id+i!=43) /**&& (s->id+i!=44) && (s->id+i!=948)**/) 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);
@@ -5243,9 +5616,22 @@ static void worker_for_ul_rescall_alignment(void *data, long i, int tid) // call
// return;
// b->num_correct_base += overlap_statistics(&b->olist, NULL, 0);
b->self_read.seq = s->seq[i]; b->self_read.length = s->len[i]; b->self_read.size = 0;
correct_ul_overlap(&b->olist, s->uu, &b->self_read, &b->correct, &b->ovlp_read, &b->POA_Graph, &b->DAGCon,
&b->cigar1, &b->hap, &b->round2, &b->r_buf, &(b->tmp_region.w_list), 0, 1, &fully_cov, &abnormal, s->opt->diff_ec_ul, winLen, NULL);
// int fully_cov, abnormal;
// b->self_read.seq = s->seq[i]; b->self_read.length = s->len[i]; b->self_read.size = 0;
// correct_ul_overlap(&b->olist, s->uu, &b->self_read, &b->correct, &b->ovlp_read, &b->POA_Graph, &b->DAGCon,
// &b->cigar1, &b->hap, &b->round2, &b->r_buf, &(b->tmp_region.w_list), 0, 1, &fully_cov, &abnormal, s->opt->diff_ec_ul, winLen, NULL);
// memset(&b->self_read, 0, sizeof(b->self_read));
ul_lalign(&b->olist, &b->clist, s->uu, s->seq[i], s->len[i], &b->self_read, &b->ovlp_read,
&b->correct, &b->hap, &b->r_buf, s->opt->diff_ec_ul, winLen, 1, NULL);
gl_chain_flter(&b->olist, &b->correct, &(s->sps[tid]), bl, s->uu, s->opt->diff_ec_ul, winLen, s->len[i], s->uopt, &phase);
if(phase) {
ul_lalign(&b->olist, &b->clist, s->uu, s->seq[i], s->len[i], &b->self_read, &b->ovlp_read,
&b->correct, &b->hap, &b->r_buf, s->opt->diff_ec_ul, winLen, 0, NULL);
}
// exit(1);
// uint64_t k;
// for (k = 0; k < b->olist.length; k++) {
@@ -5260,7 +5646,7 @@ static void worker_for_ul_rescall_alignment(void *data, long i, int tid) // call
// b->num_read_base += b->self_read.length;
// b->num_correct_base += b->correct.corrected_base;
// b->num_recorrect_base += b->round2.dumy.corrected_base;
memset(&b->self_read, 0, sizeof(b->self_read));
if(UL_INF.a[s->id+i].dd) {
free(s->seq[i]); s->seq[i] = NULL; b->num_correct_base++;
}
@@ -9150,6 +9536,10 @@ int rescall_ul_pipeline(uldat_t* sl, const enzyme *fn)
// fprintf(stderr, "[M::%s::] ==> # bases: %lu; # corrected bases: %lu; # recorrected bases: %lu\n",
// __func__, sl->num_bases, sl->num_corrected_bases, sl->num_recorrected_bases);
// gen_ul_vec_rid_t(&UL_INF);
// for (i = 0; i < UL_INF.n; i++) {
// fprintf(stderr, "[M::%s] rid::%d, dd::%u\n", __func__, i, UL_INF.a[i].dd);
// }
return 1;
}
@@ -9666,7 +10056,7 @@ void ul_resolve(ma_ug_t *ug, const asg_t *rg, const ug_opt_t *uopt, int hap_n)
{
fprintf(stderr, "[M::%s::] ==> UL\n", __func__);
mg_idxopt_t opt;
init_mg_opt(&opt, 0, 19, 10, hap_n, 0, 0, 0.05, asm_opt.ul_error_rate_low, asm_opt.ul_ec_round);
init_mg_opt(&opt, 0, 19, 10, hap_n, 0, 0, 0.05, asm_opt.ul_error_rate_low, asm_opt.ul_error_rate_hpc, asm_opt.ul_ec_round);
int exist = (asm_opt.load_index_from_disk? uidx_load(&ha_flt_tab, &ha_idx, asm_opt.output_file_name, NULL) : 0);
if(exist == 0) uidx_build(ug, &opt);
if(exist == 0) uidx_write(ha_flt_tab, ha_idx, asm_opt.output_file_name, NULL);
@@ -10655,7 +11045,7 @@ void ul_load(const ug_opt_t *uopt)
int32_t cutoff;
init_aux_table(); ha_opt_update_cov(&asm_opt, asm_opt.hom_cov);
cutoff = asm_opt.max_n_chain;
init_mg_opt(&opt, !(asm_opt.flag&HA_F_NO_HPC), 19, 10, cutoff, asm_opt.max_n_chain, asm_opt.ul_error_rate, asm_opt.ul_error_rate, asm_opt.ul_error_rate_low, asm_opt.ul_ec_round);
init_mg_opt(&opt, !(asm_opt.flag&HA_F_NO_HPC), 19, 10, cutoff, asm_opt.max_n_chain, asm_opt.ul_error_rate, asm_opt.ul_error_rate, asm_opt.ul_error_rate_low, asm_opt.ul_error_rate_hpc, asm_opt.ul_ec_round);
init_uldat_t(&sl, NULL, NULL, &opt, CHUNK_SIZE, asm_opt.thread_num, uopt, NULL);
if(!load_all_ul_t(&UL_INF, asm_opt.output_file_name, &R_INF, NULL)) {
@@ -10685,7 +11075,7 @@ uint64_t ul_refine_alignment(const ug_opt_t *uopt, asg_t *sg)
mg_idxopt_t opt; uldat_t sl; int32_t cutoff;
init_aux_table(); ha_opt_update_cov(&asm_opt, asm_opt.hom_cov);
cutoff = asm_opt.max_n_chain;
init_mg_opt(&opt, !(asm_opt.flag&HA_F_NO_HPC), 19, 10, cutoff, asm_opt.max_n_chain, asm_opt.ul_error_rate, asm_opt.ul_error_rate, asm_opt.ul_error_rate_low, asm_opt.ul_ec_round);
init_mg_opt(&opt, !(asm_opt.flag&HA_F_NO_HPC), 19, 10, cutoff, asm_opt.max_n_chain, asm_opt.ul_error_rate, asm_opt.ul_error_rate, asm_opt.ul_error_rate_low, asm_opt.ul_error_rate_hpc, asm_opt.ul_ec_round);
ul_idx_t *uu = gen_ul_idx_t(uopt, sg, 0, 0);///record contained reads; is_el = is_del = 0
init_uldat_t(&sl, NULL, NULL, &opt, CHUNK_SIZE, asm_opt.thread_num, uopt, uu); sl.rg = sg;
if(work_ul_gchains(&sl)) {
@@ -10738,7 +11128,7 @@ ma_ug_t *ul_realignment(const ug_opt_t *uopt, asg_t *sg, uint32_t double_check_c
init_aux_table(); ha_opt_update_cov(&asm_opt, asm_opt.hom_cov);
cutoff = REA_ALIGN_CUTOFF;
init_mg_opt(&opt, !(asm_opt.flag&HA_F_NO_HPC), 19, 10, cutoff, asm_opt.max_n_chain, asm_opt.ul_error_rate, asm_opt.ul_error_rate, asm_opt.ul_error_rate_low, asm_opt.ul_ec_round);
init_mg_opt(&opt, !(asm_opt.flag&HA_F_NO_HPC), 19, 10, cutoff, asm_opt.max_n_chain, asm_opt.ul_error_rate, asm_opt.ul_error_rate, asm_opt.ul_error_rate_low, asm_opt.ul_error_rate_hpc, asm_opt.ul_ec_round);
init_uldat_t(&sl, NULL, NULL, &opt, CHUNK_SIZE, asm_opt.thread_num, uopt, NULL);
ma_ug_t *ug = gen_polished_ug(uopt, sg);
// dd_ug(sg, ug, uopt->coverage_cut, uopt->sources, uopt->ruIndex, "UL.sa");

2
inter.h
View File

@@ -26,7 +26,7 @@ typedef struct {
int min_gc_cnt, min_gc_score, sub_diff, best_n;
float chn_pen_gap, mask_level, pri_ratio;
///base-alignment
double bw_thres, diff_ec_ul, diff_ec_ul_low; int max_n_chain, ec_ul_round;
double bw_thres, diff_ec_ul, diff_ec_ul_low, diff_ec_ul_hpc; int max_n_chain, ec_ul_round;
} mg_idxopt_t;
struct mg_tbuf_s {

9
main.cpp
View File

@@ -12,6 +12,15 @@ int main(int argc, char *argv[])
yak_reset_realtime();
init_opt(&asm_opt);
if (!CommandLine_process(argc, argv, &asm_opt)) return 0;
// fprintf(stderr, "[M::%s::] ed_global::%d, ed_global_128bit::%d\n", __func__,
// ed_band_cal_global((char *)"ACT", 3, (char *)"AAT", 3, 1),
// ed_band_cal_global_128bit((char *)"ACT", 3, (char *)"AAT", 3, 1));
// fprintf(stderr, "[M::%s::] ed_global::%d, ed_global_128bit::%d\n", __func__,
// ed_band_cal_global((char*)"ACTTTTTT", 8, (char*)"AATTTT", 6, 3),
// ed_band_cal_global_128bit((char*)"ACTTTTTT", 8, (char*)"AATTTT", 6, 3));
// exit(1);
ret = ha_assemble();
destory_opt(&asm_opt);
fprintf(stderr, "[M::%s] Version: %s\n", __func__, HA_VERSION);