static int
gen_subalg( FILE *fp )
{
ALG A;
VECTORS v;
int err;
char outf[NAME_LEN_LIMIT+1];
print_spopen("Generating a subpower.");
A.func= (FUNCT *)NULL;
v.list= (VEC *)NULL;
if( (err = get_next_line(name, NAME_LEN_LIMIT, fp)) != NO_ERROR) {
goto WLe_gen_subalg;
}
err= ps_alg(name, &A);
if(err!= NO_ERROR)
{
hlp_gen_subalg();
goto WLe_gen_subalg;
}
if( (err = get_next_line(name, NAME_LEN_LIMIT, fp)) != NO_ERROR) {
goto WLe_gen_subalg;
}
err = ps_vectors(name, &v, A.size);
if(err!= NO_ERROR)
{
hlp_gen_subalg();
goto WLe_gen_subalg;
}
if( (err = get_next_line(name, NAME_LEN_LIMIT, fp)) != NO_ERROR) {
goto WLe_gen_subalg;
}
err=ps_out(name, outf);
if(err != NO_ERROR)
{
hlp_gen_subalg();
hlp_vector_file();
goto WLe_gen_subalg;
}
err= spf(&A, &v, NULL, NULL, NULL);
if(err!= NO_ERROR)
{
goto WLe_gen_subalg;
}
err = wr_vectors(outf, &v);
if(err!= NO_ERROR)
{
goto WLe_gen_subalg;
}
free_alg(&A);
free_vectors(&v);
print_spclose("End of generating a subpower.");
return(NO_ERROR);
WLe_gen_subalg:
free_alg(&A);
free_vectors(&v);
return(err);
}
static void *correct_thread(void *data) {
correct_aux_t *d = (correct_aux_t*) data;
int i = 0;
bwa_seq_t *s = NULL, *query = NULL, *seqs = d->ht->seqs;
readarray *low_kmer_reads = d->low_kmer_reads;
alignarray *aligns = NULL;
aligns = g_ptr_array_sized_new(N_DEFAULT_ALIGNS);
for (i = d->start; i < d->end; i++) {
if (i % 10000 == 0)
show_msg(__func__,
"Thread %d correction progress: [%d,%d,%d]... \n", d->tid,
d->start, i, d->end);
s = g_ptr_array_index(low_kmer_reads, i);
if (is_repetitive_q(s)) {
s->status = USED;
continue;
}
// Only the fresh reads, or the reads tried once would be corrected.
if (s->status != FRESH)
continue;
query = new_seq(s, s->len - 8, 0);
pe_aln_query(s, s->seq, d->ht, MISMATCHES, s->len, 0, aligns);
pe_aln_query(s, s->rseq, d->ht, MISMATCHES, s->len, 1, aligns);
if (aligns->len >= 4)
correct_bases(seqs, s, aligns, d->tid);
s->status = TRIED;
reset_alg(aligns);
bwa_free_read_seq(1, query);
//if (i > 10000)
// break;
}
free_alg(aligns);
show_msg(__func__, "Thread %d finished. \n", d->tid);
}
static int
cr_fact_alg( FILE *fp )
{
ALG A;
ALG F;
PART cong;
int err;
char outf[NAME_LEN_LIMIT+1];
A.func= NULL;
F.func= NULL;
cong.func= NULL;
print_spopen("Creating factor algebra.");
if( (err = get_next_line(name, NAME_LEN_LIMIT, fp)) != NO_ERROR) {
goto WLe_cr_fact_alg;
}
err= ps_alg(name, &A);
if(err!= NO_ERROR)
{
hlp_cr_fact_alg();
goto WLe_cr_fact_alg;
}
if( (err = get_next_line(name, NAME_LEN_LIMIT, fp)) != NO_ERROR) {
goto WLe_cr_fact_alg;
}
err = ps_cong(name, &cong, A.size);
if(err != NO_ERROR) {
hlp_cr_fact_alg();
goto WLe_cr_fact_alg;
}
if( (err = get_next_line(name, NAME_LEN_LIMIT, fp)) != NO_ERROR) {
goto WLe_cr_fact_alg;
}
err=ps_out(name, outf);
if(err != NO_ERROR)
{
hlp_cr_fact_alg();
hlp_alg_file();
goto WLe_cr_fact_alg;
}
err= factor_alg(&A, cong.func, &F );
if(err!= NO_ERROR)
{
goto WLe_cr_fact_alg;
}
err = wr_alg(outf, &F);
if(err!= NO_ERROR)
{
goto WLe_cr_fact_alg;
}
free_alg(&A);
free_alg(&F);
if(cong.func!=NULL) free((void *)(cong.func));
print_spclose("End of creating factor algebra.");
return(NO_ERROR);
WLe_cr_fact_alg:
free_alg(&A);
free_alg(&F);
if(cong.func!=NULL) free((void *)(cong.func));
return(err);
}
static int
cr_dir_prod( FILE *fp )
{
ALG *algs;
ALG P;
VECTORS v;
int i, err, errf;
char outf[NAME_LEN_LIMIT+1];
char outuni[NAME_LEN_LIMIT+1];
errf=NO_ERROR;
print_spopen("Creating a direct product.");
v.list= (VEC *)NULL;
P.func=NULL;
algs=NULL;
/* These lines for free_ to work properly */
if( (err = get_next_line(name, NAME_LEN_LIMIT, fp)) != NO_ERROR) {
errf=ERROR;
goto WLe_dir_prod;
}
err = ps_number(name, 0, PROD_LIMIT-1, &(v.lvecs));
if(err!= NO_ERROR)
{
errf=ERROR;
hlp_dir_prod();
goto WLe_dir_prod;
}
v.nvecs=0; /* unnecessary */
/* allocate room for algebras */
algs= (ALG *)(calloc(v.lvecs,sizeof(ALG)));
if(algs== NULL) {
print_derr("Not enough memory to store algebras.");
errf=ERROR;
hlp_dir_prod();
goto WLe_dir_prod;
}
for(i=0; i<v.lvecs; i++) {
(algs[i]).func= (FUNCT *)NULL;
}
for(i=0; i<v.lvecs; i++) {
if( (err = get_next_line(name, NAME_LEN_LIMIT, fp)) != NO_ERROR) {
errf=ERROR;
goto WLe_dir_prod;
}
err= ps_alg(name, &(algs[i]));
if(err!= NO_ERROR)
{
errf=ERROR;
print_nerr("%d algebra description lines needed.", v.lvecs);
hlp_dir_prod();
goto WLe_dir_prod;
}
}
if( (err = get_next_line(name, NAME_LEN_LIMIT, fp)) != NO_ERROR) {
errf=ERROR;
goto WLe_dir_prod;
}
err=ps_out(name, outf);
if(err != NO_ERROR)
{
errf=ERROR;
print_nerr("%d algebra lines and two output lines needed.", v.lvecs);
hlp_dir_prod();
hlp_alg_file();
goto WLe_dir_prod;
}
if( (err = get_next_line(name, NAME_LEN_LIMIT, fp)) != NO_ERROR) {
errf=ERROR;
goto WLe_dir_prod;
}
err=ps_out(name, outuni);
if(err != NO_ERROR)
{
errf=ERROR;
print_nerr("%d algebra lines and two output lines needed.", v.lvecs);
hlp_dir_prod();
hlp_vector_file();
goto WLe_dir_prod;
}
err= sub_prod_alg(algs, &v, &P);
if(err!= NO_ERROR)
{
errf=ERROR;
goto WLe_dir_prod;
}
err = wr_alg(outf, &P);
if(err!= NO_ERROR)
{
errf=ERROR;
goto WLe_dir_prod;
}
err = wr_vectors(outuni, &v);
if(err!= NO_ERROR)
{
errf=ERROR;
goto WLe_dir_prod;
}
WLe_dir_prod:
if(algs!=NULL) {
for(i=0; i<v.lvecs; i++) {
free_alg(&(algs[i]));
}
free((void *)algs);
}
free_alg(&P);
free_vectors(&v);
if(errf==NO_ERROR) {
print_spclose("End of creating a direct product.");
}
return(errf);
}
static int
cr_subpr_alg( FILE *fp )
{
ALG *algs;
ALG P;
VECTORS v;
int i, err, errf;
char outf[NAME_LEN_LIMIT+1];
int *sizes;
errf=NO_ERROR;
print_spopen("Creating an algebra in a subproduct.");
v.list= (VEC *)NULL;
P.func=NULL;
sizes=NULL;
algs=NULL;
/* These lines for free_ to work properly */
if( (err = get_next_line(name, NAME_LEN_LIMIT, fp)) != NO_ERROR) {
errf=ERROR;
goto WLe_cr_subpr_alg;
}
err = ps_vectors(name, &v, ALG_SIZE_LIMIT); /* must have a third arg. */
if(err!= NO_ERROR)
{
errf=ERROR;
hlp_cr_subpr_alg();
goto WLe_cr_subpr_alg;
}
if(v.lvecs>=PROD_LIMIT)
{
print_derr("Illegal number %d of components (should be at most %d).",
v.lvecs, PROD_LIMIT-1 );
errf=ERROR;
goto WLe_cr_subpr_alg;
}
if(v.nvecs == 0)
{
print_dpres("The universe of this algebra is empty, it cannot be created.");
errf=ERROR;
goto WLe_cr_subpr_alg;
}
/* allocate room for algebras */
algs= (ALG *)(calloc(v.lvecs,sizeof(ALG)));
if(algs== NULL) {
print_derr("Not enough memory to store algebras.");
errf=ERROR;
hlp_cr_subpr_alg();
goto WLe_cr_subpr_alg;
}
for(i=0; i<v.lvecs; i++) {
(algs[i]).func= (FUNCT *)NULL;
}
for(i=0; i<v.lvecs; i++) {
if( (err = get_next_line(name, NAME_LEN_LIMIT, fp)) != NO_ERROR) {
errf=ERROR;
goto WLe_cr_subpr_alg;
}
err= ps_alg(name, &(algs[i]));
if(err!= NO_ERROR)
{
errf=ERROR;
print_nerr("%d algebra description lines needed.", v.lvecs);
hlp_cr_subpr_alg();
goto WLe_cr_subpr_alg;
}
}
/* algebras read, now check vector entries */
sizes= (int *) (calloc(v.lvecs,sizeof(int)));
if(sizes== NULL) {
print_derr("Not enough memory to check vector entries.");
errf=ERROR;
hlp_cr_subpr_alg();
goto WLe_cr_subpr_alg;
}
for(i=0; i<v.lvecs; i++) {
sizes[i]=(algs[i]).size;
}
err=check_vectors(&v,sizes);
if(err!= NO_ERROR)
{
errf=ERROR;
goto WLe_cr_subpr_alg;
}
if( (err = get_next_line(name, NAME_LEN_LIMIT, fp)) != NO_ERROR) {
errf=ERROR;
goto WLe_cr_subpr_alg;
}
err=ps_out(name, outf);
if(err != NO_ERROR)
{
errf=ERROR;
print_nerr("%d algebra lines and an output line needed.", v.lvecs);
hlp_cr_subpr_alg();
hlp_alg_file();
goto WLe_cr_subpr_alg;
}
err= sub_prod_alg(algs, &v, &P);
if(err!= NO_ERROR)
{
errf=ERROR;
goto WLe_cr_subpr_alg;
}
err = wr_alg(outf, &P);
if(err!= NO_ERROR)
{
errf=ERROR;
goto WLe_cr_subpr_alg;
}
WLe_cr_subpr_alg:
if(sizes!=NULL) free((void *)sizes);
if(algs!=NULL) {
for(i=0; i<v.lvecs; i++) {
free_alg(&(algs[i]));
}
free((void *)algs);
}
free_alg(&P);
free_vectors(&v);
if(errf==NO_ERROR) {
print_spclose("End of creating an algebra in a subproduct.");
}
return(errf);
}
