Sequence* free_Alignment ( Alignment *LA)
{
/* Does not free the A->S field (sequences of A)*/
Sequence *S;
//aln_stack checks the alignment has not already been freed
if ( LA==NULL || !aln_stack(LA,FREE_ALN)){return NULL;}
S=LA->S;
free_char ( LA->file, -1);
free_char ( LA->seq_al, -1);
free_int ( LA->seq_cache, -1);
free_int ( LA->cdna_cache, -1);
free_char ( LA->name,-1);
free_char ( LA->tree_order,-1);
vfree ( LA->generic_comment);
free_char ( LA->seq_comment, -1);
free_char ( LA->aln_comment, -1);
free_int ( LA->order, -1);
vfree ( LA->score_seq);
vfree ( LA->len);
free_profile (LA->P);
if ( LA->A){free_Alignment (LA->A);LA->A=NULL;}
vfree ( LA);
return S;
}
Distance_matrix * free_distance_matrix ( Distance_matrix *DM)
{
if (!DM)return NULL;
free_int ( DM->similarity_matrix,-1);
free_int ( DM->distance_matrix,-1);
free_int ( DM->score_similarity_matrix,-1);
vfree (DM);
return NULL;
}
Profile * free_profile ( Profile *P)
{
if (!P) return NULL;
else
{
vfree (P->alphabet);
free_int ( P->count, -1);
free_int ( P->count2, -1);
vfree (P);
}
return NULL;
}
Constraint_list* free_dp_model (Dp_Model *D)
{
Constraint_list *CL;
if ( !D)return NULL;
CL=D->CL;
vfree (D->diag);
free_int (D->model, -1);
free_int (D->model_properties, -1);
free_int (D->bounded_model, -1);
vfree (D);
return CL;
}
Alignment *free_data_in_aln (Alignment *A)
{
//Frees only the sequence data (keeps profile information)
A->seq_al=free_char (A->seq_al, -1);
A->seq_comment=free_char (A->seq_comment, -1);
A->aln_comment=free_char (A->aln_comment, -1);
A->name=free_char (A->name, -1);
A->expanded_order=free_char (A->expanded_order, -1);
A->order=free_int (A->order, -1);
A->seq_cache=free_int (A->seq_cache, -1);
A->cdna_cache=free_int (A->cdna_cache, -1);
A->score_res=free_int (A->score_res, -1);
free_sequence (A->S, -1);
A->S=NULL;
return A;
}
/**
rimuove ogni file descriptor watched da un'instanza di inotify
Da notare come files e watch_fds devono essere della stessa lunghezza!
\param inotify istanza di inotify_t a cui rimuovere tutti i file descriptors
*/
void rm_all_watches(inotify_t inotify) {
for (int i=0; i<inotify.watch_fds.size; i++)
if (inotify_rm_watch(inotify.instance, inotify.watch_fds.buf[i])==-1) {
perror("inotify_rm_watch");
exit(EXIT_FAILURE);
}
free_int(&inotify.watch_fds);
free_str(&inotify.files);
}
Constraint_list *free_constraint_list4lib_computation (Constraint_list *CL)
{
if (!CL)return NULL;
free_arrayN(CL->residue_index, 3);
free_int (CL->M, -1);
vfree (CL);
return CL;
}
int fasta_gotoh_pair_wise (Alignment *A,int*ns, int **l_s,Constraint_list *CL)
{
/*TREATMENT OF THE TERMINAL GAP PENALTIES*/
/*TG_MODE=0---> gop and gep*/
/*TG_MODE=1---> --- gep*/
/*TG_MODE=2---> --- ---*/
int maximise;
/*VARIABLES FOR THE MULTIPLE SEQUENCE ALIGNMENT*/
int **tot_diag;
int *diag;
int ktup;
float diagonal_threshold;
static int n_groups;
static char **group_list;
int score;
/********Prepare Penalties******/
maximise=CL->maximise;
ktup=CL->ktup;
diagonal_threshold=CL->diagonal_threshold;
/********************************/
if ( !group_list)
{
group_list=make_group_aa (&n_groups, CL->matrix_for_aa_group);
}
tot_diag=evaluate_diagonals ( A, ns, l_s, CL, maximise,n_groups,group_list, ktup);
if ( !CL->fasta_step)
{
diag=flag_diagonals (strlen(A->seq_al[l_s[0][0]]),strlen(A->seq_al[l_s[1][0]]), tot_diag,diagonal_threshold,0);
}
else
{
diag=extract_N_diag (strlen (A->seq_al[l_s[0][0]]),strlen (A->seq_al[l_s[1][0]]), tot_diag,CL->fasta_step,0);
}
score=make_fasta_gotoh_pair_wise ( A, ns, l_s, CL, diag);
free_int (tot_diag, -1);
vfree (diag);
return score;
}
int fasta_cdna_pair_wise (Alignment *A,int*ns, int **l_s,Constraint_list *CL)
{
/*TREATMENT OF THE TERMINAL GAP PENALTIES*/
/*TG_MODE=0---> gop and gep*/
/*TG_MODE=1---> --- gep*/
/*TG_MODE=2---> --- ---*/
int maximise;
int l0, l1;
/*VARIABLES FOR THE MULTIPLE SEQUENCE ALIGNMENT*/
int **tot_diag;
int *diag;
int ktup;
static int n_groups;
static char **group_list;
int score;
Alignment *B;
/********Prepare Penalties******/
maximise=CL->maximise;
ktup=CL->ktup;
/********************************/
if ( !group_list)
{
group_list=make_group_aa (&n_groups, CL->matrix_for_aa_group);
}
B=dna_aln2_3frame_cdna_aln(A, ns, l_s);
B->nseq=6;
l0=strlen ( B->seq_al[0]);
l1=strlen ( B->seq_al[3]);
tot_diag=evaluate_diagonals_cdna( B, ns, l_s, CL, maximise,n_groups,group_list, ktup);
diag=extract_N_diag (l0, l1, tot_diag,20,1);
score=make_fasta_cdna_pair_wise ( A,B, ns, l_s, CL, diag);
free_aln(B);
free_int (tot_diag, -1);
vfree (diag);
return score;
}
int get_starting_point ( Constraint_list *CL)
{
int a;
int l;
int **seq;
int start;
int *entry=NULL;
l=strlen ( (CL->S)->seq[0]);
seq=declare_int ( l, 2);
while (entry=extract_entry (CL))
{
seq[entry[R1]][1]=entry[R1];
seq[entry[R2]][1]=entry[R2];
if ((CL->moca) && (CL->moca)->forbiden_residues && ((CL->moca)->forbiden_residues[0][entry[R1]]==UNDEFINED||(CL->moca)->forbiden_residues[0][entry[R2]]==UNDEFINED ))continue;
else
{
seq[entry[R1]][0]+=entry[MISC];
seq[entry[R2]][0]+=entry[MISC];
}
}
sort_int_inv ( seq, 2, 0, 0, l-1);
fprintf ( stderr, "\nStart=%d %d", seq[0][1], seq[0][0]);
start=seq[0][1];
free_int ( seq, -1);
return start;
}
int very_fast_gotoh_pair_wise (Alignment *A,int*ns, int **l_s,Constraint_list *CL)
{
/*TREATMENT OF THE TERMINAL GAP PENALTIES*/
/*TG_MODE=0---> gop and gep*/
/*TG_MODE=1---> --- gep*/
/*TG_MODE=2---> --- ---*/
int maximise;
/*VARIABLES FOR THE MULTIPLE SEQUENCE ALIGNMENT*/
int **tot_diag;
int *diag;
int ktup;
static int n_groups;
static char **group_list;
int score;
/********Prepare Penalties******/
maximise=CL->maximise;
ktup=CL->ktup;
/********************************/
if ( !group_list)
{
group_list=make_group_aa (&n_groups, CL->matrix_for_aa_group);
}
CL->use_fragments=0;
tot_diag=evaluate_diagonals ( A, ns, l_s, CL, maximise,n_groups,group_list, ktup);
/*Note: 20 diagonals. 5 shadows on each side: tunned on Hom39, 2/2/04 */
diag=extract_N_diag (strlen (A->seq_al[l_s[0][0]]),strlen (A->seq_al[l_s[1][0]]), tot_diag,20,5);
score=make_fasta_gotoh_pair_wise ( A, ns, l_s, CL, diag);
free_int (tot_diag, -1);
vfree (diag);
return score;
}
void free_sequence ( Sequence *LS, int nseq)
{
if ( !LS) return;
free_char ( LS->file, -1);
free_char ( LS->seq_comment, -1);
free_char ( LS->aln_comment, -1);
free_char ( LS->seq, -1);
free_char ( LS->name,-1);
free_int (LS->dc, -1);
free_arrayN((void*)LS->T, 2);
vfree (LS->type);
vfree (LS->len);
free_weights (LS->W);
//Don't free LS->blastdb;
vfree (LS);
}
int cfasta_gotoh_pair_wise (Alignment *A,int*ns, int **l_s,Constraint_list *CL)
{
/*TREATMENT OF THE TERMINAL GAP PENALTIES*/
/*TG_MODE=0---> gop and gep*/
/*TG_MODE=1---> --- gep*/
/*TG_MODE=2---> --- ---*/
int maximise;
/*VARIABLES FOR THE MULTIPLE SEQUENCE ALIGNMENT*/
int **tot_diag;
int *diag;
int ktup;
static int n_groups;
static char **group_list;
int score, new_score;
int n_chosen_diag=20;
int step;
int max_n_chosen_diag;
int l1, l2;
/********Prepare Penalties******/
maximise=CL->maximise;
ktup=CL->ktup;
/********************************/
if ( !group_list)
{
group_list=make_group_aa (&n_groups, CL->matrix_for_aa_group);
}
l1=strlen (A->seq_al[l_s[0][0]]);
l2=strlen (A->seq_al[l_s[1][0]]);
if ( !CL->fasta_step)
{
step=MIN(l1,l2);
step=(int) log ((double)MAX(step, 1));
step=MAX(step, 20);
}
else
{
step=CL->fasta_step;
}
tot_diag=evaluate_diagonals ( A, ns, l_s, CL, maximise,n_groups,group_list, ktup);
max_n_chosen_diag=strlen (A->seq_al[l_s[0][0]])+strlen (A->seq_al[l_s[1][0]])-1;
/*max_n_chosen_diag=(int)log10((double)(l1+l2))*10;*/
n_chosen_diag+=step;
n_chosen_diag=MIN(n_chosen_diag, max_n_chosen_diag);
diag=extract_N_diag (strlen (A->seq_al[l_s[0][0]]),strlen (A->seq_al[l_s[1][0]]), tot_diag, n_chosen_diag, 0);
score =make_fasta_gotoh_pair_wise ( A, ns, l_s, CL, diag);
new_score=0;
vfree ( diag);
while (new_score!=score && n_chosen_diag< max_n_chosen_diag )
{
score=new_score;
ungap_sub_aln ( A, ns[0], l_s[0]);
ungap_sub_aln ( A, ns[1], l_s[1]);
n_chosen_diag+=step;
n_chosen_diag=MIN(n_chosen_diag, max_n_chosen_diag);
diag =extract_N_diag (strlen (A->seq_al[l_s[0][0]]),strlen (A->seq_al[l_s[1][0]]), tot_diag, n_chosen_diag, 0);
new_score=make_fasta_gotoh_pair_wise ( A, ns, l_s, CL, diag);
vfree ( diag);
}
score=new_score;
free_int (tot_diag, -1);
return score;
}
int make_fasta_cdna_pair_wise (Alignment *B,Alignment *A,int*in_ns, int **l_s,Constraint_list *CL, int *diag)
{
int a,c,p,k;
Dp_Result *DPR;
static Dp_Model *M;
int l0, l1;
int len_i, len_j;
int f0=0, f1=0;
int deltaf0, deltaf1, delta;
int nr1, nr2;
int ala, alb, aa0, aa1;
int type;
char **al;
int **tl_s;
int *tns;
/*DEBUG*/
int debug_cdna_fasta=0;
Alignment *DA;
int score;
int state,prev_state;
int t, e;
int a1, a2;
l0=strlen ( B->seq_al[l_s[0][0]]);
l1=strlen ( B->seq_al[l_s[1][0]]);
al=declare_char (2, l0+l1+1);
B=realloc_aln2 (B,B->nseq,l0+l1+1);
free_int (B->cdna_cache, -1);
B->cdna_cache=declare_int(1, l0+l1+1);
if ( !M)M=initialize_dna_dp_model (CL);
M->diag=diag;
tl_s=declare_int (2, 2);tns=vcalloc(2, sizeof(int));tl_s[0][0]=0;tl_s[1][0]=3;tns[0]=tns[1]=1;
DPR=make_fast_dp_pair_wise (A,tns, tl_s,CL,M);
vfree(tns);free_int(tl_s, -1);
/*new_trace_back*/
a=p=0;
aa0=aa1=ala=alb=0;
while ( (k=DPR->traceback[a++])!=M->START);
while ( (k=DPR->traceback[a++])!=M->END)
{
f0=M->model_properties[k][M->F0];
f1=M->model_properties[k][M->F1];
len_i=M->model_properties[k][M->LEN_I];
len_j=M->model_properties[k][M->LEN_J];
type=M->model_properties[k][M->TYPE];
if (type==M->CODING0)
{
deltaf0=(aa0*3+f0)-ala;
deltaf1=(aa1*3+f1)-alb;
delta=MAX(deltaf0, deltaf1);
for (nr1=0, nr2=0,c=0; c<delta; c++, nr1++, nr2++,p++)
{
if (nr1<deltaf0 && ala<l0)al[0][p]=B->seq_al[l_s[0][0]][ala++];
else al[0][p]='-';
if (nr2<deltaf1 && alb<l1)al[1][p]=B->seq_al[l_s[1][0]][alb++];
else al[1][p]='-';
B->cdna_cache[0][p]=M->NON_CODING;
if ( is_gap(al[1][p]) && is_gap(al[0][p]))p--;
else if ( debug_cdna_fasta)fprintf (stderr, "\nUM: %c %c", al[0][p], al[1][p]);
}
for ( c=0; c< 3; c++, p++)
{
if ( c==0)B->cdna_cache[0][p]=M->CODING0;
else if ( c==1)B->cdna_cache[0][p]=M->CODING1;
else if ( c==2)B->cdna_cache[0][p]=M->CODING2;
if (ala<l0)al[0][p]=B->seq_al[l_s[0][0]][ala++];
else al[0][p]='-';
if (alb<l1)al[1][p]=B->seq_al[l_s[1][0]][alb++];
else al[1][p]='-';
if ( is_gap(al[1][p]) && is_gap(al[0][p]))p--;
else if ( debug_cdna_fasta)fprintf (stderr, "\n%d: %c %c",k, al[0][p], al[1][p]);
}
}
aa0+=len_i;
aa1+=len_j;
}
deltaf0=(aa0*3+f0)-ala;
deltaf1=(aa1*3+f1)-alb;
delta=MAX(deltaf0, deltaf1);
for (nr1=0, nr2=0,c=0; c<delta; c++, nr1++, nr2++,p++)
{
if (nr1<deltaf0 && ala<l0)al[0][p]=B->seq_al[l_s[0][0]][ala++];
else al[0][p]='-';
if (nr2<deltaf1 && alb<l1)al[1][p]=B->seq_al[l_s[1][0]][alb++];
else al[1][p]='-';
B->cdna_cache[0][p]=M->NON_CODING;
if ( is_gap(al[1][p]) && is_gap(al[0][p]))p--;
else if ( debug_cdna_fasta)fprintf (stderr, "\nUM: %c %c", al[0][p], al[1][p]);
}
/*End New traceback*/
al[0][p]='\0';
al[1][p]='\0';
sprintf( B->seq_al[l_s[0][0]], "%s", al[0]);
sprintf( B->seq_al[l_s[1][0]], "%s", al[1]);
B->len_aln=strlen (al[0]);
B->nseq=2;
if ( debug_cdna_fasta)
{
fprintf ( stderr, "\nA-A=%d, %d", CL->M['a'-'A']['a'-'A'], CL->M['a'-'A']['a'-'A'] *SCORE_K);
for ( a=1; a<diag[0]; a++)
{
fprintf ( stderr, "\nchosen diag: %d", diag[a]);
}
fprintf ( stderr, "\n GOP=%d GEP=%d TG_MODE=%d", M->gop, M->gep, M->TG_MODE);
fprintf ( stderr, "\nF_GOP=%d F_GEP=%d F_TG_MODE=%d", M->gop, M->gep, M->F_TG_MODE);
DA=copy_aln (B, NULL);
DA=realloc_aln2 (DA,6,(DA->len_aln+1));
for ( a=0; a<B->len_aln; a++)
{
fprintf ( stderr, "\n%d", DA->cdna_cache[0][a]);
if (DA->cdna_cache[0][a]>=M->CODING0)DA->seq_al[DA->nseq][a]=DA->cdna_cache[0][a]-M->nstate+'0';
else DA->seq_al[DA->nseq][a]=DA->cdna_cache[0][a]-M->nstate+'0';
if (DA->cdna_cache[0][a]==M->CODING0)
{
DA->seq_al[DA->nseq+1][a]=translate_dna_codon (DA->seq_al[0]+a,'*');
DA->seq_al[DA->nseq+2][a]=translate_dna_codon (DA->seq_al[1]+a,'*');
}
else
{
DA->seq_al[DA->nseq+1][a]='-';
DA->seq_al[DA->nseq+2][a]='-';
}
}
DA->nseq+=3;
print_aln (DA);
free_aln(DA);
score=0;
for (prev_state=M->START,a=0; a< DA->len_aln;)
{
state=DA->cdna_cache[0][a];
t=M->model[prev_state][state];
if ( DA->cdna_cache[0][a]==M->CODING0)
{
a1=translate_dna_codon (A->seq_al[0]+a,'x');
a2=translate_dna_codon (A->seq_al[1]+a,'x');
if ( a1!='x' && a2!='x')
{
e=CL->M[a1-'A'][a2-'A']*SCORE_K;
}
}
else if ( DA->cdna_cache[0][a]>M->CODING0);
else
{
e=M->model_properties[B->cdna_cache[0][a]][M->EMISSION];
}
if ( e==UNDEFINED || t==UNDEFINED) fprintf ( stderr, "\nPROBLEM %d\n", a);
fprintf ( stderr, "\n[%c..%c: %d(e)+%d(t)=%d]", A->seq_al[0][a], A->seq_al[1][a], e,t,e+t);
score+=e+t;
prev_state=state;
if (B->cdna_cache[0][a]==M->NON_CODING)a++;
else a+=3;
}
}
for ( a=0; a<B->len_aln; a++)
{
if ( B->cdna_cache[0][a]<M->CODING0)B->cdna_cache[0][a]=0;
else B->cdna_cache[0][a]=1;
}
free_char ( al, -1);
return DPR->score;
}
int cfasta_cdna_pair_wise (Alignment *A,int*ns, int **l_s,Constraint_list *CL)
{
/*TREATMENT OF THE TERMINAL GAP PENALTIES*/
/*TG_MODE=0---> gop and gep*/
/*TG_MODE=1---> --- gep*/
/*TG_MODE=2---> --- ---*/
int maximise;
/*VARIABLES FOR THE MULTIPLE SEQUENCE ALIGNMENT*/
int **tot_diag;
int *diag;
int ktup;
static int n_groups;
static char **group_list;
int score, new_score;
int n_chosen_diag=0;
int step;
int max_n_chosen_diag;
int l0, l1;
Alignment *B;
/********Prepare Penalties******/
maximise=CL->maximise;
ktup=CL->ktup;
/********************************/
if ( !group_list)
{
group_list=make_group_aa (&n_groups, CL->matrix_for_aa_group);
}
B=dna_aln2_3frame_cdna_aln(A, ns, l_s);
l0=strlen(B->seq_al[0]);
l1=strlen(B->seq_al[3]);
tot_diag=evaluate_diagonals_cdna ( B, ns, l_s, CL, maximise,n_groups,group_list, ktup);
max_n_chosen_diag=100;
n_chosen_diag=step=10 ;
n_chosen_diag=MIN(n_chosen_diag, max_n_chosen_diag);
diag=extract_N_diag (l0,l1, tot_diag, n_chosen_diag,2);
score =make_fasta_cdna_pair_wise ( A,B, ns, l_s, CL, diag);
new_score=0;
vfree ( diag);
while (new_score!=score && n_chosen_diag< max_n_chosen_diag )
{
score=new_score;
ungap_sub_aln ( A, ns[0], l_s[0]);
ungap_sub_aln ( A, ns[1], l_s[1]);
n_chosen_diag+=step;
n_chosen_diag=MIN(n_chosen_diag, max_n_chosen_diag);
diag =extract_N_diag (l0,l1, tot_diag, n_chosen_diag,3);
new_score=make_fasta_cdna_pair_wise ( A, B,ns, l_s, CL, diag);
vfree ( diag);
}
score=new_score;
free_int (tot_diag, -1);
free_aln(B);
return score;
}
void free(void* p) {
free_int(p,cur_heap);
}
Dp_Result * make_fast_generic_dp_pair_wise (Alignment *A, int*ns, int **l_s,Dp_Model *M)
{
/*SIZE VARIABLES*/
int ndiag;
int l0, l1, len_al,len_diag;
static int max_len_al, max_len_diag;
static int mI, mJ;
/*Evaluation*/
int **pos0;
/*DP VARIABLES*/
static int *Mat, *LMat, *trace;
int a, i, j,l;
int state, cur_state, prev_state;
int pos_i=0, pos_j=0;
int last_i=0, last_j=0;
int prev_i, prev_j;
int len_i, len_j, len;
int t, e, em;
int prev_score;
int pc, best_pc;
int *prev;
int model_index;
/*TRACEBACK*/
Dp_Result *DPR;
int k=0, next_k;
int new_i, new_j;
/*Cleqanning CALL*/
if ( A==NULL)
{
max_len_al=0; max_len_diag=0;mI=0;mJ=0;
vfree (Mat); vfree(LMat);vfree(trace);
Mat=trace=LMat=NULL;
return NULL;
}
ndiag=M->diag[0];
l0=strlen (A->seq_al[l_s[0][0]]);
l1=strlen (A->seq_al[l_s[1][0]]);
len_al =l0+l1+1;
len_diag=ndiag+4;
if ( (len_al>max_len_al || len_diag>max_len_diag))
{
vfree (Mat);
vfree (LMat);
vfree(trace);
max_len_diag=max_len_al=0;
}
if (max_len_al==0)
{
max_len_al=len_al;
max_len_diag=len_diag;
mI=max_len_al*max_len_diag;
mJ=max_len_diag;
Mat =(int*)vcalloc ( M->nstate*max_len_al*max_len_diag, sizeof (int));
LMat =(int*)vcalloc ( M->nstate*max_len_al*max_len_diag, sizeof (int));
trace=(int*)vcalloc ( M->nstate*max_len_al*max_len_diag, sizeof (int));
}
prev=(int*)vcalloc ( M->nstate, sizeof (int));
DPR=( Dp_Result*)vcalloc ( 1, sizeof ( Dp_Result));
DPR->traceback=(int*)vcalloc (max_len_al, sizeof (int));
/*PREPARE THE EVALUATION*/
pos0=aln2pos_simple ( A,-1, ns, l_s);
/*INITIALIZATION OF THE DP MATRICES*/
for (i=0; i<=l0;i++)
{
for (j=0; j<=ndiag+1;j++)
{
for ( state=0; state<M->nstate; state++)
{
Mat [state*mI+i*mJ+j]=UNDEFINED;
LMat [state*mI+i*mJ+j]=UNDEFINED;
trace [state*mI+i*mJ+j]=M->START;
}
}
}
M->diag[0]=1;
M->diag[ndiag+1]=M->diag[ndiag];
for (i=0; i<=l0; i++)
for ( j=0; j<=ndiag+1; j++)
{
pos_j=M->diag[j]-l0+i;
pos_i=i;
if (!(pos_j==0 || pos_i==0))continue;
if ( pos_j<0 || pos_i<0)continue;
if ( pos_i==0 && pos_j==0)
{
for ( a=0; a< M->nstate; a++)
{
Mat [a*mI+i*mJ+j]=0;
LMat [a*mI+i*mJ+j]=0;
trace[a*mI+i*mJ+j]=M->START;
}
}
else
{
l=MAX(pos_i,pos_j);
for ( state=0; state<M->START; state++)
{
if (pos_j==0 && M->model_properties[state][M->LEN_J])continue;
if (pos_i==0 && M->model_properties[state][M->LEN_I])continue;
t=M->model[M->START][state];
e=((M->model_emission_function)[state][M->START_EMISSION])(A, pos0, ns[0], l_s[0], pos_i-1, pos0, ns[1], l_s[1],pos_j-1,M->CL);
/*e=((M->get_dp_cost_list)[M->model_properties[state][M->START_EMISSION]])(A, pos0, ns[0], l_s[0], pos_i-1, pos0, ns[1], l_s[1],pos_j-1,M->CL);*/
Mat [state*mI+i*mJ+j]=t+e*l;
LMat [state*mI+i*mJ+j]=l;
trace [state*mI+i*mJ+j]=M->START;
}
}
}
/*DYNAMIC PROGRAMMING: Forward Pass*/
/*Diagonals:
M->diag[0]=Number of diagonals being considered
M->diag[1]=First diagonal being considered
Diagonals are numbered 1...L0+l1-1
1 is the bottom-left diag
*/
for (i=1; i<=l0;i++)
{
for (j=1; j<=ndiag;j++)
{
pos_j=M->diag[j]-l0+i;
pos_i=i;
if (pos_j<=0 || pos_j>l1 )continue;
last_i=i;
last_j=j;
for (cur_state=0; cur_state<M->START; cur_state++)
{
if (M->model_properties[cur_state][M->DELTA_J])
{
prev_j=j+M->model_properties[cur_state][M->DELTA_J];
prev_i=i+M->model_properties[cur_state][M->DELTA_I]*FABS((M->diag[j]-M->diag[prev_j]));
}
else
{
prev_j=j;
prev_i=i+M->model_properties[cur_state][M->DELTA_I];
}
len_i=FABS((i-prev_i));
len_j=FABS((M->diag[prev_j]-M->diag[j]));
len=MAX(len_i, len_j);
em=((M->model_emission_function[cur_state][M->EMISSION]))(A, pos0, ns[0], l_s[0], pos_i-1, pos0, ns[1], l_s[1],pos_j-1,M->CL);
/*em=((M->get_dp_cost_list)[M->model_properties[cur_state][M->EMISSION]])(A, pos0, ns[0], l_s[0], pos_i-1, pos0, ns[1], l_s[1],pos_j-1,M->CL);*/
for (pc=best_pc=UNDEFINED, model_index=1; model_index<=M->bounded_model[cur_state][0]; model_index++)
{
prev_state=M->bounded_model[cur_state][model_index];
if(prev_i<0 || prev_j<0 ||prev_i>l0 || prev_j>ndiag || len==UNDEFINED)prev_score=UNDEFINED;
else prev_score=Mat[prev_state*mI+prev_i*mJ+prev_j];
t=M->model[prev_state][cur_state];
e=em;
if (prev_score==UNDEFINED || len==UNDEFINED)e=UNDEFINED;
else if (len==0|| e==UNDEFINED)e=UNDEFINED;
else e=e*len;
if (is_defined_int(3,prev_score,e, t))
{
pc=prev_score+t+e;
}
else pc=UNDEFINED;
/*Identify the best previous score*/
if (best_pc==UNDEFINED || (pc>best_pc && pc!=UNDEFINED))
{
prev[cur_state]=prev_state;
best_pc=pc;
}
}
Mat[cur_state*mI+i*mJ+j]=best_pc;
if ( Mat[cur_state*mI+i*mJ+j]==UNDEFINED)
{
LMat[cur_state*mI+i*mJ+j]=UNDEFINED;
trace[cur_state*mI+i*mJ+j]=UNDEFINED;
continue;
}
else if ( prev[cur_state]==cur_state)
{
LMat [cur_state*mI+i*mJ+j]= LMat [cur_state*mI+prev_i*mJ+prev_j]+len;
trace[cur_state*mI+i*mJ+j]= trace[cur_state*mI+prev_i*mJ+prev_j];
}
else
{
LMat[cur_state*mI+i*mJ+j]=len;
trace[cur_state*mI+i*mJ+j]=prev[cur_state];
}
}
}
}
i=last_i;
j=last_j;
for (pc=best_pc=UNDEFINED, state=0; state<M->START; state++)
{
t=M->model[state][M->END];
e=( M->model_emission_function[state][M->TERM_EMISSION])(A, pos0, ns[0], l_s[0], pos_i-1, pos0, ns[1], l_s[1],pos_j-1,M->CL);
/*e=((M->get_dp_cost_list)[M->model_properties[state][M->TERM_EMISSION]])(A, pos0, ns[0], l_s[0], pos_i-1, pos0, ns[1], l_s[1],pos_j-1,M->CL);*/
l=LMat[state*mI+i*mJ+j];
if (!is_defined_int(4,t,e,Mat[state*mI+i*mJ+j],l))Mat[state*mI+i*mJ+j]=UNDEFINED;
else Mat[state*mI+i*mJ+j]+=t+e*(l);
pc=Mat[state*mI+i*mJ+j];
if (best_pc==UNDEFINED || (pc>best_pc && pc!=UNDEFINED))
{
k=state;
best_pc=pc;
}
}
DPR->score=best_pc;
/*TRACEBACK*/
e=0;
len=0;
while (k!=M->START)
{
next_k=trace[k*mI+i*mJ+j];
new_i=i;
new_j=j;
l=LMat[k*mI+i*mJ+j];
for (a=0; a< l; a++)
{
DPR->traceback[len++]=k;
}
new_i+=M->model_properties[k][M->DELTA_I]*l;
if ( M->model_properties[k][M->DELTA_J])
{
while ( next_k!=M->START && FABS((M->diag[j]-M->diag[new_j]))!=l)new_j+=M->model_properties[k][M->DELTA_J];
}
i=new_i;
j=new_j;
k=next_k;
}
DPR->len=len;
DPR->traceback[DPR->len++]=M->START;
invert_list_int (DPR->traceback,DPR->len);
DPR->traceback[DPR->len]=M->END;
vfree (prev);
free_int (pos0, -1);
return DPR;
}
Sequence *free_constraint_list (Constraint_list *CL)
{
Sequence *S;
int a, b;
Constraint_list *pCL;
/*Prepare the selective freeing of the CL data structure:
If the CL has been obtained from copy, every pointer that is identical to the parent CL (CL->pCL)
will not be saved.
*/
if ( !CL)return NULL;
else S=CL->S;
if ( CL->copy_mode==SOFT_COPY && !CL->pCL)
{vfree(CL); return S;}
else if ( CL->copy_mode==SOFT_COPY)
{
pCL=CL->pCL;
CL->residue_index=NULL;
if ( CL->M ==pCL->M )CL->M=NULL;
if (CL->start_index ==pCL->start_index )CL->start_index=NULL;
if (CL->end_index ==pCL->end_index )CL->end_index=NULL;
if ( CL->fp ==pCL->fp )CL->fp=NULL;
if ( CL->matrices_list ==pCL->matrices_list )CL->matrices_list=NULL;
if ( CL->STRUC_LIST ==pCL->STRUC_LIST )CL->STRUC_LIST=NULL;
if ( CL->W ==pCL->W )CL->W=NULL;
if ( CL->DM ==pCL->DM )CL->DM=NULL;
if ( CL->ktupDM ==pCL->ktupDM )CL->ktupDM=NULL;
if ( CL->translation ==pCL->translation )CL->translation=NULL;
if ( CL->moca ==pCL->moca )CL->moca=NULL;
if ( CL->Prot_Blast ==pCL->Prot_Blast )CL->Prot_Blast=NULL;
if ( CL->DNA_Blast ==pCL->DNA_Blast )CL->DNA_Blast=NULL;
if ( CL->Pdb_Blast ==pCL->Pdb_Blast )CL->Pdb_Blast=NULL;
if ( CL->seq_for_quadruplet ==pCL->seq_for_quadruplet )CL->seq_for_quadruplet=NULL;
if ( CL->TC ==pCL->TC )CL->TC=NULL;
}
/*End of selective freeing of the CL data structure*/
if ( CL->residue_index)free_arrayN(CL->residue_index, 3);
if ( CL->M)free_int (CL->M, -1);
if ( CL->fp)vfclose (CL->fp);
if ( CL->matrices_list)free_char(CL->matrices_list,-1);
if ( CL->start_index)free_int ( CL->start_index,-1);
if ( CL->end_index)free_int ( CL->end_index,-1);
if ( CL->STRUC_LIST)free_sequence ( CL->STRUC_LIST, (CL->STRUC_LIST)->nseq);
if ( CL->W)free_weights (CL->W);
CL->DM=free_distance_matrix (CL->DM);
CL->ktupDM=free_distance_matrix (CL->ktupDM);
if ( CL->translation)vfree(CL->translation);
if ( CL->moca)free_moca (CL->moca);
if ( CL->Prot_Blast)free_blast_param ( CL->Prot_Blast);
if ( CL->DNA_Blast) free_blast_param ( CL->DNA_Blast);
if ( CL->Pdb_Blast) free_blast_param ( CL->Pdb_Blast);
if ( CL->TC) free_TC_param ( CL->TC);
if (CL->seq_for_quadruplet)vfree (CL->seq_for_quadruplet);
vfree(CL);
return S;
}
int make_fasta_gotoh_pair_wise (Alignment *A,int*ns, int **l_s,Constraint_list *CL, int *diag)
{
/*TREATMENT OF THE TERMINAL GAP PENALTIES*/
/*TG_MODE=0---> gop and gep*/
/*TG_MODE=1---> --- gep*/
/*TG_MODE=2---> --- ---*/
int TG_MODE, gop, l_gop, gep,l_gep, maximise;
/*VARIABLES FOR THE MULTIPLE SEQUENCE ALIGNMENT*/
int a, b,c,k, t;
int l1, l2,eg, ch, sub,score=0, last_i=0, last_j=0, i, delta_i, j, pos_j, ala, alb, LEN, n_diag, match1, match2;
int su, in, de, tr;
int **C, **D, **I, **trace, **pos0, **LD;
int lenal[2], len;
char *buffer, *char_buf;
char **aln, **al;
/********Prepare Penalties******/
gop=CL->gop*SCORE_K;
gep=CL->gep*SCORE_K;
TG_MODE=CL->TG_MODE;
maximise=CL->maximise;
/********************************/
n_diag=diag[0];
l1=lenal[0]=strlen (A->seq_al[l_s[0][0]]);
l2=lenal[1]=strlen (A->seq_al[l_s[1][0]]);
if ( getenv ("DEBUG_TCOFFEE"))fprintf ( stderr, "\n\tNdiag=%d%% ", (diag[0]*100)/(l1+l2));
/*diag:
diag[1..n_diag]--> flaged diagonal in order;
diag[0]=0--> first diagonal;
diag[n_diag+1]=l1+l2-1;
*/
/*numeration of the diagonals strats from the bottom right [1...l1+l2-1]*/
/*sequence s1 is vertical and seq s2 is horizontal*/
/*D contains the best Deletion in S2==>comes from diagonal N+1*/
/*I contains the best insertion in S2=> comes from diagonal N-1*/
C=declare_int (lenal[0]+lenal[1]+1, n_diag+2);
D=declare_int (lenal[0]+lenal[1]+1, n_diag+2);
LD=declare_int (lenal[0]+lenal[1]+1, n_diag+2);
I=declare_int (lenal[0]+lenal[1]+1, n_diag+2);
trace=declare_int (lenal[0]+lenal[1]+1, n_diag+2);
al=declare_char (2,lenal[0]+lenal[1]+lenal[1]+1);
len= MAX(lenal[0],lenal[1])+1;
buffer=(char*)vcalloc ( 2*len, sizeof (char));
char_buf=(char*) vcalloc (2*len, sizeof (char));
pos0=aln2pos_simple ( A,-1, ns, l_s);
C[0][0]=0;
t=(TG_MODE==0)?gop:0;
for ( j=1; j<= n_diag; j++)
{
l_gop=(TG_MODE==0)?gop:0;
l_gep=(TG_MODE==2)?0:gep;
if ( (diag[j]-lenal[0])<0 )
{
trace[0][j]=UNDEFINED;
continue;
}
C[0][j]=(diag[j]-lenal[0])*l_gep +l_gop;
D[0][j]=(diag[j]-lenal[0])*l_gep +l_gop+gop;
}
D[0][j]=D[0][j-1]+gep;
t=(TG_MODE==0)?gop:0;
for ( i=1; i<=lenal[0]; i++)
{
l_gop=(TG_MODE==0)?gop:0;
l_gep=(TG_MODE==2)?0:gep;
C[i][0]=C[i][n_diag+1]=t=t+l_gep;
I[i][0]=D[i][n_diag+1]=t+ gop;
for ( j=1; j<=n_diag; j++)
{
C[i][j]=C[i][0];
D[i][j]=I[i][j]=I[i][0];
}
for (eg=0, j=1; j<=n_diag; j++)
{
pos_j=diag[j]-lenal[0]+i;
if (pos_j<=0 || pos_j>l2 )
{
trace[i][j]=UNDEFINED;
continue;
}
sub=(CL->get_dp_cost) ( A, pos0, ns[0], l_s[0], i-1, pos0, ns[1], l_s[1],pos_j-1, CL );
/*1 identify the best insertion in S2:*/
l_gop=(i==lenal[0])?((TG_MODE==0)?gop:0):gop;
l_gep=(i==lenal[0])?((TG_MODE==2)?0:gep):gep;
len=(j==1)?0:(diag[j]-diag[j-1]);
if ( a_better_than_b(I[i][j-1], C[i][j-1]+l_gop, maximise))eg++;
else eg=1;
I[i][j]=best_of_a_b (I[i][j-1], C[i][j-1]+l_gop, maximise)+len*l_gep;
/*2 Identify the best deletion in S2*/
l_gop=(pos_j==lenal[1])?((TG_MODE==0)?gop:0):gop;
l_gep=(pos_j==lenal[1])?((TG_MODE==2)?0:gep):gep;
len=(j==n_diag)?0:(diag[j+1]-diag[j]);
delta_i=((i-len)>0)?(i-len):0;
if ( a_better_than_b(D[delta_i][j+1],C[delta_i][j+1]+l_gop, maximise)){LD[i][j]=LD[delta_i][j+1]+1;}
else {LD[i][j]=1;}
D[i][j]=best_of_a_b (D[delta_i][j+1],C[delta_i][j+1]+l_gop, maximise)+len*l_gep;
/*Identify the best way*/
/*
score=C[i][j]=best_int ( 3, maximise, &fop, I[i][j], C[i-1][j]+sub, D[i][j]);
fop-=1;
if ( fop<0)trace[i][j]=fop*eg;
else if ( fop>0 ) {trace[i][j]=fop*LD[i][j];}
else if ( fop==0) trace[i][j]=0;
*/
su=C[i-1][j]+sub;
in=I[i][j];
de=D[i][j];
/*HERE ("%d %d %d", su, in, de);*/
if (su>=in && su>=de)
{
score=su;
tr=0;
}
else if (in>=de)
{
score=in;
tr=-eg;
}
else
{
score=de;
tr=LD[i][j];
}
trace[i][j]=tr;
C[i][j]=score;
last_i=i;
last_j=j;
}
}
/*
[0][Positive]
^ ^
| /
| /
| /
| /
|/
[Neg]<-------[*]
*/
i=last_i;
j=last_j;
ala=alb=0;
match1=match2=0;
while (!(match1==l1 && match2==l2))
{
if ( match1==l1)
{
len=l2-match2;
for ( a=0; a< len; a++)
{
al[0][ala++]=0;
al[1][alb++]=1;
match2++;
}
k=0;
break;
/*k=-(j-1);*/
}
else if ( match2==l2)
{
len=l1-match1;
for ( a=0; a< len; a++)
{
al[0][ala++]=1;
al[1][alb++]=0;
match1++;
}
k=0;
break;
/*k= n_diag-j;*/
}
else
{
k=trace[i][j];
}
if ( k==0)
{
if ( match2==l2 || match1==l1);
else
{
al[0][ala++]=1;
al[1][alb++]=1;
i--;
match1++;
match2++;
}
}
else if ( k>0)
{
len=diag[j+k]-diag[j];
for ( a=0; a<len; a++)
{
if ( match1==l1)break;
al[0][ala++]=1;
al[1][alb++]=0;
match1++;
}
i-=len;
j+=k;
}
else if ( k<0)
{
k*=-1;
len=diag[j]-diag[j-k];
for ( a=0; a<len; a++)
{
if ( match2==l2)break;
al[0][ala++]=0;
al[1][alb++]=1;
match2++;
}
j-=k;
}
}
LEN=ala;
c=LEN-1;
invert_list_char ( al[0], LEN);
invert_list_char ( al[1], LEN);
if ( A->declared_len<=LEN)A=realloc_aln2 ( A,A->max_n_seq, 2*LEN);
aln=A->seq_al;
for ( c=0; c< 2; c++)
{
for ( a=0; a< ns[c]; a++)
{
ch=0;
for ( b=0; b< LEN; b++)
{
if (al[c][b]==1)
char_buf[b]=aln[l_s[c][a]][ch++];
else
char_buf[b]='-';
}
char_buf[b]='\0';
aln[l_s[c][a]]=csprintf (aln[l_s[c][a]],"%s", char_buf);
}
}
A->len_aln=LEN;
A->nseq=ns[0]+ns[1];
free_int (pos0, -1);
free_int (C, -1);
free_int (D, -1);
free_int (I, -1);
free_int (trace, -1);
free_int (LD, -1);
free_char ( al, -1);
vfree(buffer);
vfree(char_buf);
return score;
}
Moca * free_moca ( Moca *m)
{
if ( m->forbiden_residues)free_int ( m->forbiden_residues, -1);
vfree ( m);
return NULL;
}
int myers_miller_pair_wise (Alignment *A,int *ns, int **ls,Constraint_list *CL )
{
int **pos;
int a,b, i, j, l,l1, l2, len;
int *S;
char ** char_buf;
int score;
/********Prepare Penalties******/
//ns2master_ns (ns,ls, &sns,&sls);
sns=ns;
sls=ls;
/********************************/
pos=aln2pos_simple ( A,-1, ns, ls);
l1=strlen (A->seq_al[ls[0][0]]);
l2=strlen (A->seq_al[ls[1][0]]);
S=(int*)vcalloc (l1+l2+1, sizeof (int));
last=0;
sapp=S;
score=diff (A,ns, ls, 0, l1, 0, l2, 0, 0, CL, pos);
diff (NULL,ns, ls, 0, l1, 0, l2, 0, 0, CL, pos);
i=0;
j=0;
sapp=S;
len=0;
while (!(i==l1 && j==l2))
{
if (*sapp==0) {
i++;
j++;
len++;
}
else if ( *sapp<0) {
i-=*sapp;
len-=*sapp;
}
else if ( *sapp>0) {
j+=*sapp;
len+=*sapp;
}
sapp++;
}
A=realloc_aln2 ( A,A->max_n_seq,len+1);
char_buf=declare_char (A->max_n_seq,len+1);
i=0;
j=0;
sapp=S;
len=0;
while (!(i==l1 && j==l2))
{
if (*sapp==0)
{
for (b=0; b< ns[0]; b++)
char_buf[ls[0][b]][len]=A->seq_al[ls[0][b]][i];
for (b=0; b< ns[1]; b++)
char_buf[ls[1][b]][len]=A->seq_al[ls[1][b]][j];
i++;
j++;
len++;
}
else if ( *sapp>0)
{
l=*sapp;
for ( a=0; a<l; a++, j++, len++)
{
for (b=0; b< ns[0]; b++)
char_buf[ls[0][b]][len]='-';
for (b=0; b< ns[1]; b++)
char_buf[ls[1][b]][len]=A->seq_al[ls[1][b]][j];
}
}
else if ( *sapp<0)
{
l=-*sapp;
for ( a=0; a<l; a++, i++, len++)
{
for (b=0; b< ns[0]; b++)
char_buf[ls[0][b]][len]=A->seq_al[ls[0][b]][i];;
for (b=0; b< ns[1]; b++)
char_buf[ls[1][b]][len]='-';
}
}
sapp++;
}
A->len_aln=len;
A->nseq=ns[0]+ns[1];
for ( a=0; a< ns[0]; a++) {
char_buf[ls[0][a]][len]='\0';
sprintf ( A->seq_al[ls[0][a]], "%s", char_buf[ls[0][a]]);
}
for ( a=0; a< ns[1]; a++) {
char_buf[ls[1][a]][len]='\0';
sprintf ( A->seq_al[ls[1][a]], "%s", char_buf[ls[1][a]]);
}
vfree (S);
free_char ( char_buf, -1);
l1=strlen (A->seq_al[ls[0][0]]);
l2=strlen (A->seq_al[ls[1][0]]);
if ( l1!=l2) exit(1);
free_int (pos, -1);
return score;
}
