binaries/src/tcoffee/t_coffee_source/aln_convertion_util.c

   1 #include <stdio.h>\r
   2 #include <stdlib.h>\r
   3 #include <math.h>\r
   4 #include <stdarg.h>\r
   5 #include <string.h>\r
   6 #include <ctype.h> \r
   7 #include "io_lib_header.h"\r
   8 #include "util_lib_header.h"\r
   9 #include "dp_lib_header.h"\r
  10 #include "define_header.h"\r
  11 \r
  12 int aln_has_stockholm_structure (Alignment *A)\r
  13 {\r
  14   return name_is_in_list ("#=GC SS_cons", A->name, A->nseq, 100);\r
  15 }\r
  16 \r
  17 int get_aln_stockholm_structure (Alignment *A)\r
  18 {\r
  19   int i;\r
  20   if ((i=aln_has_stockholm_structure(A))==-1)\r
  21     A=add_alifold2aln (A, NULL);\r
  22   return aln_has_stockholm_structure(A);\r
  23 }\r
  24 int ** update_RNAfold_list (Alignment *A, int **pos, int s, int **l)\r
  25 {\r
  26   int a=0;\r
  27   while (l[a])\r
  28     {\r
  29       if (!is_gap(A->seq_al[s][l[a][0]]) && !is_gap (A->seq_al[s][l[a][1]]))\r
  30         {\r
  31           l[a][2]=pos[s][l[a][0]];\r
  32           l[a][3]=pos[s][l[a][1]];\r
  33         }\r
  34       else\r
  35         {\r
  36           l[a][2]=l[a][3]=-1;\r
  37         }\r
  38       a++;\r
  39     }\r
  40   return l;\r
  41 }\r
  42 \r
  43 Alignment *compare_RNA_fold ( Alignment *A, Alignment *B)\r
  44 {\r
  45   int i1, i2, i;\r
  46   int **l1, **l2;\r
  47   int **pos1, **pos2;\r
  48   int a, b;\r
  49   int tot_ol=0, tot_l=0;\r
  50   \r
  51   i1=get_aln_stockholm_structure (A);\r
  52   i2=get_aln_stockholm_structure (B);\r
  53   \r
  54   l1=vienna2list (A->seq_al[i1]);\r
  55   l2=vienna2list (B->seq_al[i2]);\r
  56   \r
  57   pos1=aln2pos_simple(A, A->nseq);\r
  58   pos2=aln2pos_simple(B, B->nseq);\r
  59     \r
  60   \r
  61                         \r
  62   for (a=0; a< A->nseq; a++)\r
  63     {\r
  64       char **lu;\r
  65       int ol=0, ll1=0, ll2=0;\r
  66       if ( A->name[a][0]=='#')continue;\r
  67       i=name_is_in_list (A->name[a], B->name, B->nseq, 100);\r
  68       if (i!=-1)\r
  69         {\r
  70           l1=update_RNAfold_list (A,pos1,a, l1);\r
  71           l2=update_RNAfold_list (B,pos2,i, l2);\r
  72           lu=declare_char (A->len_aln, B->len_aln);\r
  73           \r
  74           b=0;\r
  75           while (l2[b])\r
  76             {\r
  77              \r
  78               if (l2[b][2]==-1 || l2[b][3]==-1);\r
  79               else\r
  80                 {\r
  81                   ll2++;\r
  82                   lu[l2[b][2]][l2[b][3]]=1;\r
  83                  \r
  84                 }\r
  85               b++;\r
  86             }\r
  87           b=0;\r
  88           \r
  89           while (l1[b])\r
  90             {\r
  91               \r
  92               if (l1[b][2]==-1 || l1[b][3]==-1);\r
  93               else\r
  94                 {\r
  95                   ll1++;\r
  96                   if (lu[l1[b][2]][l1[b][3]]==1)\r
  97                     {\r
  98                       A->seq_al[a][l1[b][0]]='6';\r
  99                       A->seq_al[a][l1[b][1]]='6';\r
 100                       ol++;\r
 101                     }\r
 102                   else\r
 103                     {\r
 104                       A->seq_al[a][l1[b][0]]='0';\r
 105                       A->seq_al[a][l1[b][1]]='0';\r
 106                     }\r
 107                 }\r
 108               b++;\r
 109             }\r
 110           \r
 111           free_char (lu, -1);\r
 112         }\r
 113       tot_ol+=ol;\r
 114       tot_l+=ll1;\r
 115       tot_l+=ll2;\r
 116       fprintf ( stdout, "@@ Seq: %s Overalp: %.2f Al1: %.2f Al2: %.2f \n", A->name[a], (float)(ol*200)/(ll1+ll2), (float)(ol*100)/ll1,(float)(ol*100)/ll2);\r
 117     }\r
 118   \r
 119   fprintf ( stdout, "@@ Seq: Tot Overalp: %.2f \n", (float)(tot_ol*200)/(tot_l));\r
 120   \r
 121   return A;\r
 122 }\r
 123 int is_neutral(char c1, char c2);\r
 124 int is_watson (char c1, char c2);\r
 125 int is_watson2 (char c1, char c2);\r
 126 int is_watson (char c1, char c2)\r
 127 {\r
 128   c1=tolower (c1);\r
 129   c2=tolower (c2);\r
 130   if ( is_watson2 (c1, c2)) return 1;\r
 131   else return is_watson2 (c2, c1);\r
 132 }\r
 133 int is_watson2 (char c1, char c2)\r
 134 {\r
 135 \r
 136   if ( c1=='g' && c2=='c')return 1;\r
 137   else if (c1=='a' && (c2=='t' || c2=='u'))return 1;\r
 138   return 0;\r
 139 }\r
 140 int is_neutral (char c1, char c2)\r
 141 {\r
 142   \r
 143   c1=tolower (c1);\r
 144   c2=tolower (c2);\r
 145   if (is_watson (c1, c2)) return 1;\r
 146   else if (c1=='g' && (c2=='t' || c2=='u'))return 1;\r
 147   else if ((c1=='t' || c1=='u') && c2=='g')return 1;\r
 148   return 0;\r
 149 }\r
 150 \r
 151 int ** vienna2list ( char *seq)\r
 152 {\r
 153   int a, b, i, i2,l;\r
 154   int **list;\r
 155   l=strlen (seq);\r
 156   list=declare_int (l+1, 8);\r
 157   for (i=0,a=0; a<l; a++)\r
 158     {\r
 159       if ( seq[a]=='(')\r
 160         {\r
 161           list[i][0]=a;\r
 162           for (i2=0,b=a+1; b<l && i2>=0; b++)\r
 163             {\r
 164               if (seq[b]=='(')i2++;\r
 165               else if (seq[b]==')')i2--;\r
 166             }\r
 167           list[i][1]=b-1;\r
 168           i++;\r
 169         }\r
 170     }\r
 171   \r
 172   list[i]=NULL;\r
 173   return list;\r
 174 }\r
 175 Alignment *aln2alifold(Alignment *A)\r
 176 {\r
 177   char *tmp1;\r
 178   char *tmp2;\r
 179   \r
 180   tmp1=vtmpnam (NULL);\r
 181   tmp2=vtmpnam (NULL);\r
 182   output_clustal_aln (tmp1,A);\r
 183   printf_system ("RNAalifold %s >%s 2>/dev/null", tmp1, tmp2);\r
 184   return alifold2aln (tmp2);\r
 185 }\r
 186 \r
 187 Alignment *add_alifold2aln  (Alignment *A, Alignment *ST)\r
 188 {\r
 189   int a,b,c,d,p1,p2;\r
 190   int r1, rr1, r2, rr2;\r
 191   int watson, comp,tot; \r
 192   int **compmat;\r
 193   int max, p,k;\r
 194   int minseq=3;\r
 195   int **list;\r
 196   int ncomp=0, nwatson=0;\r
 197   int cons_l, fold_l;\r
 198   int i,l;\r
 199 \r
 200   if (!ST)\r
 201     {\r
 202       char *tmp1, *tmp2;\r
 203       int f;\r
 204       Alignment *T;\r
 205       T=copy_aln (A, NULL);\r
 206       tmp1=vtmpnam (NULL);\r
 207       tmp2=vtmpnam (NULL);\r
 208       cons_l=A->len_aln;\r
 209       for (a=0; a<A->len_aln; a++)\r
 210         {\r
 211           for (f=0,b=0; b<A->nseq && f==0; b++)\r
 212             {\r
 213               if (is_gap (A->seq_al[b][a]))f=1;\r
 214               \r
 215             }\r
 216           if (f)\r
 217             {\r
 218               cons_l--;\r
 219               for (b=0; b<A->nseq; b++)T->seq_al[b][a]='-';\r
 220             }\r
 221         }\r
 222       ST=aln2alifold (T);\r
 223     }\r
 224         \r
 225 \r
 226   //add or Replace the structure\r
 227   l=strlen (ST->seq_al[0]);\r
 228  \r
 229   if ( l!=A->len_aln)\r
 230     {\r
 231       HERE ("\n%s\n%s\n", ST->seq_al[0], A->seq_al[0]);\r
 232       printf_exit ( EXIT_FAILURE, stderr, "ERROR the predicted structure and the multiple alignment do not have the same length [FATAL:%s]\n", PROGRAM);\r
 233       \r
 234     }\r
 235 \r
 236   for (a=0; a< l; a++)if (ST->seq_al[0][a]==STOCKHOLM_CHAR)ST->seq_al[0][a]='.';\r
 237   if ((i=name_is_in_list ("#=GC SS_cons", A->name, A->nseq, 100))!=-1)\r
 238     {\r
 239        sprintf (A->seq_al[i], "%s", ST->seq_al[0]);\r
 240     }\r
 241   else\r
 242     {\r
 243       A=realloc_aln2 ( A, A->nseq+1, A->len_aln+1);\r
 244       sprintf (A->name[A->nseq], "#=GC SS_cons");\r
 245       sprintf (A->seq_al[A->nseq], "%s", ST->seq_al[0]);\r
 246       A->nseq++;\r
 247     }\r
 248   return A;\r
 249 }\r
 250 Alignment * alifold2analyze (Alignment *A, Alignment *ST, char *mode)\r
 251 {\r
 252   int s;\r
 253   int **list;\r
 254   int usegap;\r
 255   \r
 256   s=name_is_in_list ("#=GC SS_cons", A->name,A->nseq, 100);\r
 257   \r
 258   if (s==-1)\r
 259     {\r
 260       A=add_alifold2aln (A,ST);\r
 261       s=name_is_in_list ("#=GC SS_cons", A->name,A->nseq, 100);\r
 262     }\r
 263     \r
 264   list=vienna2list (A->seq_al[s]);\r
 265   list=alifold_list2cov_list (A, list);\r
 266  \r
 267   usegap=0; //do not use gaped positions by default\r
 268   if (mode && strstr (mode, "usegap"))usegap=1;//count positions with gaps\r
 269   \r
 270   if (!mode)\r
 271     {\r
 272       A=alifold2cov_stat   (A, list,usegap);\r
 273     }\r
 274   else\r
 275     {\r
 276       if ( strstr (mode, "stat"))  A=alifold2cov_stat   (A, list, usegap);\r
 277       if ( strstr (mode, "list"))  A=alifold2cov_list   (A, list, usegap);\r
 278       if ( strstr (mode, "aln"))   A=alifold2cov_aln    (A, list, usegap);\r
 279       if ( strstr (mode, "color") )\r
 280         {\r
 281           Alignment *C;\r
 282           C=copy_aln (A, NULL);\r
 283           C=alifold2cov_cache (C, list, usegap);\r
 284           A=alifold2cov_aln (A, list, usegap);\r
 285           if ( strstr ( mode, "ps"))\r
 286             output_color_ps (A, C, "stdout");\r
 287           else\r
 288             output_color_html (A, C, "stdout");\r
 289           exit (EXIT_SUCCESS);\r
 290         }\r
 291     }\r
 292   return A;\r
 293 }\r
 294 \r
 295 \r
 296 int **    alifold_list2cov_list (Alignment *A, int **list)\r
 297 {\r
 298    int a,b,c,d,p1,p2,s;\r
 299   int r1, rr1, r2, rr2;\r
 300   int neutral,watson, comp,tot, occupancy; \r
 301   int **compmat;\r
 302   int max, p,k;\r
 303   int minseq=3;\r
 304   \r
 305   int ncomp=0, nwatson=0, nneutral=0, ncomp_wc=0;\r
 306   int cons_l, fold_l;\r
 307   int nseq;\r
 308  \r
 309  \r
 310   \r
 311   for (nseq=0,a=0; a< A->nseq; a++)if ( A->name[a][0]!='#')nseq++;\r
 312   max=((nseq*(nseq-1))/2);\r
 313   a=0;\r
 314   while (list[a])\r
 315     {\r
 316       p1=list[a][0];\r
 317       p2=list[a][1];\r
 318       watson=0;\r
 319       comp=0;\r
 320       neutral=0;\r
 321       tot=0;\r
 322       occupancy=0;\r
 323       for (c=0; c<A->nseq-1; c++)\r
 324         {\r
 325           if (A->name[c][0]=='#')continue;\r
 326           r1=tolower(A->seq_al[c][p1]);\r
 327           r2=tolower(A->seq_al[c][p2]); \r
 328           if (is_gap(r1) || is_gap(r2))continue;\r
 329           for (d=c+1; d<A->nseq; d++)\r
 330             {\r
 331               if (A->name[d][0]=='#')continue;\r
 332               rr1=tolower(A->seq_al[d][p1]);\r
 333               rr2=tolower(A->seq_al[d][p2]);\r
 334               if (is_gap(rr1) || is_gap(rr2))continue;\r
 335               if (is_watson (r1, r2))watson++;\r
 336               if (is_watson (rr1, rr2))watson++;\r
 337               if (is_neutral (r1, r2))neutral++;\r
 338               if (is_neutral (rr1, rr2))neutral++;\r
 339               if (r1!=rr1 && r2!=rr2)comp++;\r
 340               occupancy++;\r
 341             }\r
 342         \r
 343         }\r
 344       watson=(watson*100)/(occupancy*2);\r
 345       comp=(comp*100)/occupancy;\r
 346       neutral=(neutral*100)/(occupancy*2);\r
 347       occupancy=(occupancy*100)/max;\r
 348       list[a][3]=neutral;\r
 349       list[a][4]=watson;\r
 350       list[a][5]=comp;\r
 351       list[a][6]=occupancy;\r
 352      \r
 353       if (list[a][3]<100)\r
 354         {\r
 355           if (list[a][5]>0)list[a][7]='I';//compensated incompatible pair\r
 356           else list[a][7]='i'; //non compensated incompatible pair\r
 357         }\r
 358       else\r
 359         {\r
 360           list[a][7]='N';//Neutral pair\r
 361           if (list[a][4]==100)\r
 362             {\r
 363               list[a][7]='W';//Watson and Crick\r
 364               if ( list[a][5]>0)list[a][7]='C'; //Watson and crick compensated\r
 365             }\r
 366           else if ( list[a][5]>0)\r
 367             {\r
 368               list[a][7]='c';//compensated\r
 369             }\r
 370         }\r
 371       a++;\r
 372     }\r
 373   \r
 374   return list;\r
 375 }\r
 376 Alignment *alifold2cov_aln (Alignment *inA,int **list, int ug)\r
 377 {\r
 378   int a=0;\r
 379   a=0;\r
 380   Alignment *A;\r
 381 \r
 382   A=copy_aln (inA, NULL);\r
 383   A=realloc_aln2 ( A, A->nseq+1, A->len_aln+1);\r
 384   sprintf (A->name[A->nseq], "#=GC SS_analyze");\r
 385   sprintf (A->seq_al[A->nseq], "%s", A->seq_al[A->nseq-1]);\r
 386   A->nseq++;\r
 387   while (list[a])\r
 388     {\r
 389       char s;\r
 390       if (list[a][6]<100 && !ug);\r
 391       else\r
 392         {\r
 393           s=list[a][7];\r
 394           A->seq_al[A->nseq-1][list[a][0]]=s;\r
 395           A->seq_al[A->nseq-1][list[a][1]]=s;\r
 396         }\r
 397       a++;\r
 398     }\r
 399   return A;\r
 400 }\r
 401 Alignment *alifold2cov_stat (Alignment *A,int **list, int ug)\r
 402 {\r
 403   int fold=0,watson=0, comp=0, compwc=0, incomp=0, neutral=0;\r
 404   int a;\r
 405   \r
 406   a=0;\r
 407   while (list[a])\r
 408     {\r
 409       int s;\r
 410       fold++;\r
 411       if (list[a][6]<100 && !ug);\r
 412       else\r
 413         {\r
 414           s=list[a][7];\r
 415           watson +=(s=='W')?1:0;\r
 416           compwc +=(s=='C')?1:0;\r
 417           comp   +=(s=='c')?1:0;\r
 418           neutral+=(s=='N')?1:0;\r
 419           incomp +=(s=='I')?1:0;\r
 420         }\r
 421       a++;\r
 422     }\r
 423   fprintf ( stdout, "@@ TOT Nseq:%d tot_len: %d  fold: %d neutral: %d watson: %d CorWC: %d cor: %d CorIncompatible: %d\n",A->nseq-1, A->len_aln,fold, neutral,watson, compwc,comp,incomp);\r
 424   return A;\r
 425 }\r
 426 Alignment *alifold2cov_cache (Alignment *inA, int **list, int ug)\r
 427 {\r
 428   int a,b, c;\r
 429   Alignment *A;\r
 430 \r
 431   A=copy_aln (inA, NULL);\r
 432   a=0;\r
 433   while (list[a])\r
 434     {\r
 435       int v, s;\r
 436       if (list[a][6]<100 && !ug);\r
 437       else\r
 438         {\r
 439           s=list[a][7];\r
 440           if (s=='C')v=9; //red\r
 441           else if ( s=='c')v=7; //orange\r
 442           else if ( s=='W')v=5; //Yellow\r
 443           else if ( s=='N')v=2; //green\r
 444           else if ( s=='I')v=0; //blue;\r
 445           for (b=0;b<A->nseq; b++)\r
 446             {\r
 447               if (A->name[b][0]=='#');\r
 448               else\r
 449                 {\r
 450                   for (c=0; c<2; c++)\r
 451                     {\r
 452                       A->seq_al[b][list[a][c]]='0'+v;\r
 453                     }\r
 454                 }\r
 455             }\r
 456         }\r
 457       a++;\r
 458     }\r
 459   return A;\r
 460 }\r
 461 \r
 462 Alignment *alifold2cov_list (Alignment *A,int **list, int ug)\r
 463 {\r
 464   int a,b, s;\r
 465   \r
 466   a=0;\r
 467   while (list[a])\r
 468     {\r
 469       s=list[a][7];\r
 470       if (list[a][6]<100 && !ug);\r
 471       else if (s=='C')\r
 472         {\r
 473           fprintf ( stdout, "@@ WC Compensated pair: %4d %4d =>", list[a][0]+1, list [a][1]+1);\r
 474           for (b=0; b<A->nseq; b++)if (A->name[b][0]!='#')fprintf ( stdout, "[%c%c]", toupper (A->seq_al[b][list[a][0]]), toupper(A->seq_al[b][list[a][1]]));\r
 475           fprintf (stdout,"\n");\r
 476         }\r
 477       else if (s=='c')\r
 478         {\r
 479           fprintf ( stdout, "@@ Neural Compensated pair: %4d %4d =>", list[a][0]+1, list [a][1]+1);\r
 480           for (b=0; b<A->nseq; b++)if (A->name[b][0]!='#')fprintf ( stdout, "[%c%c]", toupper (A->seq_al[b][list[a][0]]), toupper(A->seq_al[b][list[a][1]]));\r
 481           fprintf (stdout,"\n");\r
 482         }\r
 483       else if (s=='W')\r
 484         {\r
 485           fprintf ( stdout, "@@ WC pair: %4d %4d =>", list[a][0]+1, list [a][1]+1);\r
 486           for (b=0; b<A->nseq; b++)if (A->name[b][0]!='#')fprintf ( stdout, "[%c%c]", toupper (A->seq_al[b][list[a][0]]), toupper(A->seq_al[b][list[a][1]]));\r
 487           fprintf (stdout,"\n");\r
 488         }\r
 489       else if (s=='N')\r
 490          {\r
 491           fprintf ( stdout, "@@ Neutral pair: %4d %4d =>", list[a][0]+1, list [a][1]+1);\r
 492           for (b=0; b<A->nseq; b++)if (A->name[b][0]!='#')fprintf ( stdout, "[%c%c]", toupper (A->seq_al[b][list[a][0]]), toupper(A->seq_al[b][list[a][1]]));\r
 493           fprintf (stdout,"\n");\r
 494         }\r
 495       else if (s=='I')\r
 496         {\r
 497           fprintf ( stdout, "@@ incompatible pair: %4d %4d =>", list[a][0]+1, list [a][1]+1);\r
 498           for (b=0; b<A->nseq; b++)if (A->name[b][0]!='#')fprintf ( stdout, "[%c%c]", toupper (A->seq_al[b][list[a][0]]), toupper(A->seq_al[b][list[a][1]]));\r
 499           fprintf (stdout,"\n");\r
 500         }\r
 501       a++;\r
 502     }\r
 503   \r
 504   return A;\r
 505 }\r
 506 \r
 507             \r
 508 Alignment *aln2sample (Alignment *A, int n)\r
 509 {\r
 510   Alignment *B;\r
 511   int a, b, p;\r
 512   int **pos;\r
 513   \r
 514   B=copy_aln (A, NULL);\r
 515     \r
 516   vsrand(0);\r
 517  \r
 518   pos=declare_int (A->len_aln, 2);\r
 519   for (a=0; a<A->len_aln; a++){pos[a][0]=a;pos[a][1]=rand()%(1000*A->len_aln);}\r
 520   \r
 521   sort_int (pos, 2, 1, 0, A->len_aln-1);\r
 522  \r
 523   n=(n==0)?A->len_aln:(MIN (n, (A->len_aln)));\r
 524   for (a=0; a<n; a++)\r
 525     for (b=0; b<A->nseq; b++)\r
 526       A->seq_al[b][a]=B->seq_al[b][pos[a][0]];\r
 527   for (b=0; b<A->nseq; b++)\r
 528     A->seq_al[b][n]='\0';\r
 529   A->len_aln=n;\r
 530   \r
 531   free_aln (B);\r
 532   free_int (pos, -1);\r
 533   return A;\r
 534 }\r
 535 Alignment *aln2bootstrap (Alignment *A, int n)\r
 536 {\r
 537   Alignment *B;\r
 538   int a, b, p;\r
 539   \r
 540   if (n==0)n=A->len_aln;\r
 541   else A=realloc_aln (A, n+1);\r
 542   vsrand(0);\r
 543   B=copy_aln (A, NULL);\r
 544   for (a=0; a<n; a++)\r
 545     {\r
 546       p=rand ()%A->len_aln;\r
 547       for (b=0; b<A->nseq; b++)\r
 548         A->seq_al[b][a]=B->seq_al[b][p];\r
 549     }\r
 550   for ( b=0; b<A->nseq; b++)A->seq_al[b][n]='\0';\r
 551   A->len_aln=n;\r
 552   \r
 553   free_aln (B);\r
 554   return A;\r
 555 \r
 556 }\r
 557   \r
 558 \r
 559 Alignment * aln2random_aln (Alignment *A, char *smode)\r
 560 \r
 561 {\r
 562   int a, b, n, **res;\r
 563   int max;\r
 564   \r
 565  \r
 566   \r
 567   if ( smode==NULL)\r
 568     {\r
 569       smode=vcalloc (4, sizeof (char));\r
 570       sprintf ( smode, "SCR");//Sequences, Column Residues\r
 571     }\r
 572   else if ( strm (smode, "NO"))return A;\r
 573   \r
 574   vsrand(0);\r
 575   max=A->nseq*1000;\r
 576   \r
 577   if ( strstr ( smode, "S"))\r
 578     {\r
 579       A=aln2scramble_seq (A);\r
 580     }\r
 581   if ( strstr ( smode, "C"))\r
 582     {\r
 583       \r
 584       res=declare_int (A->nseq, 2);\r
 585       for (a=0; a< A->len_aln; a++)\r
 586           {\r
 587             for (n=0,b=0;b<A->nseq; b++)\r
 588               {\r
 589                 if ( !is_gap(A->seq_al[b][a]))\r
 590                   {\r
 591                     res[n][0]=A->seq_al[b][a];\r
 592                     res[n][1]=rand()%max;\r
 593                     n++;\r
 594                   }\r
 595                 sort_int (res, 2, 1, 0, n-1);\r
 596               }\r
 597             for (n=0,b=0;b<A->nseq; b++)\r
 598               {\r
 599                 if ( !is_gap(A->seq_al[b][a]))A->seq_al[b][a]=res[n++][0];\r
 600               }\r
 601           }\r
 602       free_int (res, -a);\r
 603     }\r
 604   \r
 605     \r
 606   //Redistributes the residues randomly without changing the gap pattern\r
 607   if ( strstr ( smode, "R"))\r
 608     {\r
 609       max=A->len_aln*A->nseq;\r
 610       res=declare_int (max, 2);\r
 611       \r
 612       for (n=0,a=0; a< A->len_aln; a++)\r
 613         {\r
 614           for (b=0;b<A->nseq; b++)\r
 615             {\r
 616               if ( !is_gap(A->seq_al[b][a]))\r
 617                 {\r
 618                   res[n][0]=A->seq_al[b][a];\r
 619                   res[n][1]=rand()%max;\r
 620                   n++;\r
 621                 }\r
 622               \r
 623             }\r
 624         }\r
 625       sort_int (res, 2, 1, 0, n-1);\r
 626       for (n=0,a=0; a< A->len_aln; a++)\r
 627         {\r
 628           for (b=0;b<A->nseq; b++)\r
 629             {\r
 630               if ( !is_gap(A->seq_al[b][a]))\r
 631                 {\r
 632                   A->seq_al[b][a]=res[n++][0];\r
 633                 }\r
 634               \r
 635             }\r
 636         }\r
 637       \r
 638       free_int (res, -1);\r
 639     }\r
 640 \r
 641   return A;\r
 642 }\r
 643 Alignment *score_aln2score_ascii_aln (Alignment *A, Alignment *C)\r
 644 {\r
 645   //Convert the output of T-Coffee evaluate into a printable score_ascii alignment*/\r
 646   //A and C must be sorted \r
 647   //sets to 0 lone residues\r
 648   int a, b;\r
 649   \r
 650   for (a=0; a<A->nseq; a++)\r
 651     for (b=0; b<A->len_aln; b++)\r
 652       {\r
 653         \r
 654         int rC=C->seq_al[a][b];\r
 655         int rA=A->seq_al[a][b];\r
 656         if ( !strm (A->name[a], C->name[a])){HERE ("Unsorted aln in score_aln2score_ascii"); exit (EXIT_FAILURE);}\r
 657         \r
 658         if ( rA=='x' || rA=='X')C->seq_al[a][b]='9';\r
 659         else if ( rC >='0' && rC<='9');\r
 660         else if ( rC<10)C->seq_al[a][b]='0'+rC;\r
 661         else if ( rC==NO_COLOR_RESIDUE && !is_gap(rA)) C->seq_al[a][b]='0';\r
 662         else if ( rC==NO_COLOR_RESIDUE && is_gap(rA))C->seq_al[a][b]='-';\r
 663       }\r
 664   return C;\r
 665 }\r
 666 Alignment*aln2gap_cache (Alignment *A, int val)\r
 667 {\r
 668   Alignment *B;\r
 669   int a, b, c, nr;\r
 670   \r
 671   B=copy_aln (A, NULL);\r
 672   for (b=0; b<A->len_aln; b++)\r
 673     {\r
 674       for (nr=0,a=0; a<A->nseq; a++)nr+=!is_gap (A->seq_al[a][b]);\r
 675       for (a=0; a<A->nseq; a++)if (!is_gap(A->seq_al[a][b]))B->seq_al[a][b]=(nr==1)?'0'+val:'1';\r
 676     }\r
 677   return B;\r
 678 }\r
 679         \r
 680 Alignment* aln2case_aln (Alignment *B, char *upper, char *lower)\r
 681 {\r
 682   int a, b, c, up, lo;\r
 683   Alignment *A;\r
 684 \r
 685   A=copy_aln (B, NULL);\r
 686   \r
 687   up=(upper)?upper[0]:'u';\r
 688   lo=(lower)?lower[0]:'l';\r
 689   \r
 690   for (a=0; a<A->nseq; a++)\r
 691     for (b=0; b<A->len_aln; b++)\r
 692       {\r
 693         c=A->seq_al[a][b];\r
 694         \r
 695         if ( is_gap(c));\r
 696         else A->seq_al[a][b]=(isupper (c))?up:lo;\r
 697       }\r
 698   return A;\r
 699 }\r
 700 Alignment *aln2scale (Alignment *A, char *coffset)\r
 701 {\r
 702   int a, b, t, v, n;\r
 703   char *s1, *s2;\r
 704   char s[1000];\r
 705   int offset;\r
 706   \r
 707   if (coffset)offset=atoi(coffset);\r
 708   else offset=0;\r
 709 \r
 710   sprintf (s, "%d", A->len_aln+offset);\r
 711   n=strlen (s);\r
 712   \r
 713   A=realloc_aln2 (A, A->nseq+n, A->len_aln+1);\r
 714   s1=vcalloc ( n+1, sizeof (char));\r
 715   s2=vcalloc ( n+1, sizeof (char));\r
 716   \r
 717   for (a=0; a<n; a++)\r
 718     {\r
 719       if (a==0)s2[a]='1';\r
 720       else strcat (s2, "0");\r
 721       sprintf (A->name[A->nseq+a], "%s", s2);\r
 722     }\r
 723   \r
 724   for (a=0; a<A->len_aln; a++)\r
 725     {\r
 726       sprintf (s1, "%d", a+1+offset);\r
 727       s2=invert_string (s1);\r
 728       t=strlen (s2);\r
 729       \r
 730       for (b=0; b<=n; b++)\r
 731         {\r
 732           if (b>=t) v='0';\r
 733           else v=s2[b];\r
 734 \r
 735           A->seq_al[A->nseq+b][a]=v;\r
 736         }\r
 737     }\r
 738   \r
 739   A->nseq+=n;\r
 740   return A;\r
 741 }\r
 742 \r
 743   \r
 744         \r
 745       \r
 746 int * pos2list (int * pos, int len, int *nl)\r
 747 {\r
 748   int *list;\r
 749   int a;\r
 750   nl[0]=0;\r
 751   list=vcalloc (len, sizeof (int));\r
 752   for (a=0; a<len; a++)if (pos[a])list[nl[0]++]=a;\r
 753   return list;\r
 754 }\r
 755 int *list2pos (int *list, int nl, int len)\r
 756 {\r
 757   int *pos, a;\r
 758   pos=vcalloc (len, sizeof (int));\r
 759   for (a=0; a<nl; a++)pos[list[a]]=1;\r
 760   return pos;\r
 761 }\r
 762 \r
 763 int **aln2resindex ( Alignment *A, Alignment *B, FILE *fp)\r
 764 {\r
 765   int *list, **pos;\r
 766   int a, b, n, s;\r
 767   \r
 768   \r
 769   list=vcalloc (A->nseq+((B)?B->nseq:0), sizeof (int));\r
 770   pos=aln2pos_simple_2 (A);\r
 771   if (B)\r
 772     {\r
 773       n=B->nseq;\r
 774       for ( a=0; a<B->nseq; a++)\r
 775         {\r
 776           list[a]=name_is_in_list(B->name[a], A->name, A->nseq, 100);\r
 777         }\r
 778     }\r
 779   else\r
 780     {\r
 781       for ( a=0; a<A->nseq; a++)\r
 782         list[a]=a;\r
 783       n=A->nseq;\r
 784     }\r
 785 \r
 786   \r
 787   fprintf ( fp, "#");\r
 788   for ( b=0; b<n; b++)\r
 789     {\r
 790       s=list[b];\r
 791       if ( s!=-1)fprintf (fp, " %s",A->name[s]);\r
 792     }\r
 793   fprintf (fp, "\n");\r
 794            \r
 795   for ( a=0; a<A->len_aln; a++)\r
 796     {\r
 797       for ( b=0; b<n; b++)\r
 798         {\r
 799           s=list[b];\r
 800           if ( s==-1);\r
 801           else if (pos[s][a]<0)\r
 802             fprintf (fp, "%4d", -1);\r
 803           else\r
 804             fprintf (fp, "%4d", pos[s][a]);\r
 805         }\r
 806       fprintf (fp, "\n");\r
 807     }\r
 808   return pos;\r
 809 }\r
 810         \r
 811 int **index_seq_res      ( Sequence *S1, Sequence *S2, int **name_index)\r
 812 {\r
 813   /*Index the residues of S1 according to S2\r
 814     index[seq1 of S1][z]->x, where x is the position of residue z of seq1/S1 in S2->seq[index[Seq1/S1]] \r
 815   */ \r
 816   int a;\r
 817   int **index;\r
 818   char *seq1=NULL, *seq2=NULL;\r
 819   Alignment *Profile;\r
 820   \r
 821   index=vcalloc ( S1->nseq, sizeof (int*));\r
 822   \r
 823   for (a=0; a< S1->nseq; a++)\r
 824     {\r
 825       int  len1, len2, b, c;\r
 826       \r
 827       seq1=S1->seq[a];\r
 828       \r
 829       if (name_index[a][0]==-1)\r
 830         seq2=NULL;\r
 831       else if (name_index[a][1]==-1)\r
 832         {\r
 833           seq2=S2->seq[name_index[a][0]];\r
 834         }\r
 835       else if ((Profile=seq2R_template_profile (S2, name_index[a][0])) !=NULL)\r
 836         {\r
 837           seq2=Profile->seq_al[name_index[a][1]];\r
 838         }\r
 839       \r
 840       len1=strlen (seq1);len2=strlen (seq2);\r
 841       index[a]=vcalloc (len2, sizeof(int));\r
 842 \r
 843       \r
 844       for (c=0,b=0; b<len2; b++)if( !is_gap(seq2[b]))index[a][c++]=b;\r
 845       //index[a]=get_res_index ( seq1, seq2);\r
 846     }\r
 847   return index;\r
 848 }\r
 849 \r
 850 int **index_seq_name ( Sequence *S1, Sequence *S2)\r
 851 {\r
 852   /*Index the names of S1 according to S2\r
 853     index[seq1 of S1][0]->x  if seq1 is the xth sequence of S2\r
 854                         ->-1 if seq1 is nowhere to be found\r
 855     index[seq1 of S1][1]->z if seq1 is the zth sequence within the xth profile of S2\r
 856   */\r
 857   int **index;\r
 858   int a, b, x, z;\r
 859   Alignment *Profile;\r
 860   index=declare_int (S1->nseq, 2);\r
 861 \r
 862   \r
 863   for ( a=0; a<S1->nseq; a++)\r
 864     {\r
 865       index[a][0]=index[a][1]=-1;\r
 866       x=name_is_in_list (S1->name[a],S2->name,S2->nseq,100);\r
 867       if ( x!=-1){index[a][0]=x;index[a][1]=-1;}\r
 868       for ( b=0; b<S2->nseq; b++)\r
 869             {\r
 870               if ((Profile=seq2R_template_profile (S2,b)))\r
 871                 {\r
 872                   z=name_is_in_list (S1->name[a],Profile->name,Profile->nseq,100);\r
 873                   if ( z!=-1){index[a][0]=b;index[a][1]=z;b=S2->nseq;}\r
 874                 }\r
 875             }\r
 876     }\r
 877   return index;\r
 878 }\r
 879                   \r
 880                   \r
 881             \r
 882           \r
 883 int *get_name_index (char **l1, int n1, char **l2, int n2)\r
 884 {\r
 885   int *r;\r
 886   int a;\r
 887   /*return Array[Index_L1]=Index_L2 */\r
 888   r=vcalloc ( n1, sizeof (int));\r
 889   for ( a=0; a< n1; a++)\r
 890     r[a]=name_is_in_list (l1[a],l2,n2,100);\r
 891   return r;\r
 892 }\r
 893 \r
 894 int* get_res_index (char *seq0, char *seq1)\r
 895 {\r
 896   int *coor, a;\r
 897 \r
 898   if ( !seq0 || !seq1) return NULL;\r
 899   \r
 900 \r
 901   coor=vcalloc ( strlen (seq0)+1, sizeof (int));\r
 902   if (!strm (seq0, seq1))\r
 903     {\r
 904       int r0, r1 , isr0, isr1;\r
 905       int l0=0, l1=0;\r
 906       Alignment *A;\r
 907       A=align_two_sequences (seq0,seq1,"pam250mt",-5,-1, "myers_miller_pair_wise");\r
 908       \r
 909       for ( a=0; a< A->len_aln; a++)\r
 910         {\r
 911           r0=A->seq_al[0][a];r1=A->seq_al[1][a];\r
 912           isr0=!is_gap(r0);\r
 913           isr1=!is_gap(r1);\r
 914           l0+= isr0;\r
 915           l1+= isr1;\r
 916           if (isr0 && isr1)coor[l0-1]=l1-1;\r
 917           else if (isr0)  coor[l0-1]=-1;\r
 918         }\r
 919       free_aln (A);\r
 920     }\r
 921   else\r
 922     {\r
 923       int l0;\r
 924       \r
 925       l0=strlen (seq0);\r
 926       for ( a=0;a< l0; a++)\r
 927         coor[a]=a;\r
 928     }\r
 929   \r
 930   return coor;\r
 931 }\r
 932 \r
 933 int change_residue_coordinate ( char *in_seq1, char *in_seq2, int v)\r
 934 {\r
 935   /*Expresses the coordinate of a residue in seq1, in the coordinate system of seq2*/\r
 936 \r
 937   \r
 938   static char *seq1, *seq2;\r
 939   static int *coor;\r
 940  \r
 941 \r
 942   if ( seq1 !=in_seq1 || seq2 !=in_seq2)\r
 943     {\r
 944       int r0, r1 , isr0, isr1;\r
 945       int l0=0, l1=0;\r
 946       Alignment *A;\r
 947       int a;\r
 948       \r
 949       vfree (coor);\r
 950       seq1=in_seq1, seq2=in_seq2;\r
 951       A=align_two_sequences (seq1,seq2,"pam250mt", -14, -2, "myers_miller_pair_wise");\r
 952       \r
 953       coor=vcalloc ( A->len_aln, sizeof (int));\r
 954       for ( a=0; a< A->len_aln; a++)\r
 955         {\r
 956           r0=A->seq_al[0][a];r1=A->seq_al[1][a];\r
 957           \r
 958           isr0=!is_gap(r0);\r
 959           isr1=!is_gap(r1);\r
 960           l0+= isr0;\r
 961           l1+= isr1;\r
 962 \r
 963           if (isr0 && isr1)coor[l0-1]=l1-1;\r
 964           else if (isr0)  coor[l0-1]=-1;\r
 965         }\r
 966       free_aln (A);\r
 967     }\r
 968   return coor[v];\r
 969 }\r
 970           \r
 971    \r
 972 int ** minimise_repeat_coor (int **coor, int nseq, Sequence *S)\r
 973     {\r
 974     int **new_coor;\r
 975     int a, min;\r
 976     new_coor=declare_int ( nseq, 3);\r
 977     min=return_min_int (coor, nseq, 2);\r
 978     for ( a=0; a< nseq; a++)\r
 979         {\r
 980         new_coor[a][0]=coor[a][0];\r
 981         new_coor[a][1]=coor[a][1];\r
 982         new_coor[a][2]=min;\r
 983         }\r
 984     return new_coor;\r
 985     }\r
 986 int ** get_nol_seq ( Constraint_list *CL, int **coor, int nseq, Sequence *S)\r
 987     {\r
 988     int a, s, p, l, nl;\r
 989     int **buf;\r
 990     int **new_coor;\r
 991     \r
 992     new_coor=declare_int ( nseq+1, 3);\r
 993     \r
 994     \r
 995     buf=get_undefined_list ( CL);\r
 996     \r
 997     \r
 998 \r
 999     for ( a=0; a< nseq; a++)buf[coor[a][0]][coor[a][1]]=1;\r
1000 \r
1001     \r
1002     for ( a=0; a< nseq; a++)\r
1003         {\r
1004         s=coor[a][0];\r
1005         p=coor[a][1]+1;\r
1006         l=strlen(S->seq[s]);\r
1007         nl=0;\r
1008         while ( p<=l && !buf[s][p++])nl++;\r
1009         new_coor[a][0]=s;\r
1010         new_coor[a][1]=coor[a][1];\r
1011         new_coor[a][2]=nl;\r
1012         }\r
1013     free_int ( buf, -1);\r
1014     return new_coor;\r
1015     }\r
1016 \r
1017 \r
1018 \r
1019 int compare_pos_column( int **pos1,int p1, int **pos2,int p2, int nseq)\r
1020     {\r
1021     int a,v1, v2;\r
1022     int identical=0;\r
1023 \r
1024 \r
1025     \r
1026     for ( a=0; a< nseq; a++)\r
1027         {\r
1028         \r
1029         v1=pos1[a][p1];\r
1030         v2=pos2[a][p2];\r
1031         \r
1032         if (v1>0 || v2>0) \r
1033             {\r
1034             if ( v1!=v2)return 0;\r
1035             else identical=1;\r
1036             }\r
1037         }\r
1038     \r
1039     return identical;\r
1040     }\r
1041 \r
1042 char *seq2alphabet (Sequence *S)\r
1043 {\r
1044   return array2alphabet (S->seq, S->nseq, "");\r
1045 }\r
1046 \r
1047 char *aln2alphabet (Alignment *A)\r
1048 {\r
1049   return array2alphabet (A->seq_al, A->nseq, "");\r
1050 }  \r
1051 \r
1052 char *array2alphabet (char **array, int n, char *forbiden)\r
1053 {\r
1054   int a, b, l;\r
1055   int *hasch;\r
1056   char *alphabet;\r
1057 \r
1058   hasch=vcalloc (256, sizeof (int));\r
1059   alphabet=vcalloc ( 257, sizeof (char));\r
1060   \r
1061   \r
1062   for ( a=0; a<n; a++)\r
1063     {\r
1064       l=strlen (array[a]);\r
1065       for ( b=0; b<l; b++)\r
1066         hasch[tolower(array[a][b])]++;\r
1067     }\r
1068   \r
1069   for ( a=0, b=0; a< 256; a++)\r
1070     {\r
1071       if (hasch[a] && !strrchr(forbiden,a))alphabet[b++]=a;\r
1072     }\r
1073   \r
1074   alphabet[b]='\0';\r
1075   vfree (hasch);\r
1076   return alphabet;\r
1077 }\r
1078 \r
1079 \r
1080 //***************************************************************\r
1081 //\r
1082   //                          TM PRED\r
1083 //***************************************************************\r
1084 \r
1085 char* alnpos2hmmtop_pred (Alignment *A,Alignment *Pred, int pos, int mode)\r
1086 {\r
1087   static char *result;\r
1088   static Alignment *Cache;\r
1089   static int *score;\r
1090   int a, tot, cons;\r
1091   \r
1092   if (!score)\r
1093     {\r
1094       score=vcalloc (256, sizeof (int));\r
1095       result=vcalloc (100, sizeof (char));\r
1096     }\r
1097 \r
1098   if (!Pred && !Cache)\r
1099     {\r
1100       Cache=aln2hmmtop_pred (A);\r
1101     }\r
1102   if (!Pred) Pred=Cache;\r
1103   \r
1104 \r
1105   for (tot=0,a=0; a<A->nseq; a++)\r
1106     {\r
1107       char s;\r
1108       s=Pred->seq_al[a][pos];\r
1109       if (!is_gap(s))\r
1110         {\r
1111           score[tolower(s)]++;\r
1112           tot++;\r
1113         }\r
1114     }\r
1115 \r
1116   if ( score['h']>score['i'] && score['h']>score['o'])cons='h';\r
1117   \r
1118   else if ( score['i']>score['o'])cons='i';\r
1119   else cons='o';\r
1120   if (tot==0) return "";\r
1121 \r
1122   \r
1123   if (mode==VERBOSE)sprintf (result, " H: %3d I: %3d O: %3d P: %c", (score['h']*100)/tot, (score['i']*100)/tot, (score['o']*100)/tot, cons);\r
1124   else if (mode == SHORT)sprintf ( result, "%c", cons);\r
1125   score['h']=score['o']=score['i']=0;\r
1126   return result;\r
1127 }\r
1128   \r
1129   \r
1130 Alignment * aln2hmmtop_pred (Alignment *A)\r
1131   {\r
1132     int a, b, c;\r
1133     char *buf, *pred;\r
1134     Alignment *PA;\r
1135 \r
1136     PA=copy_aln (A, NULL);\r
1137     buf=vcalloc ( A->len_aln+1, sizeof (char));\r
1138     \r
1139     for ( a=0; a< A->nseq; a++)\r
1140       {\r
1141         sprintf (buf, "%s", A->seq_al[a]);\r
1142         pred=seq2tmstruc (buf);\r
1143         for (c=0,b=0; b<A->len_aln; b++)\r
1144           {\r
1145             if (!is_gap (PA->seq_al[a][b]))PA->seq_al[a][b]=pred[c++];\r
1146           }\r
1147         vfree (pred);\r
1148       }\r
1149     vfree (buf);\r
1150     return PA;\r
1151   }\r
1152  \r
1153 char * seq2tmstruc ( char *seq)\r
1154    {\r
1155      static Sequence *S;\r
1156      char *seqfile, *predfile, *buf;\r
1157      FILE *fp;\r
1158      \r
1159      seqfile=vtmpnam (NULL);\r
1160      predfile=vtmpnam (NULL);\r
1161      \r
1162      fp=vfopen (seqfile, "w");\r
1163      fprintf ( fp, ">seq1\n%s", seq);\r
1164      vfclose (fp);\r
1165      \r
1166      \r
1167      printf_system ( "fasta_seq2hmmtop_fasta.pl -in=%s -out=%s -arch=%s/%s -psv=%s/%s", seqfile, predfile, get_mcoffee_4_tcoffee(), "hmmtop.arch", get_mcoffee_4_tcoffee(), "hmmtop.psv");\r
1168      S=get_fasta_sequence (predfile, NULL);\r
1169      buf=vcalloc ( strlen (S->seq[0])+1, sizeof (char));\r
1170      sprintf ( buf, "%s", S->seq[0]);\r
1171      \r
1172      free_sequence (S, S->nseq);\r
1173      \r
1174      return buf;\r
1175    }\r
1176   \r
1177 char * set_blast_default_values()\r
1178 {\r
1179   set_string_variable ("blast_server", (getenv ("blast_server_4_TCOFFEE"))?getenv ("blast_server_4_TCOFFEE"):"EBI");\r
1180   set_string_variable ("pdb_db", (getenv ("pdb_db_4_TCOFFEE"))?getenv ("pdb_db_4_TCOFFEE"):"pdb");\r
1181   set_string_variable ("prot_db", (getenv ("prot_db_4_TCOFFEE"))?getenv ("prot_db_4_TCOFFEE"):"uniprot");\r
1182   set_int_variable ("prot_min_sim", 0);\r
1183   set_int_variable ("prot_max_sim", 100);\r
1184   \r
1185   set_int_variable ("prot_min_cov", 0);\r
1186   set_int_variable ("prot_max_cov", 100);\r
1187 \r
1188   set_int_variable ("pdb_min_sim", 0);\r
1189   set_int_variable ("pdb_max_sim", 100);\r
1190   set_int_variable ("pdb_min_cov", 0);\r
1191   set_int_variable ("pdb_max_cov", 100);\r
1192   \r
1193   return;\r
1194 }\r
1195   \r
1196 char * seq2pdb   (Sequence *S)\r
1197 {\r
1198   set_blast_default_values();\r
1199   S->nseq=1;\r
1200   S=seq2template_seq (S, "PDB", NULL);\r
1201   return seq2P_pdb_id(S,0);\r
1202 }\r
1203 \r
1204 Alignment * seq2blast ( Sequence *S)\r
1205 {\r
1206   Alignment *A;\r
1207   set_blast_default_values();\r
1208   \r
1209   if (S->nseq==1)\r
1210     {\r
1211       S=seq2template_seq (S, "BLAST", NULL);\r
1212       A=seq2R_template_profile(S,0);\r
1213       sprintf ( A->name[0], "%s", S->name[0]);\r
1214     }\r
1215   else\r
1216     {\r
1217       int a;\r
1218       for (a=0; a< S->nseq; a++)\r
1219         {\r
1220           Sequence *NS;\r
1221           char name[1000];\r
1222           NS=fill_sequence_struc(1, &(S->seq[a]), &(S->name[a]));\r
1223           NS=seq2template_seq (NS, "BLAST", NULL);\r
1224           A=seq2R_template_profile(NS,0);\r
1225           sprintf ( name, "%s.prf", S->name[a]);\r
1226           \r
1227           output_fasta_aln (name,A); \r
1228           fprintf (stdout, "\nOUTPUT %s\n", name);\r
1229         }\r
1230       exit (EXIT_SUCCESS);\r
1231     }\r
1232   return A;\r
1233 }\r
1234             \r
1235       \r
1236           \r
1237 \r
1238 Sequence * seq2unique_name_seq ( Sequence *S)\r
1239 {\r
1240   int a;\r
1241   if ((a=name_list2unique_name_list (S->nseq, S->name)))\r
1242     {\r
1243       add_warning ( stderr, "\nWarning: Sequence %s is duplicated in file %s. The sequence will be renamed", S->name[a-1], S->file[a-1]);\r
1244     }\r
1245   return S;\r
1246 }\r
1247 Alignment * aln2unique_name_aln ( Alignment *S)\r
1248 {\r
1249   int a;\r
1250   if ((a=name_list2unique_name_list (S->nseq, S->name)))\r
1251     {\r
1252       add_warning ( stderr, "\nWarning: Sequence %s is duplicated in file %s. The sequence will be renamed", S->name[a-1], S->file[a-1]);\r
1253     }\r
1254   return S;\r
1255 }\r
1256 \r
1257     \r
1258 int name_list2unique_name_list (int n, char **name)\r
1259 {\r
1260   int duplicate=0;  \r
1261   int a, b;\r
1262           \r
1263   for (a=0; a<n-1; a++)\r
1264     for (b=a+1; b<n; b++)\r
1265       {\r
1266         if ( strm (name[a], name[b]))\r
1267           {duplicate=a+1;b=a=n;}\r
1268       }\r
1269   \r
1270   if (duplicate)\r
1271     {\r
1272       char *tmp1, *tmp2;\r
1273       Sequence *S;\r
1274       FILE *fp;\r
1275       \r
1276       tmp1=vtmpnam (NULL);\r
1277       tmp2=vtmpnam (NULL);\r
1278       fp=vfopen (tmp1, "w");\r
1279       for (a=0; a< n; a++)fprintf ( fp, ">%s\naggggg\n", name[a]);\r
1280       vfclose (fp);\r
1281       printf_system ("fasta_aln2fasta_aln_unique_name.pl %s > %s", tmp1, tmp2);\r
1282       S=get_fasta_sequence (tmp2, NULL);\r
1283       for (a=0; a<n; a++)\r
1284         {\r
1285           name[a]=vrealloc (name [a], sizeof (int)*(strlen (S->name[a])+1));\r
1286           sprintf ( name[a], "%s", S->name [a]);\r
1287         }\r
1288       free_sequence(S, -1);\r
1289     }\r
1290   return duplicate;\r
1291 }\r
1292 \r
1293 Sequence* seq2clean_seq (Sequence *S, char *alp)\r
1294 {\r
1295   int a, b, c, d, l;\r
1296   \r
1297   for (a=0; a< S->nseq; a++)\r
1298     {\r
1299       l=strlen (S->seq[a]);\r
1300       for (d=0,b=0; b<l; b++)\r
1301         {\r
1302           c=S->seq[a][b];\r
1303           if ( alp==NULL && !strchr (AA_ALPHABET, c) && !strchr (DNA_ALPHABET, c));\r
1304           else if (alp && strchr (alp, c));\r
1305           else S->seq[a][d++]=c;\r
1306         }\r
1307       S->seq[a][d]='\0';\r
1308       S->len[a]=strlen (S->seq[a]);\r
1309     }\r
1310   return S;\r
1311 }    \r
1312 int ** seq2aln_pos      (Alignment *A, int *ns, int **l_s)\r
1313     {\r
1314     int **code;\r
1315     int a, b,c, d,l, p , g;\r
1316     \r
1317 \r
1318     l=MAX(strlen (A->seq_al[l_s[0][0]]), strlen (A->seq_al[l_s[1][0]]));\r
1319     code=declare_int ((A->S)->nseq,l+1);\r
1320     \r
1321     for (c=0; c<2; c++)\r
1322         {\r
1323         l=strlen (A->seq_al[l_s[c][0]]);\r
1324         for (d=0; d<ns[c]; d++)\r
1325             {\r
1326             a=A->order[l_s[c][d]][0];\r
1327             for (p=0, b=0; b<l; b++)\r
1328                 {\r
1329                     g=is_gap (A->seq_al[l_s[c][d]][b]);\r
1330                     if (!g){p++; code[a][p]=b+1;}\r
1331                 }\r
1332             }\r
1333         }\r
1334     return code;\r
1335     }\r
1336 \r
1337 Alignment *local_maln2global_maln (char *seq, Alignment *A)\r
1338     {\r
1339       /*inputs a BLAST alignmnent where the master sequence may be partila\r
1340         outputs the same alignment, while amkeing sure the profile is perfectly in sink with its master sequence\r
1341       */\r
1342 \r
1343       int a, b, c;\r
1344       int start, end, rend;\r
1345       char qname[100], *p;\r
1346       Alignment *B=NULL;\r
1347       \r
1348       sprintf ( qname, "%s", A->name[0]);\r
1349       p=strtok (qname, "_");\r
1350       if ( !strm (p, "QUERY"))\r
1351            {\r
1352              fprintf ( stderr, "\nUnappropriate format for the alignment [%s:FATAL]", PROGRAM);\r
1353              myexit (EXIT_FAILURE);\r
1354            }\r
1355              \r
1356       start=atoi(strtok (NULL, "_"));\r
1357       end=atoi(strtok (NULL, "_"));\r
1358       rend=strlen (seq);\r
1359       \r
1360       B=copy_aln (A,NULL);\r
1361       if ( start>1 || end<rend )A=realloc_aln (A,rend+1);\r
1362 \r
1363       for (a=0; a<start-1; a++)\r
1364         {\r
1365           A->seq_al[0][a]=seq[a];\r
1366           for ( b=1; b< A->nseq; b++)A->seq_al[b][a]='-';\r
1367         }\r
1368       \r
1369       for (c=0,a=start-1; a< end; a++, c++)\r
1370         {\r
1371           A->seq_al[0][a]=seq[a];\r
1372           for ( b=1; b< A->nseq; b++)\r
1373             {\r
1374               A->seq_al[b][a]=B->seq_al[b][c];\r
1375             }\r
1376         }\r
1377       for ( a=end; a<rend; a++)\r
1378         {\r
1379           A->seq_al[0][a]=seq[a];\r
1380           for ( b=1; b< A->nseq; b++)A->seq_al[b][a]='-';\r
1381         }\r
1382       for ( a=0; a< A->nseq; a++) A->seq_al[a][rend]='\0';\r
1383       free_aln (B);\r
1384       \r
1385       A->len_aln=rend;\r
1386       return A;\r
1387     }\r
1388 \r
1389 int ** aln2inv_pos ( Alignment *A)\r
1390 {\r
1391   int **pos,a;\r
1392   pos=vcalloc (A->nseq, sizeof (char*));\r
1393   for (a=0; a< A->nseq; a++)pos[a]=seq2inv_pos (A->seq_al[a]);\r
1394   return pos;\r
1395 }\r
1396 int *  seq2inv_pos ( char *seq)\r
1397 {\r
1398   /*returns a list where each value gives the index of the corresponding residue in seq*/\r
1399   /*Numbering: 1 to L : Analogy to the aln2pos*/\r
1400   \r
1401   int a,l1, l2;\r
1402   int *pos;\r
1403   \r
1404   l1=strlen ( seq);\r
1405   for ( l2=a=0; a< l1; a++)l2+=1-is_gap(seq[a]);\r
1406   pos=vcalloc (l2+1, sizeof (int));\r
1407   for ( l2=a=0; a< l1; a++)if (!is_gap(seq[a]))pos[++l2]=a+1;\r
1408   return pos;\r
1409 }\r
1410   \r
1411   \r
1412 int ** aln2pos_simple_2 (Alignment *A)\r
1413     {\r
1414     int **pos1;\r
1415     int **pos2;\r
1416     pos1=aln2pos_simple (A, A->nseq);\r
1417     pos2=duplicate_int  (pos1, A->nseq,read_size_int (pos1[0],sizeof (int)));\r
1418     pos1=aln2pos_simple (NULL, 0);\r
1419     return pos2;\r
1420     }\r
1421 int ** aln2pos_simple (Alignment *A, int n_nseq, ...)\r
1422     {\r
1423     /*\r
1424     function documentation: start\r
1425     int ** aln2pos_simple (Alignment *A, int n_nseq, ...)\r
1426 \r
1427 ####with two parameter only: Alignment *A, int n_nseq\r
1428 \r
1429     this function turns A into pos, a matrix where each residue is replace by its index according to the complete sequence.\r
1430     the indices in pos are computed using A->order[x][1] that contains the indice of the first residue of seq x of A\r
1431     \r
1432     n_nseq MUST not be null\r
1433 \r
1434 ####with more than two param:\r
1435      int ** aln2pos_simple (Alignment *A, int n_nseq, int *ns, int **ls)\r
1436      n_nseq must be set to 0 for the param 3 and four to be read\r
1437      \r
1438      ns[x]=number seq in group \r
1439      ls[x]=list of the sequences in group x ( size=ns[x])\r
1440      \r
1441     The computation of the indices is only carried out on the scpecified residues\r
1442 \r
1443 ####IMPORTANT\r
1444       in pos, the numbering of the residues goes from 1 to L:\r
1445         pos[0][0]=3, means that the first position of the first sequence \r
1446         in the alignmnet contains residue #3 from sequence A->order[0][0];\r
1447         \r
1448     function documentation: end\r
1449     */\r
1450 \r
1451     int a, b,c, p, g,l;\r
1452     int **T;\r
1453 \r
1454     int max_nseq;\r
1455     int n_len=0;\r
1456 \r
1457     int *list=NULL;\r
1458     int *ns=NULL;\r
1459     int **ls=NULL;\r
1460 \r
1461 \r
1462 \r
1463     va_list ap;\r
1464     \r
1465     \r
1466     if ( A==NULL)\r
1467        {\r
1468          return NULL;\r
1469        }\r
1470     else\r
1471        {\r
1472        if ( n_nseq>0)\r
1473           {\r
1474           list=vcalloc(n_nseq, sizeof (int));\r
1475           for ( a=0; a< n_nseq; a++)list[a]=a;\r
1476           }\r
1477        else\r
1478           { \r
1479           va_start (ap, n_nseq);\r
1480           ns=va_arg(ap, int * );\r
1481           ls=va_arg(ap, int **);\r
1482           va_end(ap);\r
1483           list=vcalloc ( ns[0]+ns[1], sizeof (int));\r
1484           n_nseq=0;\r
1485           for ( a=0; a< ns[0]; a++)list[n_nseq++]=ls[0][a];\r
1486           for ( a=0; a< ns[1]; a++)list[n_nseq++]=ls[1][a];\r
1487           \r
1488           }\r
1489        max_nseq=MAX(read_size_int(A->order,sizeof (int*)),return_max_int (A->order, read_size_int(A->order,sizeof (int*)),0))+1;\r
1490        n_len=get_longest_string ( A->seq_al,A->max_n_seq, NULL, NULL)+1;  \r
1491        \r
1492 \r
1493        T=declare_int (max_nseq, n_len);\r
1494        for ( c=0; c< n_nseq; c++)\r
1495            {\r
1496            a=list[c];          \r
1497            l=strlen ( A->seq_al[a]);\r
1498            \r
1499            for ( p=A->order[a][1],b=0; b<l; b++)\r
1500                {\r
1501                g=1-is_gap(A->seq_al[a][b]);\r
1502                p+=g;\r
1503                T[a][b]=(g==1)?p:-(1+p);\r
1504                if ( A->seq_al[a][b]==UNDEFINED_RESIDUE)T[a][b]=0;\r
1505                if ( A->seq_cache && T[a][b]>0)T[a][b]=A->seq_cache[A->order[a][0]][T[a][b]];\r
1506                } \r
1507            }\r
1508        vfree (list);\r
1509        }\r
1510    \r
1511    return T;\r
1512    }\r
1513 Alignment ** split_seq_in_aln_list ( Alignment **aln, Sequence *S, int n_seq, char **seq_list)\r
1514         {\r
1515         int a, b, c;\r
1516         char * long_seq=NULL;\r
1517         int    len,l;\r
1518         int  **translation;\r
1519         int  **table;\r
1520 \r
1521 \r
1522         \r
1523 \r
1524         if ( aln==NULL)return NULL;\r
1525         translation=declare_int ( S->nseq,2);\r
1526         \r
1527         for (len=0,a=0; a< S->nseq; a++)\r
1528             {\r
1529             if((b=name_is_in_list (S->name[a],seq_list, n_seq, 100))!=-1)\r
1530                {\r
1531                l=strlen(S->seq[a])+1;\r
1532                long_seq=vrealloc(long_seq,(len+l+1)*sizeof(char));\r
1533                long_seq=strcat(long_seq, S->seq[a]);\r
1534                long_seq=strcat(long_seq, "*");   \r
1535                \r
1536                translation[a][0]=b;\r
1537                translation[a][1]=len;\r
1538                len+=l;\r
1539                }\r
1540             else translation[a][0]=-1;\r
1541             }\r
1542 \r
1543         long_seq[len-1]='\0';\r
1544         len--;\r
1545 \r
1546         table=declare_int ( len+1, 2);\r
1547 \r
1548         for ( b=0,a=0; a< S->nseq; a++)\r
1549             {\r
1550             if ( translation[a][0]!=-1)\r
1551                {\r
1552                c=1;\r
1553                while (long_seq[b]!='\0' && long_seq[b]!='*')\r
1554                    {\r
1555                    table[b+1][1]=c++;\r
1556                    table[b+1][0]=translation[a][0];\r
1557                    b++;\r
1558                    }\r
1559                table[b][1]=c++;\r
1560                table[b][0]=translation[a][0];\r
1561                b++;\r
1562                }\r
1563             }\r
1564 \r
1565         for ( a=0; a< (aln[-1])->nseq; a++)\r
1566             {\r
1567             for ( b=0; b< (aln[a])->nseq; b++)\r
1568                 {\r
1569                 \r
1570                 (aln[a])->order[b][0]=table[(aln[a])->order[b][1]][0];\r
1571                 (aln[a])->order[b][1]=table[(aln[a])->order[b][1]][1];\r
1572                 sprintf ( (aln[a])->name[b],"%s_%d_%d", S->name[(aln[a])->order[b][0]],a+1,b+1); \r
1573                 }\r
1574             }\r
1575         free_int (translation, -1);\r
1576         free_int (table,       -1);\r
1577         return aln;\r
1578         }\r
1579 \r
1580 \r
1581 \r
1582 Sequence  *  fill_sequence_struc ( int nseq, char **sequences, char **seq_name)\r
1583         {\r
1584         int a;\r
1585         Sequence *S;\r
1586         int shortest, longuest;\r
1587 \r
1588         if (!sequences)\r
1589           {\r
1590             shortest=longuest=0;\r
1591           }\r
1592         else if ( nseq>1)\r
1593           {\r
1594             shortest=get_shortest_string( sequences, nseq, NULL, NULL);\r
1595             longuest=get_longest_string (sequences, nseq, NULL, NULL);\r
1596           }\r
1597         else if ( nseq==1)\r
1598           {\r
1599             shortest=longuest=strlen (sequences[0]);\r
1600           }\r
1601         else\r
1602           {\r
1603             return NULL;\r
1604           }\r
1605         \r
1606 \r
1607         S=declare_sequence (shortest, longuest,nseq);\r
1608         S->nseq=nseq;\r
1609         \r
1610         if (sequences)S->seq=copy_char ( sequences, S->seq, nseq, -1);\r
1611         else S->seq=declare_char (S->nseq, 1);\r
1612         \r
1613         S->name=copy_char ( seq_name, S->name,nseq, -1);\r
1614         \r
1615         ungap_array (S->seq,nseq);\r
1616         for ( a=0; a< S->nseq; a++)S->len[a]=strlen(S->seq[a]);\r
1617         return S;\r
1618         }\r
1619 \r
1620 \r
1621 Alignment * thread_profile_files2aln (Alignment *A, char *template_file, Fname *F)\r
1622 {\r
1623  \r
1624   Alignment *P;\r
1625   int a;\r
1626   \r
1627   if (!A->S)A->S=aln2seq (A);\r
1628   if (template_file)A->S=seq2template_seq (A->S, template_file,F);\r
1629   for ( a=0; a< A->nseq; a++)\r
1630     {\r
1631       P=seq2R_template_profile (A->S, a);\r
1632       if ( P)\r
1633         {\r
1634           P->expand=1;\r
1635           sprintf ( P->name[0], "%s", A->name[a]);\r
1636         }\r
1637     }\r
1638   \r
1639   return expand_aln (A);\r
1640 }\r
1641   \r
1642   \r
1643 \r
1644 \r
1645 Alignment * expand_aln (Alignment *A)\r
1646   {\r
1647   /*This function expands the profiles within an alignment*/\r
1648   \r
1649   \r
1650   int a, b, d, e;\r
1651   Alignment *MAIN=NULL, *SUB=NULL;\r
1652   int n_sub_seq=0;\r
1653   int new_nseq=0;\r
1654   int *list;\r
1655   Alignment *Profile;\r
1656   \r
1657   if ( !A)return A;\r
1658 \r
1659 \r
1660   \r
1661   list=vcalloc (A->nseq, sizeof (int)); \r
1662   for ( a=0; a< A->nseq; a++)\r
1663     {\r
1664       Profile=seq2R_template_profile (A->S, A->order[a][0]);\r
1665       if (Profile && Profile->expand)\r
1666         {\r
1667           new_nseq+=Profile->nseq;\r
1668         }\r
1669       else \r
1670         {\r
1671           new_nseq++;\r
1672           list[n_sub_seq++]=a;\r
1673         }      \r
1674     }\r
1675   \r
1676   if ( n_sub_seq==A->nseq){vfree(list);return A;}\r
1677   else if (n_sub_seq==0){MAIN=copy_aln (A, MAIN);MAIN->nseq=0;}\r
1678   else\r
1679     {\r
1680       MAIN=extract_sub_aln (A, n_sub_seq, list);\r
1681     }\r
1682   vfree(list);\r
1683   \r
1684   \r
1685   for ( a=0; a< A->nseq; a++)\r
1686     {\r
1687       Profile=seq2R_template_profile (A->S, A->order[a][0]);\r
1688       if ( Profile && Profile->expand)\r
1689         {\r
1690           SUB=copy_aln (Profile,SUB);\r
1691           SUB=realloc_aln2(SUB, SUB->nseq, A->len_aln+1);\r
1692           \r
1693           for ( e=0,b=0; b< A->len_aln; b++)\r
1694             {\r
1695               if ( is_gap(A->seq_al[a][b]))\r
1696                 {for (d=0; d< SUB->nseq; d++)SUB->seq_al[d][b]='-';}\r
1697               else \r
1698                  {\r
1699                    for(d=0; d<SUB->nseq; d++)SUB->seq_al[d][b]=Profile->seq_al[d][e];\r
1700                    e++;\r
1701                  }\r
1702                    \r
1703             }\r
1704           MAIN=stack_aln(MAIN, SUB);\r
1705         }\r
1706     }\r
1707   free_aln (A);\r
1708   free_aln (SUB);\r
1709   return MAIN;\r
1710   }\r
1711 Alignment * expand_number_aln (Alignment *A,Alignment *EA)\r
1712   {\r
1713   /*This function expands the profiles within an alignment*/\r
1714   \r
1715     \r
1716   int a, b, d, e;\r
1717   Alignment *MAIN=NULL, *SUB=NULL, *C=NULL;\r
1718   int n_sub_seq=0;\r
1719   int new_nseq=0;\r
1720   int *list;\r
1721   Alignment *Profile;\r
1722 \r
1723   if ( !EA || !A)return EA;\r
1724 \r
1725   if ( EA->nseq<A->nseq)\r
1726     {\r
1727       fprintf (stderr, "\n[ERROR:expand_number_aln] Using as a master an expanded aln (%d %d) [FATAL:%s]", EA->nseq, A->nseq,PROGRAM);\r
1728       EA->A=A->A=NULL;\r
1729       print_aln (EA);\r
1730       print_aln (A);\r
1731       myexit (EXIT_FAILURE);\r
1732     }\r
1733   \r
1734 \r
1735   list=vcalloc (EA->nseq, sizeof (int)); \r
1736   for ( a=0; a< EA->nseq; a++)\r
1737     {\r
1738       Profile=seq2R_template_profile (EA->S, EA->order[a][0]);\r
1739       if (Profile && Profile->expand)new_nseq+=Profile->nseq;\r
1740       else \r
1741         {\r
1742           new_nseq++;\r
1743           list[n_sub_seq++]=a;\r
1744         }      \r
1745     }\r
1746   \r
1747   if ( n_sub_seq==EA->nseq){vfree(list);return EA;}\r
1748   else if (n_sub_seq==0){MAIN=copy_aln (EA, MAIN);MAIN->nseq=0;}\r
1749   else\r
1750     {\r
1751       MAIN=extract_sub_aln (EA, n_sub_seq, list);      \r
1752     }\r
1753   \r
1754   \r
1755   list[0]=EA->nseq;\r
1756   C=extract_sub_aln (EA,1, list);  \r
1757   vfree(list);\r
1758   \r
1759   \r
1760   \r
1761   for ( a=0; a< EA->nseq; a++)\r
1762     {\r
1763       Profile=seq2R_template_profile (EA->S, EA->order[a][0]);\r
1764       if ( Profile && Profile->expand)\r
1765         {\r
1766           SUB=copy_aln (Profile,SUB);\r
1767           SUB=realloc_aln2(SUB, SUB->nseq, EA->len_aln+1);\r
1768           \r
1769           for ( e=0,b=0; b<= EA->len_aln; b++)\r
1770             {\r
1771               if (is_gap(A->seq_al[a][b]))\r
1772                 {\r
1773                 for ( d=0; d<SUB->nseq; d++)\r
1774                   SUB->seq_al[d][b]=NO_COLOR_RESIDUE;\r
1775                 }\r
1776               else\r
1777                 {\r
1778                   for ( d=0; d<SUB->nseq; d++)\r
1779                     {\r
1780 \r
1781                       if ( is_gap (Profile->seq_al[d][e]))\r
1782                         {\r
1783                           SUB->seq_al[d][b]=NO_COLOR_RESIDUE;\r
1784                         }\r
1785                       else SUB->seq_al[d][b]=EA->seq_al[a][b];\r
1786                     }\r
1787                   e++;\r
1788                 }\r
1789             }\r
1790           for (d=0; d< SUB->nseq; d++)SUB->score_seq[d]=EA->score_seq[a];\r
1791           \r
1792           MAIN=stack_aln(MAIN, SUB);\r
1793         }\r
1794     }\r
1795   \r
1796   MAIN=stack_aln(MAIN, C);\r
1797   MAIN->nseq--;\r
1798   MAIN->score=MAIN->score_aln=EA->score_aln;\r
1799   \r
1800   free_aln (SUB);\r
1801   free_aln (EA);\r
1802   \r
1803   free_aln (C);\r
1804   \r
1805   return MAIN;\r
1806   }\r
1807 \r
1808 Alignment * probabilistic_rm_aa ( Alignment *A, int pos, int len)\r
1809 {\r
1810   int random_len=0;\r
1811   int a, b;\r
1812   int left, right;\r
1813 \r
1814   if ( len<0)\r
1815     {\r
1816       random_len=1;\r
1817       len=-len;\r
1818     }\r
1819   \r
1820   vsrand(0);\r
1821 \r
1822   if (pos==0)pos= (rand()%(A->len_aln-(2*len+len))) +len;\r
1823   \r
1824    \r
1825   for ( a=0; a< A->nseq; a++)\r
1826         {\r
1827           if (random_len)left =rand()%len;\r
1828           else left=len;\r
1829           if (random_len)right=rand()%len;\r
1830           else right=len;\r
1831           if ( (pos-right)<0 || (pos+left)>A->len_aln)\r
1832             {\r
1833               add_warning ( stderr, "\nWarning: probabilistic_rm_aa, pos out of range [%s]\n", PROGRAM);\r
1834             }\r
1835           else\r
1836             for ( b=pos-right; b<pos+left; b++)A->seq_al[a][b]=(b==pos)?'~':'*';\r
1837         }\r
1838 \r
1839   ungap_aln (A);\r
1840   free_sequence ( A->S, A->nseq);\r
1841   A->S=aln2seq (A);\r
1842   return A;\r
1843   \r
1844 }\r
1845           \r
1846 Alignment * remove_gap_column ( Alignment *A, char *mode)\r
1847   {\r
1848     int   a, b;\r
1849     char *p;\r
1850     int  *seq_list;\r
1851     int   nseq=0;\r
1852     int keep_col, cl;\r
1853 \r
1854 \r
1855     seq_list =vcalloc ( A->nseq, sizeof (int));\r
1856     while (  (p=strtok(mode, ":")))\r
1857       {\r
1858         mode=NULL;\r
1859         if (p[0]=='#')\r
1860           {\r
1861             seq_list[nseq++]=atoi(p+1)-1;\r
1862           }\r
1863         else if ( (a=name_is_in_list (p, A->name, A->nseq, 100))!=-1)\r
1864           {\r
1865             seq_list[nseq++]=a;\r
1866           }\r
1867       }\r
1868     \r
1869     if ( nseq==0)\r
1870       {\r
1871         for ( a=0; a< A->nseq; a++)seq_list[a]=a;\r
1872         nseq=A->nseq;\r
1873       }\r
1874 \r
1875     for ( cl=0,a=0; a<=A->len_aln; a++)\r
1876       {\r
1877         for (keep_col=1, b=0; b< nseq && keep_col; b++)\r
1878           {\r
1879             keep_col=(is_gap(A->seq_al[seq_list[b]][a]))?0:keep_col;\r
1880           }\r
1881         \r
1882         if ( keep_col)\r
1883           {\r
1884             for ( b=0; b< A->nseq; b++)\r
1885               {\r
1886                 A->seq_al[b][cl]=A->seq_al[b][a];\r
1887               }\r
1888             cl++;\r
1889           }\r
1890         else\r
1891           {\r
1892             for ( b=0; b< A->nseq; b++)\r
1893               {\r
1894                 A->seq_al[b][cl]='-';\r
1895               }\r
1896             cl++;\r
1897           }\r
1898       }\r
1899     A->len_aln=cl;\r
1900     vfree (seq_list);\r
1901     \r
1902     return A;\r
1903   }\r
1904 \r
1905 \r
1906 Alignment * ungap_sub_aln (Alignment *A, int ns, int *ls)\r
1907         {\r
1908 \r
1909         int a, b, c,t;\r
1910         int len;\r
1911 \r
1912         len=strlen ( A->seq_al[ls[0]]);\r
1913 \r
1914         for ( c=0,a=0; a<len; a++)\r
1915                 {\r
1916                 for ( t=0,b=0; b<ns; b++)\r
1917                         t+=is_gap(A->seq_al[ls[b]][a]);\r
1918                 if (t==ns);\r
1919                 else\r
1920                     {\r
1921                     for ( b=0; b<ns; b++)\r
1922                         A->seq_al[ls[b]][c]=A->seq_al[ls[b]][a];\r
1923                     c++;\r
1924                     }\r
1925                 }\r
1926          for ( b=0; b<ns; b++)A->seq_al[ls[b]][c]='\0';  \r
1927          return A;\r
1928         }\r
1929 \r
1930 Sequence * ungap_seq ( Sequence *S)\r
1931         {\r
1932           int a;\r
1933           \r
1934           if ( !S)return NULL;\r
1935           ungap(S->seq[0]);\r
1936           S->max_len=S->min_len=strlen (S->seq[0]);\r
1937           for ( a=0; a< S->nseq; a++)\r
1938             {\r
1939               ungap(S->seq[a]);\r
1940               S->len[a]=strlen (S->seq[a]);\r
1941               S->max_len=MAX(S->max_len,S->len[a]);\r
1942               S->min_len=MAX(S->min_len,S->len[a]);\r
1943             }\r
1944           return S;\r
1945           \r
1946         }\r
1947 Alignment * unalign_aln (Alignment *A, Alignment *C, int t)\r
1948 {\r
1949   int a, b, pos, len;\r
1950   Sequence *S;\r
1951   \r
1952   for (a=0; a<A->nseq; a++)\r
1953     for (b=0; b<A->len_aln; b++)\r
1954       {\r
1955         int res=C->seq_al[a][b];\r
1956         A->seq_al[a][b]=toupper(A->seq_al[a][b]);\r
1957         if ((isdigit (res) && (res-'0')<=t))\r
1958           A->seq_al[a][b]=tolower(A->seq_al[a][b]);\r
1959       }\r
1960   \r
1961   \r
1962   for (pos=-1, a=0; a<C->nseq; a++)\r
1963     {\r
1964       b=0;\r
1965       while ( C->seq_al[a][b])\r
1966         {\r
1967           int res=C->seq_al[a][b];\r
1968           if ((isdigit (res) && (res-'0')<=t))\r
1969             {\r
1970               if (pos==-1){pos=b;len=1;}\r
1971               else len++;\r
1972             }\r
1973           else if (pos!=-1)\r
1974             {\r
1975               \r
1976               C=unalign_aln_pos(C,a,pos, len);\r
1977               pos=-1;\r
1978             }\r
1979           b++;\r
1980         }\r
1981       if ( pos!=-1){C=unalign_aln_pos(C,a,pos, len);pos=-1;}\r
1982     }\r
1983   S=aln2seq (A);\r
1984   thread_seq_struc2aln (C, S);\r
1985   A=realloc_aln2 (A, A->nseq, C->len_aln+1);\r
1986   A->len_aln=C->len_aln;\r
1987   for (a=0; a<A->nseq; a++)sprintf ( A->seq_al[a], "%s", C->seq_al[a]);\r
1988   ungap_aln (A);\r
1989  \r
1990   free_sequence (S, -1);\r
1991   return A;\r
1992 }\r
1993 Alignment * unalign_aln_pos (Alignment *A, int s, int p, int l)\r
1994 {\r
1995   int a;\r
1996   char *buf;\r
1997   int unalign=0;\r
1998  \r
1999   \r
2000   buf=vcalloc (l+1, sizeof (char));\r
2001   for (a=0; a<l; a++)\r
2002     {\r
2003       buf[a]=A->seq_al[s][p+a];\r
2004       A->seq_al[s][p+a]='-';\r
2005     }\r
2006   \r
2007   \r
2008   A=insert_gap_col (A,p, l);\r
2009   for (a=0; a<l; a++)\r
2010     {\r
2011       A->seq_al[s][p+a]=buf[a];\r
2012     }\r
2013   vfree (buf);\r
2014   return A;\r
2015 }       \r
2016 Alignment * insert_gap_col (Alignment *A, int p, int l)\r
2017 {\r
2018   int a, c;\r
2019   char *buf;\r
2020   char *gap;\r
2021 \r
2022   gap=generate_null(l);\r
2023   if ( !A || p>=A->len_aln || p<0 || p<=0)return A;\r
2024   \r
2025   buf=vcalloc (A->len_aln+l+1, sizeof (char));\r
2026   A=realloc_aln2(A,A->nseq, A->len_aln+l+1);\r
2027   for (a=0; a<A->nseq; a++)\r
2028     {\r
2029       c=A->seq_al[a][p];\r
2030       A->seq_al[a][p]='\0';\r
2031       sprintf ( buf, "%s%s%c%s", A->seq_al[a],gap,c,A->seq_al[a]+p+1);\r
2032       sprintf (A->seq_al[a], "%s", buf);\r
2033     }\r
2034   vfree (buf);\r
2035   A->len_aln+=l;\r
2036   return A;\r
2037 }\r
2038 Alignment * unalign_residues (Alignment *A, int si1, int si2)\r
2039 {\r
2040   char *s1, *s2, *ns1, *ns2; \r
2041   int l, a, b,r1, r2;\r
2042   \r
2043   s1=A->seq_al[si1];s2=A->seq_al[si2];\r
2044   l=strlen (s1);\r
2045   \r
2046   ns1=vcalloc (2*l+1, sizeof (char));\r
2047   ns2=vcalloc (2*l+1, sizeof (char));\r
2048   \r
2049   for (b=a=0; a< l; a++)\r
2050     {\r
2051       r1=s1[a]; r2=s2[a];\r
2052       if (is_gap(r1) || is_gap(r2) || isupper (r1) || isupper(r2))\r
2053         {\r
2054           ns1[b]=(r1=='.')?'-':r1;\r
2055           ns2[b]=(r2=='.')?'-':r2;\r
2056           b++;\r
2057         }\r
2058       else\r
2059         {\r
2060           ns1[b]=r1;\r
2061           ns2[b]='-';\r
2062           b++;\r
2063           ns2[b]=r2;\r
2064           ns1[b]='-';\r
2065           b++;\r
2066         }\r
2067     }\r
2068   ns1[b]='\0';\r
2069   ns2[b]='\0';\r
2070   A->seq_al[si1]=ns1;\r
2071   A->seq_al[si2]=ns2;\r
2072   \r
2073 \r
2074   A->len_aln=strlen (ns1);\r
2075   return A;\r
2076 }\r
2077 Alignment *degap_aln (Alignment *A)\r
2078 {\r
2079   //Reomove all the gaps\r
2080   int a;\r
2081   for ( a=0; a< A->nseq; a++)ungap (A->seq_al[a]);\r
2082   return A;\r
2083 }\r
2084 \r
2085 Alignment *ungap_aln_n ( Alignment *A, int p)\r
2086         {\r
2087 /*remove all the columns of gap-only within an alignment*/  \r
2088         int a, b, c;\r
2089         int t;\r
2090         int gp;\r
2091 \r
2092         if ( A->nseq==0)return A;\r
2093 \r
2094         for ( c=0,a=0; a< A->len_aln; a++)\r
2095                 {\r
2096                 for ( t=0,b=0; b<A->nseq; b++)\r
2097                         t+=is_gap(A->seq_al[b][a]);\r
2098                 gp=(t*100)/A->nseq;\r
2099                 if (p>0 && (gp>=p || (t==A->nseq && p==100) || (t && p==1)));//Remove columns containing more than p% gaps\r
2100                 else if (p<0 && (gp<=p || (t==0 && p==-100) ||(t && p==-1)));//remove columns containing less than p% gaps\r
2101                 else\r
2102                   {\r
2103                     for ( b=0; b<A->nseq; b++)\r
2104                       A->seq_al[b][c]=A->seq_al[b][a];\r
2105                     c++;\r
2106                   }\r
2107                 }\r
2108         for ( b=0; b<A->nseq; b++)A->seq_al[b][c]='\0';\r
2109         A->len_aln=c; \r
2110         return A;\r
2111         }\r
2112 \r
2113 Alignment *ungap_aln ( Alignment *A)\r
2114 {\r
2115   return ungap_aln_n (A, 100);\r
2116 }\r
2117 /*\r
2118 Alignment *ungap_aln ( Alignment *A)\r
2119         {\r
2120         int a, b, c,t;\r
2121         \r
2122         for ( c=0,a=0; a< A->len_aln; a++)\r
2123                 {\r
2124                 for ( t=0,b=0; b<A->nseq; b++)\r
2125                         t+=is_gap(A->seq_al[b][a]);\r
2126                 if (t==A->nseq);\r
2127                 else\r
2128                     {\r
2129                     for ( b=0; b<A->nseq; b++)\r
2130                         A->seq_al[b][c]=A->seq_al[b][a];\r
2131                     c++;\r
2132                     }\r
2133                 }\r
2134          for ( b=0; b<A->nseq; b++)A->seq_al[b][c]='\0';\r
2135          A->len_aln=c; \r
2136          return A;\r
2137 \r
2138          }\r
2139 */\r
2140 \r
2141 \r
2142 Alignment *remove_end (Alignment *A)\r
2143         {\r
2144         int a, b, d;\r
2145         int left, right;\r
2146 \r
2147         for (a=0; a< A->len_aln; a++)\r
2148             {\r
2149             for ( b=0, d=0; b< A->nseq; b++)\r
2150                 if ( !is_gap(A->seq_al[b][a]))d++;\r
2151             if ( d>1)break;\r
2152             }\r
2153         left=a;\r
2154         for (a=A->len_aln-1; a>0; a--)\r
2155             {\r
2156             for ( b=0, d=0; b< A->nseq; b++)\r
2157                 if ( !is_gap(A->seq_al[b][a]))d++;\r
2158             if ( d>1)break;\r
2159             }\r
2160         right=a;\r
2161 \r
2162         return extract_aln(A, left, right+1);\r
2163         }\r
2164 \r
2165 Alignment* condense_aln (Alignment *A)\r
2166 {\r
2167   /* condense complementarz columns:\r
2168      X-       X\r
2169      -X  ....>X\r
2170      X-       X\r
2171 \r
2172   */\r
2173   int a, b, plen, n,m, r1, r2;\r
2174   \r
2175   plen=0;\r
2176   while ( A->len_aln !=plen)\r
2177     {\r
2178       plen=A->len_aln;\r
2179       for ( a=0; a< A->len_aln-1; a++)\r
2180         {\r
2181           for ( n=m=b=0; b< A->nseq; b++)\r
2182             {\r
2183               r1=is_gap(A->seq_al[b][a]);\r
2184               r2=is_gap(A->seq_al[b][a+1]);\r
2185               n+=(r1 || r2);\r
2186               m+=r1;\r
2187             }\r
2188         \r
2189           if ( n==A->nseq && m!=A->nseq)\r
2190             {\r
2191               for (b=0; b< A->nseq; b++)\r
2192                 {\r
2193                   if (!is_gap(A->seq_al[b][a+1]))\r
2194                       {\r
2195                         A->seq_al[b][a]=A->seq_al[b][a+1];\r
2196                         A->seq_al[b][a+1]='-';\r
2197                         }\r
2198                 }\r
2199               a++;\r
2200             }\r
2201         }\r
2202     }\r
2203   A=ungap_aln(A);  \r
2204   return A;\r
2205 }\r
2206                     \r
2207                       \r
2208                   \r
2209 \r
2210 void compress_aln ( Alignment *A)\r
2211         {\r
2212 \r
2213           /*remove all the columns of gap-only within an alignment*/  \r
2214         int a, b, c, d;\r
2215         \r
2216         \r
2217 \r
2218         for (c=0, a=0; a< A->len_aln; a++)\r
2219           {\r
2220             for ( b=0, d=0; b< A->nseq; b++)\r
2221                 if ( A->seq_al[b][a]!='-'){d=1; break;}\r
2222             if ( d==0);\r
2223             else\r
2224               {\r
2225                 for (b=0; b< A->nseq; b++)\r
2226                   A->seq_al[b][c]=A->seq_al[b][a];\r
2227               c++;\r
2228               }\r
2229           }\r
2230          A->len_aln=c;\r
2231         \r
2232         for ( a=0; a< A->nseq; a++)\r
2233           A->seq_al[a][c]='\0';\r
2234         }\r
2235 \r
2236 Alignment *seq_coor2aln ( Sequence *S, Alignment *A, int **coor, int nseq)\r
2237         {\r
2238         int a;\r
2239         char *buf;\r
2240 \r
2241         A=realloc_alignment2(A, nseq, return_maxlen ( S->seq, S->nseq)+1);\r
2242         for ( a=0; a< S->nseq; a++)sprintf ( A->file[a], "%s", S->file[a]);\r
2243         for ( a=0; a< nseq; a++)\r
2244             {\r
2245             sprintf (A->name[a], "Repeat_%d_%d", a, coor[a][0]);\r
2246             buf=extract_char ( S->seq[coor[a][0]], coor[a][1]-1, coor[a][2]);\r
2247             sprintf ( A->seq_al[a],"%s", buf);\r
2248             vfree(buf);\r
2249             A->order[a][0]=0;\r
2250             A->order[a][1]=coor[a][1]-1;\r
2251             }\r
2252         A->nseq=nseq;\r
2253         return A;\r
2254         }\r
2255 \r
2256 Alignment *strings2aln (int nseq,...)\r
2257         {\r
2258           /*strings2aln(nseq, <name1>, <seq1>, <name2>, <seq2>....)*/\r
2259           va_list ap;\r
2260           char **list, **list2;\r
2261           char **name, **name2;\r
2262           Sequence *S;\r
2263           Alignment *A;\r
2264           int a, max;\r
2265 \r
2266           va_start(ap, nseq);\r
2267           list=vcalloc (nseq, sizeof (char*));\r
2268           name=vcalloc (nseq, sizeof (char*));\r
2269           for ( a=0; a< nseq; a++)\r
2270             {\r
2271               name[a]=va_arg(ap,char*);\r
2272               list[a]=va_arg(ap,char*);\r
2273               \r
2274             }\r
2275           va_end(ap);\r
2276           \r
2277           for ( max=0,a=0; a< nseq; a++)\r
2278             {\r
2279               max=(strlen (list[a])>max)?strlen(list[a]):max;\r
2280             }\r
2281           list2=declare_char (nseq, max+1);\r
2282           name2=declare_char (nseq, MAXNAMES+1);\r
2283           \r
2284           for ( a=0; a< nseq; a++)\r
2285             {\r
2286               sprintf ( list2[a], "%s", list[a]);\r
2287               sprintf ( name2[a], "%s", name[a]);\r
2288             }\r
2289 \r
2290           \r
2291           S=fill_sequence_struc(nseq,list2,name2);\r
2292           \r
2293           free_char (list2, -1);\r
2294           free_char (name2, -1);\r
2295           vfree (list);\r
2296           vfree(name);\r
2297           A=seq2aln(S,NULL, 1); \r
2298           return A;\r
2299         }\r
2300 Alignment *seq2aln ( Sequence *S, Alignment *A,int rm_gap)\r
2301         {\r
2302         int a;\r
2303 \r
2304         A=realloc_alignment2(A, S->nseq, S->max_len+1);         \r
2305         for ( a=0; a< S->nseq; a++)sprintf ( A->file[a], "%s", S->file[a]);\r
2306         A->nseq=S->nseq;\r
2307         A->max_len=S->max_len;\r
2308         A->min_len=S->min_len;\r
2309 \r
2310         for ( a=0; a< S->nseq; a++)\r
2311                 {\r
2312                 A->order[a][0]=a;\r
2313                 A->order[a][1]=0;\r
2314 \r
2315                 sprintf ( A->seq_comment[a], "%s", S->seq_comment[a]);\r
2316                 sprintf ( A->aln_comment[a], "%s", S->aln_comment[a]);\r
2317                 \r
2318                 sprintf ( A->name[a], "%s", S->name[a]);\r
2319                 sprintf ( A->seq_al[a], "%s", S->seq[a]);\r
2320                 \r
2321                 ungap ( A->seq_al[a]);\r
2322                 A->len[a]=strlen ( A->seq_al[a]); \r
2323                 \r
2324                 if ( rm_gap==0 || rm_gap==NO_PAD)sprintf ( A->seq_al[a], "%s", S->seq[a]);\r
2325                 \r
2326                 }\r
2327         if (rm_gap!=NO_PAD)padd_aln (A);\r
2328         A->S=S;\r
2329         return A;\r
2330         }\r
2331 \r
2332 Alignment *padd_aln ( Alignment *A)\r
2333 {\r
2334   A->seq_al=padd_string (A->seq_al, A->nseq, '-');\r
2335   A->len_aln=strlen (A->seq_al[0]);\r
2336   return A;\r
2337 }\r
2338 \r
2339 char **padd_string ( char **string, int n,char pad)\r
2340 {\r
2341   /*Pads a the strings so that they all have the same length*/\r
2342   \r
2343   int max_len, a;\r
2344   char *buf;\r
2345   \r
2346   max_len=get_longest_string  (string,n, NULL, NULL);\r
2347   for (a=0; a<n; a++)\r
2348             {\r
2349             buf=generate_null (max_len-strlen (string[a]));\r
2350             strcat ( string[a], buf);   \r
2351             vfree (buf);            \r
2352             }   \r
2353   return string;\r
2354 }\r
2355 \r
2356 Alignment * trim_aln_with_seq ( Alignment *S, Alignment *P)\r
2357 {\r
2358   Alignment *A, *R;\r
2359   int a, b, c;\r
2360   static int seqindex;\r
2361   P=aln2profile (P);\r
2362   S=aln2profile (S);\r
2363   \r
2364   A=align_two_aln (S,P, "blosum62mt",-8,-1, "myers_miller_pair_wise");\r
2365   for (a=0; a<A->nseq; a++) sprintf (A->name[a], "tmpname_%d", seqindex++);\r
2366   \r
2367   R=copy_aln (A, NULL);\r
2368   for (c=0, a=0; a< A->len_aln; a++)\r
2369     {\r
2370       if ( is_gap (A->seq_al[0][a]));\r
2371       else\r
2372         {\r
2373           for ( b=0; b<A->nseq; b++)\r
2374             R->seq_al[b][c]=A->seq_al[b][a];\r
2375           c++;\r
2376         }\r
2377     }\r
2378   for ( a=0; a< A->nseq; a++)R->seq_al[a][c]='\0';\r
2379   R->len_aln=c;\r
2380   R->S=aln2seq (R);\r
2381   \r
2382   free_aln (S);\r
2383   free_aln (P);\r
2384   free_aln (A);\r
2385 \r
2386   return R;\r
2387 }\r
2388 \r
2389 Alignment * add_align_seq2aln ( Alignment *A, char *seq, char *seq_name)\r
2390         {\r
2391           if ( !A)\r
2392             {\r
2393               A=declare_aln (NULL);\r
2394               A=realloc_aln2 ( A, 1, strlen (seq)+1);\r
2395               A->nseq=0;\r
2396               sprintf ( A->name[A->nseq], "%s", seq_name);\r
2397               sprintf ( A->seq_al[A->nseq], "%s", seq);\r
2398               A->nseq++;\r
2399               \r
2400             }     \r
2401           else if ( strlen (seq)!=A->len_aln)\r
2402             {\r
2403               fprintf ( stderr, "\nError: Attempt to stack incompatible aln and aligned sequence[FATAL]\n");\r
2404               myexit (EXIT_FAILURE);\r
2405               A=NULL;\r
2406             }\r
2407           else\r
2408             {\r
2409 \r
2410               A=realloc_aln2 ( A, A->nseq+1, A->len_aln+1);\r
2411               sprintf ( A->name[A->nseq], "%s", seq_name);\r
2412               sprintf ( A->seq_al[A->nseq], "%s", seq);\r
2413               A->nseq++;\r
2414             }\r
2415           return A;\r
2416         }\r
2417   \r
2418 \r
2419 Alignment *aln2number (Alignment *A)\r
2420         {\r
2421         A->seq_al=char_array2number(A->seq_al, A->nseq);\r
2422         return A;\r
2423         }\r
2424 Sequence *seq2number (Sequence *A)\r
2425         {\r
2426         A->seq=char_array2number(A->seq, A->nseq);\r
2427         return A;\r
2428         }\r
2429 \r
2430 Sequence * aln2seq (Alignment *A)\r
2431 {\r
2432   return aln2seq_main(A, RM_GAP);\r
2433 }\r
2434 Sequence * aln2seq_main (Alignment *A, int mode)\r
2435         {\r
2436         Sequence *LS;\r
2437         int a;\r
2438         int maxlen;\r
2439         \r
2440         if ( !A) return NULL;\r
2441         else if ( A->nseq==0)return NULL;\r
2442         for (maxlen=0,a=0; a<A->nseq; a++)maxlen=MAX(maxlen, strlen (A->seq_al[a]));\r
2443 \r
2444         \r
2445         LS=declare_sequence ( maxlen+1, maxlen+1, A->nseq);\r
2446         LS->nseq=A->nseq;\r
2447         for ( a=0; a< LS->nseq; a++)\r
2448                 {\r
2449                   sprintf (LS->file[a],"%s", A->file[a]); \r
2450                 \r
2451                   sprintf ( LS->seq[a], "%s", A->seq_al[a]);\r
2452                 \r
2453                   if (mode==RM_GAP)ungap ( LS->seq[a]);\r
2454                 \r
2455                 LS->len[a]=strlen ( LS->seq[a]);\r
2456 \r
2457                 sprintf ( LS->seq_comment[a], A->seq_comment[a]);\r
2458                 sprintf ( LS->aln_comment[a], A->aln_comment[a]);\r
2459                 sprintf ( LS->name[a], "%s", A->name[a]);\r
2460                 }\r
2461         return LS;\r
2462         }\r
2463 \r
2464 Sequence  *keep_residues_in_seq ( Sequence *S, char *list, char replacement)\r
2465 {\r
2466   Alignment *A=NULL;\r
2467   int a;\r
2468   \r
2469   A=seq2aln (S, A,1);\r
2470   A=keep_residues_in_aln ( A, list, replacement);\r
2471   for ( a=0; a< A->nseq; a++)\r
2472     {\r
2473       ungap (A->seq_al[a]);\r
2474       sprintf ( S->seq[a], "%s", A->seq_al[a]);\r
2475     }\r
2476   free_aln (A);\r
2477   return S;\r
2478 }\r
2479 \r
2480 \r
2481 Alignment *aln2short_aln ( Alignment *A, char *list, char *new, int spacer)\r
2482 {\r
2483   int a, b, r, cl, l;\r
2484   char *buf;\r
2485   \r
2486   for ( a=0; a< A->nseq; a++)\r
2487     {\r
2488       buf=vcalloc ( strlen (A->seq_al[a])+1, sizeof (char));\r
2489       \r
2490       for (l=0,cl=0, b=0; b< A->len_aln; b++)\r
2491         {\r
2492           r=A->seq_al[a][b];\r
2493           if ( is_gap(r));\r
2494           else if ( is_in_set (r, list))\r
2495             {\r
2496               if (cl){cl=0; buf[l++]=new[0];}\r
2497               buf[l++]=r;\r
2498             }\r
2499           else\r
2500             {\r
2501               if ( cl==spacer){buf[l++]=new[0];cl=0;}\r
2502               cl++;\r
2503             }\r
2504           \r
2505         }\r
2506       \r
2507       buf[l]='\0';\r
2508       sprintf (A->seq_al[a], "%s", buf);\r
2509       vfree (buf);\r
2510     }\r
2511   return A;\r
2512 }\r
2513   \r
2514 Alignment *keep_residues_in_aln ( Alignment *A, char *list, char replacement)\r
2515 {\r
2516   return filter_keep_residues_in_aln (A,NULL, 0, -1, list, replacement);\r
2517 }\r
2518 Alignment *filter_keep_residues_in_aln ( Alignment *A,Alignment *ST, int use_cons, int value, char *list, char replacement)\r
2519 {\r
2520   char **sl;\r
2521   int n, a;\r
2522   \r
2523   n=strlen (list);\r
2524   sl=declare_char (n+1, 256);\r
2525   for (a=0; a< n; a++)\r
2526     sprintf ( sl[a], "%c%c", list[a], list[a]);\r
2527   sprintf ( sl[a],"#%c", replacement);\r
2528   A=filter_aln_convert (A, ST,use_cons,value, n+1, sl);\r
2529   free_char (sl, -1);\r
2530   return A;\r
2531 }\r
2532   \r
2533 \r
2534 Alignment *filter_convert_aln ( Alignment *A,Alignment *ST, int use_cons, int value, int n, ...)\r
2535 {\r
2536   va_list ap;\r
2537   char **sl;\r
2538   int a;\r
2539   va_start (ap, n);\r
2540   sl=vcalloc ( n,sizeof(char*));\r
2541   for ( a=0; a< n; a++)\r
2542     {\r
2543       sl[a]=va_arg(ap, char * );\r
2544     }\r
2545   va_end(ap);\r
2546   A=filter_aln_convert (A,ST,use_cons,value, n,sl);\r
2547   vfree(sl);\r
2548   return A;\r
2549 }\r
2550 \r
2551 Alignment * filter_aln ( Alignment *A, Alignment *ST, int value)\r
2552         {\r
2553           return filter_aln_convert (A, ST,0,value,DELETE, NULL);\r
2554         }\r
2555 Alignment * filter_aln_switchcase ( Alignment *A, Alignment *ST,int use_cons, int value)\r
2556         {\r
2557           return filter_aln_convert (A, ST,0,value,SWITCHCASE, NULL);\r
2558         }\r
2559 Alignment * filter_aln_upper_lower ( Alignment *A, Alignment *ST,int use_cons, int value)\r
2560         {\r
2561           return filter_aln_convert (A, ST,use_cons,value, LOWER, NULL);\r
2562         }\r
2563 Alignment * filter_aln_lower_upper ( Alignment *A, Alignment *ST,int use_cons, int value)\r
2564         {\r
2565           \r
2566           return filter_aln_convert (A, ST,use_cons,value, UPPER, NULL);\r
2567         }\r
2568 Alignment * STseq2STaln ( Alignment *A, Alignment *ST)\r
2569         {\r
2570           int a, i=0;\r
2571           \r
2572           if  (ST && ST->len_aln !=A->len_aln)\r
2573                 {\r
2574                   Sequence *S_T, *S_A;\r
2575 \r
2576                   S_T=aln2seq (ST);\r
2577                   S_A=aln2seq (A);\r
2578                   \r
2579                   for (a=0; a< A->nseq; a++)\r
2580                     {\r
2581                       i=name_is_in_list (A->name[a], S_T->name,S_T->nseq, 100);\r
2582                       if (i!=-1)\r
2583                         {\r
2584                           char *s1, *s2;\r
2585                           s1=(S_T)->seq[i];ungap(s1);\r
2586                           s2=(S_A)->seq[a];ungap(s2);\r
2587                           \r
2588                           if ( strlen (s1)!=strlen(s2))\r
2589                             {\r
2590                               fprintf ( stderr, "%s\n%s\n", s1, s2);\r
2591                               printf_exit (EXIT_FAILURE, stderr, "ERROR: Sequence %s has different length in the alignment and in the  structure Alignment [FATAL:%s]\n", A->name[a], PROGRAM);\r
2592                             }\r
2593                         }\r
2594                     }\r
2595                    ST=copy_aln (A, ST);\r
2596                    thread_seq_struc2aln (ST,S_T);\r
2597                 }\r
2598           \r
2599           return ST;\r
2600         }\r
2601 Alignment * merge_annotation   ( Alignment *A, Alignment *ST, char *seq)\r
2602 {\r
2603   int s, a, b;\r
2604   \r
2605   ST=STseq2STaln (A, ST);\r
2606   if ( seq==NULL)s=0;\r
2607   else\r
2608     s=name_is_in_list ( seq, A->name, A->nseq, 100);\r
2609   \r
2610   if (s==-1)\r
2611     {\r
2612       add_warning ( stderr, "\nERROR: %s is not in your MSA [FATAL: %s]", PROGRAM);\r
2613       myexit (EXIT_FAILURE);\r
2614     }\r
2615   \r
2616   for (a=0; a<A->len_aln; a++)\r
2617     {\r
2618       int t, r;\r
2619       \r
2620       t=A->seq_al[s][a];\r
2621       if (is_gap (t))continue;\r
2622       for (b=0; b<A->nseq; b++)\r
2623         {\r
2624           t=A->seq_al[s][a];\r
2625           r=ST->seq_al[b][a];\r
2626           if ( isdigit (r))\r
2627             {\r
2628               if (!isdigit(t) || (isdigit (t) && t<r))\r
2629                 A->seq_al[s][a]=r;\r
2630             }\r
2631         }\r
2632     }\r
2633   return A;\r
2634 }\r
2635            \r
2636   \r
2637 \r
2638 Alignment * filter_aln_convert ( Alignment *A, Alignment *ST,int use_cons, int value, int n_symbol,char **symbol_list)\r
2639         {\r
2640           int a, b, c;\r
2641           int st;\r
2642           int cons=0;\r
2643           \r
2644           \r
2645           ST=STseq2STaln (A, ST);\r
2646           if ( ST && use_cons)\r
2647             {\r
2648               cons=name_is_in_list ("con", ST->name,ST->nseq+1, 100);\r
2649               if ( cons==-1)cons=name_is_in_list ("cons", ST->name,ST->nseq+1, 100);\r
2650               if ( cons==-1)cons=name_is_in_list ("Cons", ST->name,ST->nseq+1, 100);\r
2651               if ( cons==-1)\r
2652                 {\r
2653                   use_cons=0;\r
2654                   fprintf (stderr, "WARNING: Could Not Use the Consensus Sequence [WARNING:%s]\n", PROGRAM);\r
2655                 }\r
2656             }\r
2657           \r
2658           A->residue_case=KEEP_CASE;\r
2659           for ( a=0; a< A->nseq; a++)\r
2660             {\r
2661               if(value!=10 && ST && !use_cons)\r
2662                 {\r
2663                   c=name_is_in_list (A->name[a], ST->name, ST->nseq,100);\r
2664                   if (c==-1)st=11;\r
2665                 }\r
2666               \r
2667               for ( b=0; b< A->len_aln; b++)\r
2668                 {\r
2669                   if ( value==10 || !ST)st=11;\r
2670                   else if ( ST && use_cons)\r
2671                     {\r
2672                       st=(isdigit(ST->seq_al[cons][b]))?ST->seq_al[cons][b]-'0':ST->seq_al[cons][b];\r
2673                     }\r
2674                   else st=(isdigit(ST->seq_al[c][b]))?ST->seq_al[c][b]-'0':ST->seq_al[c][b];\r
2675                   \r
2676                   \r
2677                   if ( st==value || value==-1 || st==NO_COLOR_RESIDUE) \r
2678                     {\r
2679                       if      ( n_symbol==UPPER  && !symbol_list)A->seq_al[a][b]=toupper (A->seq_al[a][b]);\r
2680                       else if ( n_symbol==LOWER  && !symbol_list)A->seq_al[a][b]=tolower (A->seq_al[a][b]);\r
2681                       else if ( n_symbol==SWITCHCASE && !symbol_list)\r
2682                         {\r
2683                           if ( !isalpha(A->seq_al[a][b]));\r
2684                           else if (isupper (A->seq_al[a][b]))A->seq_al[a][b]=tolower (A->seq_al[a][b]);\r
2685                           else if (islower (A->seq_al[a][b]))A->seq_al[a][b]=toupper (A->seq_al[a][b]);\r
2686                         }\r
2687                       else if ( n_symbol==DELETE && !symbol_list)A->seq_al[a][b]='-';\r
2688                       else\r
2689                         {\r
2690                           A->seq_al[a][b]=convert(A->seq_al[a][b],n_symbol,symbol_list);\r
2691                         }\r
2692                     }\r
2693                   \r
2694                 }\r
2695             }\r
2696           return A;\r
2697         }\r
2698 \r
2699 \r
2700 char ** sar_aln2motif (Alignment *A, Alignment *B, int *pos, int c);\r
2701 char ** sar_aln2motif (Alignment *A, Alignment *B, int *pos, int c)\r
2702 {\r
2703   static Alignment *I;\r
2704   static Alignment *O;\r
2705   int a, b, o, i;\r
2706 \r
2707   float tp,tn,fp,fn,best, sp, sn, sen2;\r
2708   float best_pred=-1;\r
2709   int best_motif=0;\r
2710 \r
2711 \r
2712   int n1;\r
2713   static char ***alp;\r
2714   static int *alp_size;\r
2715   \r
2716   char ***motif_list;\r
2717   int n;\r
2718   \r
2719 \r
2720   if (!I)\r
2721     {\r
2722       I=copy_aln(A, NULL);\r
2723       O=copy_aln(A, NULL);\r
2724     }\r
2725   \r
2726 \r
2727   \r
2728   I->nseq=O->nseq=I->len_aln=O->len_aln=0;\r
2729   for (a=0; a<A->len_aln; a++)\r
2730     {\r
2731       if (pos[a])\r
2732         {\r
2733           for (i=o=0,b=0; b<A->nseq; b++)\r
2734             {\r
2735               \r
2736               if ( is_gap(A->seq_al[b][a]))return 0;\r
2737               if (B->seq_al[b][c]=='I')I->seq_al[i++][I->len_aln]=A->seq_al[b][a];\r
2738               else O->seq_al[o++][O->len_aln]=A->seq_al[b][a];\r
2739             }\r
2740           I->len_aln++;\r
2741           O->len_aln++;\r
2742         }\r
2743     }\r
2744   \r
2745   if (O->len_aln==0 || I->len_aln==0) return 0;\r
2746   O->nseq=o;\r
2747   I->nseq=i;\r
2748   for (a=0; a<o; a++)O->seq_al[a][O->len_aln]='\0';\r
2749   for (a=0; a<i; a++)I->seq_al[a][I->len_aln]='\0';\r
2750 \r
2751   alp=vcalloc ( sizeof (char**), I->len_aln);\r
2752   alp_size= vcalloc ( I->len_aln, sizeof (int));\r
2753   for (a=0; a<I->len_aln; a++)\r
2754     {\r
2755       char *col;\r
2756       alp[a]=string2alphabet ( (col=aln_column2string (I,a)),2, &alp_size[a]);\r
2757       vfree (col);\r
2758     }\r
2759 \r
2760   \r
2761   \r
2762   motif_list=generate_array_string_list (I->len_aln, alp, alp_size, &n, NULL, OVERLAP);\r
2763   best_pred=best_motif=0;\r
2764   for (a=0; a<n; a++)\r
2765     {\r
2766       \r
2767       tp=tn=fp=fn=0;\r
2768       \r
2769       for (b=0; b<I->nseq; b++)\r
2770         {\r
2771           if (match_motif (I->seq_al[b], motif_list[a]))tp++;\r
2772           else fn++;\r
2773         }\r
2774       for (b=0; b<O->nseq; b++)\r
2775         {\r
2776           if (match_motif (O->seq_al[b], motif_list[a]))fp++;\r
2777           else tn++;\r
2778         }\r
2779       rates2sensitivity (tp, tn, fp, fn, &sp, &sn, &sen2, &best);\r
2780       \r
2781       if (best> best_pred)\r
2782         {\r
2783           best_pred=best;\r
2784           best_motif=a;\r
2785         }\r
2786     }\r
2787   \r
2788   output_Alignment_without_header ( I, stdout);\r
2789   fprintf ( stdout, "\n");\r
2790   output_Alignment_without_header ( O, stdout);\r
2791   \r
2792   \r
2793   fprintf ( stdout, "\nMotifCompound %d pred: %.2f motif: ", c, best_pred);\r
2794   for (n1=0, a=0; a<I->len_aln; a++) \r
2795     {\r
2796       char *m;\r
2797       int l;\r
2798       m=motif_list[best_motif][a];\r
2799       fprintf ( stdout, "[%s]-", m);\r
2800       l=strlen (m);\r
2801       n1+=(l==1 && !strm ("*",m) )?1:0;\r
2802     }\r
2803   fprintf (stdout, "SCORE: %d", n1);\r
2804   \r
2805   for (a=0; a<n; a++)vfree (motif_list[a]);\r
2806   vfree (motif_list);\r
2807   free_arrayN((void ***) alp, 3);\r
2808   vfree (alp_size);\r
2809   \r
2810   return NULL;\r
2811 }\r
2812 \r
2813 \r
2814 \r
2815 \r
2816 void explore_weight_matrix (Alignment *A, Alignment *B, int range, int n, int *array);\r
2817 void explore_weight_matrix (Alignment *A, Alignment *B, int range, int n, int *array)\r
2818 {\r
2819   int a;\r
2820   if ( n==A->len_aln)\r
2821     {\r
2822       fprintf ( stdout, "\n W:");\r
2823       for (a=0; a<A->len_aln; a++)fprintf ( stdout, "%d", array[a]);\r
2824       fprintf ( stdout, " %.4f",(float)sar_aln2r(A,B,array,0));\r
2825       return;\r
2826     }\r
2827   else\r
2828     {\r
2829       for ( a=0; a<range; a++)\r
2830         {\r
2831           array[n]=a;\r
2832           explore_weight_matrix (A, B, range, n+1, array);\r
2833         }\r
2834     }\r
2835 }\r
2836 float search_best_combo(Alignment *A, Alignment *B);\r
2837 void search_best_combo_sar_aln(Alignment *A, Alignment *B);\r
2838 void search_best_combo_sar_aln(Alignment *A, Alignment *B)\r
2839 {\r
2840   int a,b,c;\r
2841   Alignment *S;\r
2842   float s;\r
2843   int w=5;\r
2844   \r
2845   S=copy_aln (B, NULL);\r
2846   S->len_aln=w;\r
2847   for ( a=0; a<B->len_aln-w;a++)\r
2848     {\r
2849       for (b=0; b<B->nseq; b++)\r
2850         {\r
2851           for (c=0; c<w; c++)\r
2852             {\r
2853               S->seq_al[b][c]=B->seq_al[b][a+c];\r
2854             }\r
2855           S->seq_al[b][c]='\0';\r
2856             }\r
2857           \r
2858       s=search_best_combo (A, S);\r
2859       fprintf ( stdout,"\nP: XXXX \nP: XXXXX A=%d / %d", a, B->len_aln);\r
2860    \r
2861     }\r
2862    \r
2863 }\r
2864 \r
2865 float search_best_combo(Alignment *A, Alignment *B)\r
2866 {\r
2867   int a, b, c, d, best_pos,nl, max;\r
2868   float best_score, score;\r
2869   int *list, *pos;\r
2870  \r
2871   int  w;\r
2872   int combo_mode=1; //1: greedy 2: consider all thw w combinations;\r
2873   FILE *fp2;\r
2874   static int **M;\r
2875   max=2;\r
2876   int delta=0;\r
2877   w=1;\r
2878   \r
2879   pos=vcalloc ( A->len_aln, sizeof (int));\r
2880   list=vcalloc (A->len_aln, sizeof (int));\r
2881   nl=0;\r
2882   \r
2883   if ( combo_mode==1)\r
2884     {\r
2885       for (a=0; a< max; a++)\r
2886         {\r
2887           for (best_score=-9999,best_pos=0,b=0; b< A->len_aln-w; b++)\r
2888             {\r
2889               for (c=0; c<nl; c++)pos[list[c]]=1;\r
2890               for (c=0; c<w; c++)pos[b+c]=1;\r
2891               score=sar_aln2r(A,B,pos,0);\r
2892               if ( score>best_score)\r
2893                 {\r
2894                   best_score=score;\r
2895                   best_pos=b;\r
2896                 }\r
2897               for (c=0; c<w; c++)pos[b+c]=0;\r
2898             }\r
2899           if (best_pos==list[nl-1])break;\r
2900           list[nl++]=best_pos;\r
2901           for (b=0; b<nl; b++) pos[list[b]]=1;\r
2902           fprintf ( stdout, "\n%2d P: %d S:%.3f Delta= %d", nl,best_pos, best_score, (int)sar_aln2delta(A,B, pos,0));\r
2903           for (b=0; b<nl; b++) pos[list[b]]=0;    \r
2904          \r
2905 \r
2906         }\r
2907       for (a=0; a<nl; a++) pos[list[a]]=1;\r
2908       fprintf ( stdout, "\nR: %3f " ,(float)sar_aln2r(A,B,pos,1));\r
2909    \r
2910     }\r
2911   else if ( combo_mode==2)\r
2912     {\r
2913       int  *array;\r
2914       char *tmpf;\r
2915       FILE *fp;\r
2916       char *buf=NULL;\r
2917       int *preset,  n_preset;\r
2918       \r
2919       tmpf=vtmpnam (NULL);\r
2920       max=1;\r
2921       generate_array_int_list (max, 0,A->len_aln-1, 1,NULL, tmpf);\r
2922       printf_system ( "cp %s testfile", tmpf);\r
2923       buf=vcalloc ( 1000, sizeof (char));\r
2924       fp=vfopen (tmpf, "r");\r
2925       best_score=-99999;\r
2926       \r
2927       n_preset=0;\r
2928       preset=vcalloc (A->len_aln, sizeof (int));\r
2929       preset[n_preset++]=353;\r
2930       preset[n_preset++]=361;\r
2931       //preset[n_preset++]=365;\r
2932       //preset[n_preset++]=187;\r
2933       //preset[n_preset++]=397;\r
2934       //preset[n_preset++]=492;\r
2935 \r
2936       \r
2937       while ( (buf=vfgets ( buf, fp))!=NULL)\r
2938         {\r
2939 \r
2940           array=string2num_list (buf);\r
2941 \r
2942           for (a=1; a<=max; a++)\r
2943             {\r
2944               pos[array[a]]=1;\r
2945             }\r
2946           for ( a=0; a<n_preset; a++)pos[preset[a]]=1;\r
2947                                          \r
2948           score=sar_aln2r(A,B,pos,0);\r
2949           \r
2950           if ( score>best_score)\r
2951             {\r
2952               best_score=score;\r
2953               fprintf ( stdout, "\n");\r
2954               for (a=0; a<n_preset; a++)fprintf (stdout, "%2d ", preset[a]);\r
2955               for (a=1; a<=max; a++)fprintf (stdout, "%2d ", array[a]);\r
2956               fprintf ( stdout, " R: %.3f", best_score);\r
2957               for (nl=0,a=0; a<n_preset; a++)list[nl++]=preset[a];\r
2958               for (a=1; a<=max; a++)list[nl++]=array[a];\r
2959             }\r
2960           //if ( score!=0)HERE ("R=%.2f", score);\r
2961           for (b=1; b<=max; b++)\r
2962             pos[array[b]]=0;\r
2963           vfree (array);\r
2964         }\r
2965       fprintf ( stdout, "\n");\r
2966       vfclose (fp);\r
2967       //for (a=0; a<max; a++)fprintf (stdout, "%2d ", array[best_pos][a]);\r
2968       //fprintf ( stdout, " R: %.3f", best_score);\r
2969     }\r
2970   for (c=0; c<B->len_aln; c++)\r
2971     {\r
2972       sar_aln2motif (A,B,pos, c);\r
2973       \r
2974     }\r
2975   exit (0);\r
2976   HERE ("***************");\r
2977   fp2=vfopen ("aln.aln", "w");\r
2978   for (a=0; a<A->nseq; a++)\r
2979     {\r
2980       fprintf (fp2, ">%s\n", A->name[a]);\r
2981       for ( b=0; b<nl; b++)fprintf (fp2, "%c", A->seq_al[a][list[b]]);\r
2982       fprintf ( fp2, "\n");\r
2983     }\r
2984   vfclose (fp2);\r
2985   HERE ("Output aln.aln");\r
2986   if (1)\r
2987     {\r
2988       float tp=0, tn=0, fp=0, fn=0, pp2=0,pp=0, sn,sn2, sp;\r
2989       int **result,**result2,**compound_score, *ref_score,n2,n, s, p, c;\r
2990       Alignment *AI, *AO;\r
2991       int simI, simO;\r
2992       \r
2993       compound_score=declare_int (B->len_aln, 2);\r
2994       ref_score=vcalloc (nl, sizeof (int));\r
2995       \r
2996       result=declare_int (B->len_aln*A->nseq*A->nseq, 2);\r
2997       result2=declare_int (B->len_aln*A->nseq*A->nseq, 2);\r
2998                           \r
2999       for (n2=c=0; c< B->len_aln; c++)\r
3000         {\r
3001          \r
3002           int sar1, sar2;\r
3003           pp=tp=tn=fp=fn=0;\r
3004           if (!M)M=read_matrice ("blosum62mt");\r
3005           for (n=0,a=0; a<A->nseq-1; a++)\r
3006             {\r
3007               for (b=a+1; b<A->nseq;b++)\r
3008                 {\r
3009                   for (s=0,p=0; p<nl; p++)\r
3010                     {\r
3011                       char r1, r2;\r
3012                       \r
3013                       r1=A->seq_al[a][list[p]];\r
3014                       r2=A->seq_al[b][list[p]];\r
3015                       if ( !is_gap (r1) && !is_gap(r2))s+=M[r1-'A'][r2-'A'];\r
3016                     }\r
3017                   result2[n2][0]=result[n][0]=s;\r
3018                   \r
3019                   sar1=B->seq_al[a][c];sar2=B->seq_al[b][c];\r
3020                   \r
3021                   if (sar1=='I' && sar1==sar2)\r
3022                     {\r
3023                       result2[n2][1]=result[n][1]=1;\r
3024                       pp++;pp2++;\r
3025                       n++;n2++;\r
3026                     }\r
3027                   else if ( sar1==sar2 && sar1=='O')\r
3028                     {\r
3029                       ;\r
3030                     }\r
3031                   else\r
3032                     {\r
3033                       result2[n2][1]=result[n][1]=0;\r
3034                       n++;n2++;\r
3035                     }\r
3036                   //else if ( s1==s2=='O')result[n][1]=-1;\r
3037                 }\r
3038             }\r
3039         \r
3040           if (pp==0)continue;\r
3041           sort_int_inv (result, 2, 0, 0, n-1);\r
3042          \r
3043           \r
3044           for (tp=0,a=0; a<n; a++)\r
3045             {\r
3046               tp+=result[a][1];\r
3047               if ((pp-tp) == (a-tp))break;\r
3048             }\r
3049           fp=a-tp;\r
3050           fn=pp-tp;\r
3051           tn=n-pp;\r
3052           \r
3053           sn=(tp/(tp+fn));\r
3054           sn2=(tp/(tp+fp));\r
3055           sp=(tn/(tn+fp));\r
3056           fprintf ( stdout, "\nCompound %3d sn: %.3f sn2: %.3f sp: %.3f MIN: %.3f",c,sn, sn2,sp, MIN((MIN(sn,sn2)),sp));\r
3057           compound_score[c][0]=c;\r
3058           compound_score[c][1]=1000*MIN((MIN(sn,sn2)),sp);\r
3059         }\r
3060       \r
3061       sort_int_inv (compound_score,2, 1, 0, B->len_aln-1);\r
3062 \r
3063       fp2=vfopen ("compound.fasta", "w");\r
3064       for (d=0; d<nl; d++)\r
3065         {\r
3066           int r1, r2;\r
3067           for (n=0,a=0;a<A->nseq; a++)\r
3068             for (b=0; b<A->nseq; b++)\r
3069               {\r
3070                 r1= A->seq_al[b][list[d]];\r
3071                 r2= A->seq_al[b][list[d]];\r
3072                 if (is_gap(r1) || is_gap(r2))continue;\r
3073                 else \r
3074                   {\r
3075                     ref_score[d]+=M[r1-'A'][r2-'A'];\r
3076                     n++;\r
3077                   }\r
3078               }\r
3079           ref_score[d]/=n;\r
3080         }\r
3081       AO=copy_aln (A, NULL);\r
3082       AI=copy_aln (A,NULL);\r
3083       AO->len_aln=AI->len_aln=nl;\r
3084       for (a=0; a<A->nseq; a++)AO->seq_al[a][nl]=AI->seq_al[a][nl]='\0';\r
3085       \r
3086       for (a=0; a<B->len_aln; a++)\r
3087         {\r
3088           fprintf (stdout, "\n>%4d %4d ", compound_score[a][0], compound_score[a][1]);\r
3089           for (b=0; b<B->nseq; b++) fprintf (stdout, "%c", B->seq_al[b][compound_score[a][0]]);\r
3090           fprintf ( stdout, "\n");\r
3091           \r
3092           for (AI->nseq=0,b=0; b<B->nseq; b++)\r
3093             {\r
3094               if (B->seq_al[b][compound_score[a][0]]=='O')continue;\r
3095               fprintf ( stdout, "\n\t");\r
3096               for (c=0; c<nl; c++)\r
3097                 {\r
3098                   fprintf ( stdout, "%c", A->seq_al[b][list[c]]);\r
3099                   AI->seq_al[AI->nseq][c]=A->seq_al[b][list[c]];\r
3100                 }\r
3101               AI->nseq++;\r
3102             }\r
3103           fprintf ( stdout, "\n\t");\r
3104           for (d=0; d<nl; d++)\r
3105             {\r
3106               for (score=0,n=0,b=0; b<B->nseq; b++)\r
3107                 {\r
3108                   if (B->seq_al[b][compound_score[a][0]]=='O')continue;\r
3109                   for (c=0; c<B->nseq; c++)\r
3110                     {\r
3111                       if (B->seq_al[c][compound_score[a][0]]=='O')continue;\r
3112                       {\r
3113                         int r1, r2;\r
3114                         \r
3115                         r1= A->seq_al[b][list[d]];\r
3116                         r2= A->seq_al[b][list[d]];\r
3117                         if (is_gap(r1) || is_gap(r2))continue;\r
3118                         else score+=M[r1-'A'][r2-'A'];\r
3119                         n++;\r
3120                       }\r
3121                     }\r
3122                 }\r
3123               score/=n;\r
3124               if ((float)score/(float)ref_score[d]>1.2)fprintf ( stdout, "*");\r
3125               else fprintf ( stdout, " ");\r
3126             }\r
3127           for (AO->nseq=0,b=0; b<B->nseq; b++)\r
3128             {\r
3129               if (B->seq_al[b][compound_score[a][0]]=='I')continue;\r
3130               fprintf ( stdout, "\n\t");\r
3131               for (c=0; c<nl; c++)\r
3132                 {\r
3133                   AO->seq_al[AO->nseq][c]=A->seq_al[b][list[c]];\r
3134                   fprintf ( stdout, "%c", A->seq_al[b][list[c]]);\r
3135                 }\r
3136               AO->nseq++;\r
3137             }\r
3138           simI=aln2sim (AI, "blosum62mt"); simO=aln2sim (AO, "blosum62mt");\r
3139           fprintf ( stdout, "\nDELTA: I: %d O: %d %d",simI,simO, simI-simO);\r
3140           delta+=simI-simO;\r
3141         }\r
3142 \r
3143       for ( a=0; a<B->nseq; a++)\r
3144         {\r
3145 \r
3146           fprintf ( fp2, ">%s\n", B->name[a]);\r
3147           for (b=0; b<B->len_aln/2; b++)\r
3148             fprintf ( fp2, "%c", B->seq_al[a][compound_score[b][0]]);\r
3149           fprintf (fp2, "\n");\r
3150         }\r
3151       vfclose (fp2);\r
3152       HERE ("OUTPUT compound.fasta");\r
3153       result=result2;\r
3154       n=n2;\r
3155       pp=pp2;\r
3156       \r
3157       sort_int_inv (result, 2, 0, 0, n-1);\r
3158          \r
3159           \r
3160       for (tp=0,a=0; a<n; a++)\r
3161         {\r
3162           tp+=result[a][1];\r
3163           if ((pp-tp) == (a-tp))break;\r
3164         }\r
3165       fp=a-tp;\r
3166       fn=pp-tp;\r
3167       tn=n-pp;\r
3168       \r
3169       sn=(tp/(tp+fn));\r
3170       sn2=(tp/(tp+fp));\r
3171       sp=(tn/(tn+fp));\r
3172       fprintf ( stdout, "\nTOT:  sn: %.3f sn2: %.3f sp: %.3f MIN: %.3f",sn, sn2,sp, MIN((MIN(sn,sn2)),sp));\r
3173    \r
3174     }\r
3175   HERE ("Delta= %d", delta);\r
3176   \r
3177     \r
3178   /*\r
3179   C=copy_aln(A, NULL);\r
3180   for (a=0; a< nl; a++)\r
3181     for (b=0; b<A->nseq; b++)\r
3182       C->seq_al[b][a]=A->seq_al[b][list[a]];\r
3183   C->len_aln=nl;\r
3184   array=vcalloc (C->len_aln, sizeof (int));\r
3185   explore_weight_matrix (C, B, 6,0, array);\r
3186   */\r
3187   \r
3188   return best_score;\r
3189 }\r
3190 \r
3191 \r
3192 void count_misc (Alignment *A, Alignment *B)\r
3193 {\r
3194   int **done, a, b, c, d, e,f, g, *list, n, score;\r
3195   double **slist, *r;\r
3196   int *pos;\r
3197   int w=1;\r
3198   \r
3199   search_best_combo (A,B);\r
3200   exit (0);\r
3201   pos=vcalloc (A->len_aln+1, sizeof (int));\r
3202   /*\r
3203   pos[354]=1;\r
3204   pos[362]=1;\r
3205   pos[366]=1;\r
3206   pos[398]=1;\r
3207   pos[476]=1;\r
3208   \r
3209   \r
3210   fprintf ( stdout, "\nR: %3f " ,(float)sar_aln2r(A,B,pos,1));exit (0);\r
3211   */\r
3212   for (a=0; a< A->len_aln-w; a++)\r
3213     {\r
3214       for (c=0; c<w; c++)\r
3215         {\r
3216           pos[a+c]=1;\r
3217         }\r
3218       pos[398]=1;\r
3219       pos[362]=1;\r
3220       pos[354]=1;\r
3221       pos[366]=1;\r
3222       pos[419]=1;\r
3223       pos[494]=1;\r
3224       pos[476]=1;\r
3225       pos[337]=1;\r
3226       fprintf ( stdout, "\nP: %3d  W:2 R: %3f ",a+1, (float)sar_aln2r(A,B,pos,0));\r
3227       for (c=0; c<w; c++)\r
3228           {\r
3229             pos[a+c]=0;\r
3230           }\r
3231     }\r
3232   \r
3233   exit (0);\r
3234   for (a=0; a<w; a++) pos[a]=1;\r
3235   for (a=w; a< A->len_aln-1; a++)\r
3236     {\r
3237       pos[a-w]=0;\r
3238       pos[a]=1;\r
3239       fprintf ( stdout, "\nP: %3d W:2 R: %3f ",a, (float)sar_aln2r(A,B,pos,0));\r
3240     }\r
3241         \r
3242   exit (0);\r
3243   pos[2]=1;\r
3244   pos[3]=1;\r
3245   \r
3246   \r
3247   \r
3248   explore_weight_matrix (A, B,3, 0,pos);\r
3249   exit (0);\r
3250 \r
3251   for (a=0; a<A->len_aln; a++)\r
3252     for ( b=0; b<A->len_aln; b++)\r
3253       for (c=0; c<A->len_aln; c++)\r
3254         for (d=0; d<A->len_aln; d++)\r
3255           for (f=0; f<A->len_aln; f++)\r
3256             for (g=0; g<A->len_aln; g++)\r
3257             {\r
3258               e=0;\r
3259               pos[e++]=a;\r
3260               pos[e++]=b;\r
3261               pos[e++]=c;\r
3262               pos[e++]=d;\r
3263               pos[e++]=f;\r
3264               pos[e++]=g;\r
3265               pos[e++]=-1;\r
3266               fprintf ( stdout, "\n%d %d %d %d %d %d %.3f", a, b,c,d,f, g, sar_aln2r(A,B, pos,0));\r
3267               \r
3268             }\r
3269   \r
3270   exit (0);\r
3271 \r
3272 \r
3273   slist=declare_double (A->nseq*A->nseq*10, 2);\r
3274   done=declare_int (256, 256);\r
3275   list=vcalloc ( A->nseq, sizeof (int));\r
3276   \r
3277   for (a=0; a<A->len_aln-1; a++)\r
3278     {\r
3279       for (b =0; b<256; b++)for (c=0; c<256; c++)done[b][c]=0;\r
3280       \r
3281       for (b=0; b<A->nseq-1; b++)\r
3282         {\r
3283           int r1, r2;\r
3284           r1=A->seq_al[b][a];\r
3285           r2=A->seq_al[b][a+1];\r
3286           if (done[r1][r2])continue;\r
3287           n=0;\r
3288           done[r1][r2]=1;\r
3289           list[n++]=b;\r
3290           fprintf ( stdout, "\n%3d %c%c: %s ",a+1, r1, r2, A->name[b]);\r
3291           for ( c=b+1; c<A->nseq; c++)\r
3292             {\r
3293               if (r1==A->seq_al[c][a] && r2==A->seq_al[c][a+1])\r
3294                 {\r
3295                   fprintf ( stdout, "%s ", A->name[c]);\r
3296                   list[n++]=c;\r
3297                 }\r
3298 \r
3299             }\r
3300           if (B && n>1)\r
3301             {\r
3302               for (e=0,score=0,c=0; c<n-1; c++)\r
3303                 for (d=c+1; d<n; d++,e++)\r
3304                   score+=get_sar_sim2(B->seq_al[list[c]], B->seq_al[list[d]]);\r
3305               fprintf ( stdout, " Score=%d", score/e);\r
3306             }\r
3307         }\r
3308     }\r
3309   for (score=0,e=0,a=0; a<A->nseq-1; a++)\r
3310     for (b=a+1; b<A->nseq; b++,e++)\r
3311       {\r
3312         score+=get_sar_sim2(B->seq_al[a], B->seq_al[b]);\r
3313       }\r
3314   fprintf  (stdout,"AVG=%d", score/e);\r
3315   for (n=0,a=0; a< A->nseq-1; a++)\r
3316     {\r
3317       static int **M;\r
3318       int sim;\r
3319       if (!M)M=read_matrice ("blosum62mt");\r
3320       \r
3321       \r
3322       for (b=a+1; b<A->nseq; b++)\r
3323         {\r
3324           int n11, n01, n10, n00, n1;\r
3325           \r
3326           for (sim=d=0;d<A->len_aln; d++)\r
3327             {\r
3328               int r1, r2;\r
3329               r1=A->seq_al[a][d];\r
3330               r2=A->seq_al[b][d];\r
3331               sim+=(r1==r2)?1:0;\r
3332               //sim +=(M[r1-'A'][r2-'A']>0)?1:0;\r
3333             }\r
3334           \r
3335           sim=(100*sim)/(A->len_aln);//+rand()%10;\r
3336           for (n1=n00=n11=n10=n01=score=0, d=0; d<B->len_aln; d++)\r
3337             {\r
3338               int r1, r2;\r
3339               r1=B->seq_al[a][d];\r
3340               r2=B->seq_al[b][d];\r
3341               n11+=(r1=='I' && r2=='I');\r
3342               n00+=(r1=='O' && r2=='O');\r
3343               n10+=(r1=='I' && r2=='0');\r
3344               n01+=(r1=='O' && r2=='I');\r
3345               n1+=(r1=='I' || r2=='I');\r
3346             }\r
3347           score =((n11+n00)*100)/B->len_aln;\r
3348               \r
3349           //score=get_sar_sim2(B->seq_al[a], B->seq_al[b]);\r
3350           \r
3351           fprintf ( stdout, "\nSIM: %d SC: %d", sim, score);\r
3352           slist[n][0]=(double)sim;\r
3353           slist[n][1]=(double)score;\r
3354           n++;\r
3355         }\r
3356     }\r
3357   r=return_r(slist, n);\r
3358   fprintf ( stdout, "\nR= %.4f", (float)r[0]);\r
3359   exit (0);\r
3360 }\r
3361 \r
3362 int aln2ngap ( Alignment *A)\r
3363 {\r
3364   int ngap=0, a, b;\r
3365   for (a=0; a< A->len_aln; a++)\r
3366     for (b=0; b<A->nseq; b++) ngap+=is_gap (A->seq_al[b][a]);\r
3367   return ngap;\r
3368 }\r
3369 int  * count_in_aln ( Alignment *A, Alignment *ST, int value, int n_symbol,char **symbol_list, int *table)\r
3370         {\r
3371           int a, b, c=0, d;\r
3372           int st;\r
3373           \r
3374           if (!table)table=vcalloc (n_symbol, sizeof (int));\r
3375 \r
3376           A->residue_case=KEEP_CASE;\r
3377           for ( a=0; a< A->nseq; a++)\r
3378                 {\r
3379                 if(value!=10 && ST)for ( c=0; c< ST->nseq; c++)if ( strm(ST->name[c], A->name[a]))break;\r
3380                 for ( b=0; b< A->len_aln; b++)\r
3381                     {\r
3382                       if ( value==10 || !ST)st=11;\r
3383                       else st=(isdigit(ST->seq_al[c][b]))?ST->seq_al[c][b]-'0':ST->seq_al[c][b];\r
3384                       if ( st==value || value==-1) \r
3385                         {\r
3386                           for ( d=0; d<n_symbol; d++)table[d]+=is_in_set ( A->seq_al[a][b], symbol_list[d]);\r
3387                         }\r
3388                     }\r
3389                 }\r
3390           return table;\r
3391         } \r
3392 \r
3393 char *dna_aln2cons_seq ( Alignment *A)\r
3394         {\r
3395         int a, b, best;\r
3396         static int **column_count;\r
3397         static int **old_tot_count;\r
3398         static int **new_tot_count;\r
3399         static char *string1, *string2;\r
3400         int **count_buf;\r
3401         char r1, r2,*seq;\r
3402         int NA=0, NG=1, NC=2, NT=3, IGAP=4;\r
3403         static int   MAX_EST_SIZE=10000;\r
3404         static int   size_increment=1000;\r
3405         static int first;\r
3406         int overlap=0, best_overlap=0;\r
3407         \r
3408 \r
3409         seq=vcalloc ( A->len_aln+1, sizeof (char));\r
3410 \r
3411         if (!column_count )\r
3412           {\r
3413             column_count=vcalloc(MAX_EST_SIZE, sizeof (int*));\r
3414             for ( a=0; a< MAX_EST_SIZE; a++)\r
3415               column_count[a]=vcalloc (5, sizeof (int));\r
3416           \r
3417             old_tot_count=vcalloc(MAX_EST_SIZE, sizeof (int*));\r
3418             new_tot_count=vcalloc(MAX_EST_SIZE, sizeof (int*));\r
3419             A->P=declare_profile( "agct-",MAX_EST_SIZE);\r
3420             string1=vcalloc (MAX_EST_SIZE, sizeof (char));\r
3421             string2=vcalloc (MAX_EST_SIZE, sizeof (char));\r
3422           }\r
3423         else if (A->len_aln>MAX_EST_SIZE)\r
3424           {\r
3425             if ( column_count)\r
3426               {\r
3427                 for ( a=0; a< MAX_EST_SIZE; a++)\r
3428                   vfree(column_count[a]);\r
3429                 vfree(column_count);\r
3430                 vfree(old_tot_count);\r
3431                 vfree(new_tot_count);\r
3432                 vfree(string1);\r
3433                 vfree(string2);\r
3434               }\r
3435             \r
3436           column_count=vcalloc(MAX_EST_SIZE+ size_increment, sizeof (int*));\r
3437           for ( a=0; a< MAX_EST_SIZE+ size_increment; a++)\r
3438               column_count[a]=vcalloc (5, sizeof (int));\r
3439           \r
3440           old_tot_count=vcalloc(MAX_EST_SIZE+ size_increment, sizeof (int*));\r
3441           new_tot_count=vcalloc(MAX_EST_SIZE+ size_increment, sizeof (int*));\r
3442           \r
3443           for (a=0; a< MAX_EST_SIZE; a++)\r
3444             {\r
3445               old_tot_count[a]=*(column_count++);\r
3446               for ( b=0; b<5; b++)old_tot_count[a][b]=(A->P)->count[b][a];\r
3447             }\r
3448           free_int ( (A->P)->count, -1);\r
3449           \r
3450           (A->P)->count=declare_int (5, MAX_EST_SIZE+ size_increment);\r
3451           (A->P)->max_len=MAX_EST_SIZE+ size_increment;\r
3452           MAX_EST_SIZE+= size_increment;\r
3453           string1=vcalloc (MAX_EST_SIZE, sizeof (char));\r
3454           string2=vcalloc (MAX_EST_SIZE, sizeof (char));\r
3455           }\r
3456         \r
3457         \r
3458         sprintf ( string1, "%s",A->seq_al[0]);\r
3459         sprintf ( string2, "%s",A->seq_al[1]);\r
3460         \r
3461 \r
3462         string1=mark_internal_gaps(string1,'.');\r
3463         string2=mark_internal_gaps(string2,'.');\r
3464 \r
3465         \r
3466         \r
3467         for (b=0,a=0; a< A->len_aln; a++)\r
3468           {\r
3469             r1=string1[a];\r
3470             r2=string2[a];\r
3471             \r
3472             if ( r1==r2)\r
3473               {\r
3474                 overlap++;\r
3475               }\r
3476             else\r
3477               {\r
3478                 best_overlap=MAX(overlap, best_overlap);\r
3479                 overlap=0;\r
3480               }\r
3481 \r
3482 \r
3483             if (!is_gap(r1) && first==1)new_tot_count[a]=old_tot_count[b++]; \r
3484             else if (is_gap(r1) || first==0){new_tot_count[a]=*column_count;column_count++;};\r
3485             \r
3486             if ( first==0)\r
3487               {\r
3488                 if(r1=='a')       new_tot_count[a][NA]++;\r
3489                 else if ( r1=='g')new_tot_count[a][NG]++;\r
3490                 else if ( r1=='c')new_tot_count[a][NC]++;\r
3491                 else if ( r1=='t')new_tot_count[a][NT]++;       \r
3492                 else if (is_gap(r1));\r
3493                 else\r
3494                   {\r
3495                    new_tot_count[a][NA]++;\r
3496                    new_tot_count[a][NG]++;\r
3497                    new_tot_count[a][NC]++;\r
3498                    new_tot_count[a][NT]++;\r
3499                   }\r
3500               }\r
3501             if ( a> 0 && a<A->len_aln-1 && r1=='.')\r
3502               {\r
3503                 new_tot_count[a][IGAP]+=((new_tot_count[a-1][NA]+new_tot_count[a-1][NG]+new_tot_count[a-1][NC]+new_tot_count[a-1][NT]));\r
3504               }\r
3505             \r
3506 \r
3507             if(r2=='a')       new_tot_count[a][NA]++;\r
3508             else if ( r2=='g')new_tot_count[a][NG]++;\r
3509             else if ( r2=='c')new_tot_count[a][NC]++;\r
3510             else if ( r2=='t')new_tot_count[a][NT]++;\r
3511             else if ( r2=='.')new_tot_count[a][IGAP]++;\r
3512             else if ( r2=='-');\r
3513             else \r
3514               {\r
3515                 new_tot_count[a][NA]++;\r
3516                 new_tot_count[a][NG]++;\r
3517                 new_tot_count[a][NC]++;\r
3518                 new_tot_count[a][NT]++; \r
3519               }\r
3520             (A->P)->count[0][a]=new_tot_count[a][NA];\r
3521             (A->P)->count[1][a]=new_tot_count[a][NG];\r
3522             (A->P)->count[2][a]=new_tot_count[a][NC];\r
3523             (A->P)->count[3][a]=new_tot_count[a][NT];\r
3524             (A->P)->count[4][a]=new_tot_count[a][IGAP];\r
3525 \r
3526             best_int(4,1, &best,new_tot_count[a][NA], new_tot_count[a][NG],new_tot_count[a][NC],new_tot_count[a][NT]); \r
3527             if( best==0)      seq[a]='a';\r
3528             else if ( best==1)seq[a]='g';\r
3529             else if ( best==2)seq[a]='c';\r
3530             else if ( best==3)seq[a]='t';\r
3531           }\r
3532 \r
3533         first=1;\r
3534 \r
3535         seq[a]='\0';\r
3536         fprintf ( stderr, "[Best Overlap: %d Residues]", best_overlap);\r
3537         count_buf=old_tot_count;\r
3538         old_tot_count=new_tot_count;\r
3539         new_tot_count=count_buf;\r
3540 \r
3541         return seq;\r
3542         \r
3543         }\r
3544 \r
3545 char *aln2cons_maj ( Alignment *A, int ns, int *ls, int n_groups, char **group_list)\r
3546         {\r
3547         char *seq;\r
3548         int a, b;\r
3549         int len;\r
3550         int clean_ls=0;\r
3551         static int *aa;\r
3552 \r
3553         if ( !aa) aa=vcalloc (1000, sizeof (int));\r
3554         \r
3555         len=strlen  (A->seq_al[ls[0]]);\r
3556         seq=vcalloc (len+1, sizeof (char));\r
3557 \r
3558         if ( ns==0)\r
3559           {\r
3560             ns=A->nseq;\r
3561             ls=vcalloc ( A->nseq, sizeof (int));\r
3562             for ( a=0; a< A->nseq; a++)ls[a]=a;\r
3563             clean_ls=1;\r
3564           }\r
3565         \r
3566         for ( a=0; a<len; a++)\r
3567             {\r
3568               int best_s=0, best_aa=0, r;\r
3569               for (b=0; b< ns; b++)\r
3570                     {\r
3571                       r=tolower(A->seq_al[ls[b]][a]);\r
3572                       aa[r]++;\r
3573                       if (!is_gap(r) && aa[r]>best_s)\r
3574                         {\r
3575                           best_s=aa[r];\r
3576                           best_aa=r;\r
3577                         }\r
3578                       seq[a]=best_aa;\r
3579                     }\r
3580                 for (best_s=0, best_aa=0,b=0; b< ns; b++)\r
3581                   {\r
3582                     aa[tolower(A->seq_al[ls[b]][a])]=0;\r
3583                   }\r
3584             }\r
3585         if ( clean_ls)vfree(ls);\r
3586         seq[a]='\0';\r
3587         \r
3588         return seq;\r
3589         }\r
3590 \r
3591 char *aln2cons_seq ( Alignment *A, int ns, int *ls, int n_groups, char **group_list)\r
3592         {\r
3593         char *seq;\r
3594         int a, b, c;\r
3595         int best_group=0;\r
3596         int aa_group=0;\r
3597         int *group;\r
3598         int len;\r
3599         int clean_ls=0;\r
3600         \r
3601         len=strlen  (A->seq_al[ls[0]]);\r
3602         seq=vcalloc (len+1, sizeof (char));\r
3603 \r
3604         if ( ns==0)\r
3605           {\r
3606             ns=A->nseq;\r
3607             ls=vcalloc ( A->nseq, sizeof (int));\r
3608             for ( a=0; a< A->nseq; a++)ls[a]=a;\r
3609             clean_ls=1;\r
3610           }\r
3611 \r
3612 \r
3613         if ( !group_list)\r
3614            {\r
3615                group_list=declare_char ( 26, 2);\r
3616                for ( a=0; a<26; a++)group_list[a][0]=a+'a';\r
3617                n_groups=26;\r
3618                aa_group=1;\r
3619            }\r
3620         \r
3621         \r
3622         for ( a=0; a<len; a++)\r
3623             {\r
3624                 group=vcalloc (n_groups+1, sizeof (int));\r
3625                 for (best_group=0,b=0; b< ns; b++)\r
3626                     {\r
3627                     if ( !is_gap(A->seq_al[ls[b]][a]))\r
3628                          {\r
3629                          for (c=0; c< n_groups; c++)\r
3630                              if ( is_in_set (tolower(A->seq_al[ls[b]][a]), group_list[c]))\r
3631                                          {group[c]++;\r
3632                                           best_group=(group[c]>group[best_group])?c:best_group;\r
3633                                          }\r
3634                          }\r
3635                     seq[a]=group_list[best_group][0];\r
3636                     }\r
3637                 vfree (group);\r
3638             }\r
3639         seq[a]='\0';\r
3640         if ( aa_group) free_char (group_list, -1);\r
3641 \r
3642         if ( clean_ls)vfree(ls);\r
3643         \r
3644         return seq;\r
3645         }\r
3646 \r
3647 Alignment *aln2conservation ( Alignment *A, int threshold,char *seq)\r
3648 {\r
3649   int a, b, c, d, i, c1, c2;\r
3650   int   *pos;\r
3651   float *eval;\r
3652   float tot=0;\r
3653   float tn=0;\r
3654   int **sim;\r
3655   int w=0;\r
3656   \r
3657   pos =vcalloc (A->len_aln, sizeof (int));\r
3658   eval=vcalloc (A->len_aln, sizeof (int));\r
3659   sim=aln2sim_mat (A, "idmat");\r
3660   if (seq)i=name_is_in_list (seq, A->name, A->nseq, 100);\r
3661   else i=0;\r
3662   \r
3663   if ( i==-1) {HERE ("%s is an unknown:sequence [FATAL]"); exit (EXIT_FAILURE);}\r
3664   \r
3665   for (a=0; a<A->len_aln; a++)\r
3666     {\r
3667       double s;\r
3668       int e;\r
3669       for (c=0,e=a-w; e<=a+w; e++)\r
3670         {\r
3671           if (e<0 || e==A->len_aln)continue;\r
3672           c1=toupper (A->seq_al[i][e]);\r
3673           for (b=0; b<A->nseq; b++)\r
3674             {\r
3675               c2=toupper (A->seq_al[b][a]);\r
3676               if (c1==c2)\r
3677                 {       \r
3678                   c++;\r
3679                   s=(double)((double)sim[i][b]/(double)(100));\r
3680                   \r
3681                 }\r
3682               else\r
3683                 {\r
3684                   s=(double)(((double)100-(double)sim[i][b])/(double)(100));\r
3685                 }\r
3686               eval[a]+=(s==0)?0:log(s);\r
3687             }\r
3688         }\r
3689       pos[a]=(c*100)/A->nseq;\r
3690       if (!is_gap(c1)){tot+=pos[a]; tn++;}\r
3691       \r
3692       if (pos[a]>=threshold)A->seq_al[i][a]=toupper (A->seq_al[i][a]);\r
3693       else A->seq_al[i][a]=tolower (A->seq_al[i][a]);\r
3694     }\r
3695   fprintf (stdout, ">%s %s [i=%d]\n%s\n", A->name[i],A->aln_comment[i],i, A->seq_al[i]);\r
3696   tot=(tn>0)?(float)tot/(float)tn:0;\r
3697   \r
3698   for (d=0,a=0; a<A->len_aln; a++)\r
3699     {\r
3700       fprintf (stdout, "# %c %4d", A->seq_al[i][a],pos[a]);\r
3701 \r
3702       \r
3703       if ( !is_gap (A->seq_al[i][a]))\r
3704         {\r
3705           fprintf (stdout, " LogOdd: %6.2f ", (tot==0 || pos[a]==0)?0:(float)log((float)pos[a]/tot));\r
3706           fprintf ( stdout, " Pos: %5d E-Val: %9.2f", ++d, eval[a]/(A->nseq));\r
3707         }\r
3708       fprintf ( stdout, "\n");\r
3709     }\r
3710   fprintf ( stdout, "#average conservation: %.2f", tot);\r
3711   exit (EXIT_SUCCESS);\r
3712 }\r
3713 char *aln2cons_seq_mat ( Alignment *A, char *mat_name)\r
3714 {\r
3715   return sub_aln2cons_seq_mat (A, A->nseq, NULL, mat_name);\r
3716 }\r
3717 char *sub_aln2cons_seq_mat2 ( Alignment *A,int ns, char **ls, char *mat_name)\r
3718 {\r
3719   char *cons;\r
3720   int *list;\r
3721   list=name_array2index_array(ls, ns, A->name, A->nseq);\r
3722   cons=sub_aln2cons_seq_mat  ( A,ns, list, mat_name);\r
3723   vfree (list);\r
3724   return cons;\r
3725 }\r
3726 \r
3727 char *sub_aln2cons_seq_mat  ( Alignment *A,int ns, int *ls, char *mat_name)\r
3728 {\r
3729  int a, b, c, s;\r
3730  char *seq, r1, r2;\r
3731  int **mat;\r
3732  int score=0, best_score=0, best_r=0;\r
3733  int len;\r
3734  int naa;\r
3735  \r
3736  mat=read_matrice (mat_name);\r
3737  len=strlen ( A->seq_al[(ls==NULL)?0:ls[0]]);\r
3738  seq=vcalloc (len+1, sizeof (char));\r
3739  for ( a=0; a<len; a++)     \r
3740    {\r
3741      for (b=0; b<20; b++)\r
3742        {\r
3743          r1=AA_ALPHABET[b];\r
3744          for ( naa=0,score=0,c=0; c<ns; c++)\r
3745            {\r
3746              s=(ls==NULL)?c:ls[c];\r
3747              if ( ls && ls[c]==-1) continue;\r
3748              else if (is_gap(A->seq_al[s][a]))continue;\r
3749              else \r
3750                {\r
3751                  naa++;\r
3752                  r2=A->seq_al[s][a];\r
3753                  score+=mat[r1-'A'][r2-'A'];\r
3754                }\r
3755            }\r
3756          if (naa==0)best_r='-';\r
3757          if ( b==0 || score>best_score){best_score=score; best_r=r1;}\r
3758        }\r
3759      seq[a]=best_r;\r
3760    }\r
3761  free_int (mat, -1);\r
3762  return seq;\r
3763 }\r
3764 \r
3765 int  seq_list2in_file ( TC_method *M, Sequence *S, char *list, char *file)\r
3766 {\r
3767   X_template *T=NULL;\r
3768   \r
3769   if ( !S)return 0;\r
3770   else\r
3771     {\r
3772       int t;\r
3773       t=tolower(M->seq_type[0]);\r
3774      \r
3775       if ( t=='s')\r
3776         {\r
3777           return seq_list2fasta_file ( S, list, file);\r
3778           \r
3779         }\r
3780       else\r
3781         {\r
3782           FILE *fp, *fp2;\r
3783           int a, n, s, c;\r
3784           int *slist;\r
3785 \r
3786 \r
3787           \r
3788           fp=vfopen ( file, "w");\r
3789           slist=string2num_list (list);\r
3790           n=slist[0];\r
3791           \r
3792           if (strlen (M->seq_type) >1)\r
3793             {\r
3794               add_warning( stderr, "\nERROR: Mixed seq_type not supported for external methods\n[FATAL:%s]", PROGRAM);\r
3795             }\r
3796           \r
3797           for ( a=2; a<n; a++)\r
3798             {\r
3799               s=slist[a];\r
3800               if (t=='p')T=(S->T[s])->P;\r
3801               else if (t=='r')T=(S->T[s])->R;\r
3802               else if (t=='g')T=(S->T[s])->G;\r
3803               \r
3804               if (!T && t=='r')\r
3805                 {\r
3806                   fprintf ( fp, ">%s\n%s%s", S->name[s], S->seq[s], LINE_SEPARATOR);\r
3807                 }\r
3808               else if ( T && T->template_file && T->template_file[0])\r
3809                 {\r
3810                   fp2=vfopen (T->template_file, "r");\r
3811                   while ( (c=fgetc (fp2))!=EOF)\r
3812                     {\r
3813                       fprintf ( fp, "%c", c);\r
3814                     }\r
3815                   fprintf (fp, "%s", LINE_SEPARATOR);\r
3816                   vfclose (fp2);\r
3817                 }\r
3818             }\r
3819 \r
3820           fprintf (fp, "TARGET_SEQ_NAME: ");\r
3821           for (a=2; a<n; a++)fprintf ( fp, "%s ", (S->name[slist[a]]));\r
3822           fprintf ( fp, "%s", LINE_SEPARATOR);\r
3823           \r
3824           vfclose (fp); vfree (slist);\r
3825           \r
3826         }\r
3827 \r
3828       return 1;\r
3829     }\r
3830 }\r
3831 \r
3832 int  seq_list2fasta_file( Sequence *S,  char *list, char *file)\r
3833         {\r
3834         FILE *fp;\r
3835         int n, a, s;\r
3836         static char *buf;\r
3837         static int blen;\r
3838         int l;\r
3839         \r
3840         \r
3841         /*Buf is used because cmalloced functions cannot go through strtok*/\r
3842         if ( !S)return 0;\r
3843         else\r
3844           {\r
3845             fp=vfopen ( file, "w");\r
3846             if ( !list)\r
3847               {\r
3848                 for ( a=0; a<S->nseq; a++)\r
3849                   {\r
3850                     fprintf ( fp, ">%s %s\n%s\n", decode_name (S->name[a], CODE),S->name[a], S->seq[a]);\r
3851                   }\r
3852               }\r
3853             else\r
3854               {\r
3855                 l=strlen (list);\r
3856                 if ( l>blen)\r
3857                   {\r
3858                     if (buf)vfree(buf);\r
3859                     buf=vcalloc ( strlen (list)+1, sizeof (char));\r
3860                     sprintf ( buf, "%s", list);\r
3861                     blen=l;\r
3862                   }\r
3863                 n=atoi(strtok (list,SEPARATORS));\r
3864                 for ( a=0; a< n; a++)\r
3865                   {\r
3866                     s=atoi(strtok (NULL, SEPARATORS));\r
3867                     fprintf ( fp, ">%s %s\n%s\n", decode_name (S->name[s], CODE), S->name[a],S->seq[s]);\r
3868                   }\r
3869               }\r
3870             vfclose (fp);\r
3871           }\r
3872         return 1;\r
3873         }\r
3874 Structure * seq2struc ( Sequence *S, Structure *ST)\r
3875         {\r
3876         int a, b;\r
3877         \r
3878         for ( a=0; a< S->nseq; a++)\r
3879             for ( b=0; b< S->len[a]; b++)\r
3880                 ST->struc[a][b+1][ST->n_fields-1]=S->seq[a][b];\r
3881         return ST;\r
3882         }\r
3883 \r
3884 void aln2struc (Alignment *A, Structure *ST) \r
3885         {\r
3886         int a, b, c;\r
3887 \r
3888         for ( a=0; a< A->nseq; a++)\r
3889             for (c=0, b=0; b< A->len_aln; b++)\r
3890                 {\r
3891                 if ( !is_gap (A->seq_al[a][b]))\r
3892                      {\r
3893                      ST->struc[a][c][ST->n_fields-1]=A->seq_al[a][b];\r
3894                      c++;\r
3895                      }\r
3896                 }\r
3897         }\r
3898 Alignment *stack_aln (Alignment *A, Alignment *B)\r
3899         {\r
3900         int a,b;\r
3901         int max_len=0, max_nseq=0;\r
3902         if ( B==NULL)return A;\r
3903         if ( A==NULL)return B;\r
3904         \r
3905         max_nseq=A->nseq+B->nseq;\r
3906         for (a=0; a< A->nseq; a++)max_len=MAX(strlen(A->seq_al[a]),max_len);\r
3907         for (a=0; a< B->nseq; a++)max_len=MAX(strlen(B->seq_al[a]),max_len);\r
3908         \r
3909         A=realloc_aln2 ( A,max_nseq,max_len+1);\r
3910         \r
3911         for (a=A->nseq,b=0; b< B->nseq; b++, a++)\r
3912             {\r
3913             sprintf ( A->seq_comment[a] , "%s", B->seq_comment[b]);\r
3914             sprintf ( A->aln_comment[a] , "%s", B->aln_comment[b]);\r
3915             \r
3916             sprintf ( A->seq_al [a] , "%s", B->seq_al [b]);\r
3917             sprintf ( A->name   [a] , "%s", B->name[b]);\r
3918             sprintf ( A->file   [a], "%s" , B->file[b]);\r
3919             A->order[a][0]=B->order[b][0];\r
3920             A->order[a][1]=B->order[b][1];\r
3921             A->score_seq[a]=B->score_seq[b];\r
3922             A->len[a]=B->len[b];\r
3923             }\r
3924         \r
3925         A->len_aln=MAX(A->len_aln, B->len_aln);\r
3926         A->nseq=A->nseq+B->nseq;\r
3927         A->score_aln=A->score_aln+B->score_aln;\r
3928         \r
3929         A->finished=A->finished+B->finished;\r
3930         return A;\r
3931         }\r
3932             \r
3933 Alignment *chseqIaln(char *name, int seq_n, int start,int len,Sequence *S, int seqIaln, Alignment *A)\r
3934         {\r
3935         char *seq;\r
3936 \r
3937         seq=extract_char ( S->seq[seq_n], start, len);\r
3938         A=realloc_aln2 (A, (A==NULL)?(seqIaln+1):MAX(A->nseq,seqIaln+1), ((A==NULL)?(strlen (seq)):MAX(strlen (seq),A->len_aln))+1);\r
3939         \r
3940         \r
3941         sprintf ( A->seq_al[seqIaln], "%s",seq);\r
3942 \r
3943         \r
3944         A->order[seqIaln][0]=seq_n;\r
3945         A->order[seqIaln][1]=start;\r
3946         sprintf ( A->name[seqIaln], "%s", name);\r
3947         A->nseq=MAX(A->nseq, seqIaln+1);\r
3948         A->len_aln=return_maxlen(A->seq_al, A->nseq);\r
3949         A->S=S;\r
3950         vfree (seq);\r
3951         return A;\r
3952         }\r
3953 \r
3954 Alignment * aln_gap2random_aa(Alignment *A)\r
3955         {\r
3956          int a, b,l;\r
3957          char alp[200];\r
3958          \r
3959          if (strm ( (A->S)->type, "PROTEIN"))\r
3960            sprintf ( alp, "acefghiklmnpqrstuvwy");\r
3961          else if ( strm ( (A->S)->type, "DNA") ||strm ( (A->S)->type, "RNA") )\r
3962            sprintf ( alp, "agct");\r
3963          l=strlen (alp);\r
3964          \r
3965          \r
3966          for (a=0; a<A->nseq; a++)\r
3967             for ( b=0; b<A->len_aln; b++)\r
3968               if ( is_gap (A->seq_al[a][b]))A->seq_al[a][b]=alp[(int)rand()%(l)];\r
3969           return A;\r
3970         }\r
3971 \r
3972 Alignment * make_random_aln(Alignment *A,int nseq, int len, char *alphabet)\r
3973         {\r
3974         int a;\r
3975         \r
3976 \r
3977         A=realloc_aln2(A, nseq, len+1);\r
3978 \r
3979         A->nseq=0;\r
3980         A->len_aln=len;\r
3981         for ( a=0; a< A->nseq; a++)sprintf ( A->file[a], "random alignment");\r
3982         for ( a=0; a< nseq; a++)\r
3983             A=add_random_sequence2aln(A,alphabet);\r
3984         return A;\r
3985         }\r
3986 Alignment * add_random_sequence2aln( Alignment *A, char *alphabet)\r
3987         {\r
3988         int a, n;\r
3989 \r
3990         vsrand(0);\r
3991 \r
3992         n=strlen(alphabet);\r
3993         A=realloc_alignment2 (A, A->nseq+1, A->len_aln+1);\r
3994         \r
3995         for ( a=0; a< A->len_aln; a++)A->seq_al[A->nseq][a]=alphabet[rand()%n];\r
3996         if (! A->name[A->nseq][0])\r
3997           {\r
3998             for ( a=0; a<10; a++)A->name[A->nseq][a]=alphabet[rand()%n];\r
3999             A->name[A->nseq][a]='\0';\r
4000           }\r
4001         \r
4002         A->nseq++;\r
4003         return A;\r
4004         }\r
4005 \r
4006 Sequence *get_defined_residues( Alignment *A)\r
4007         {\r
4008             char *buf;\r
4009             Sequence *S;\r
4010             int a, b, s, l, r;\r
4011             if ( !A || !A->S) return NULL;\r
4012 \r
4013             S=duplicate_sequence (A->S);\r
4014             for ( a=0; a< S->nseq; a++)\r
4015                 for ( b=0; b< S->len[a]; b++)S->seq[a][b]=UNDEFINED_RESIDUE;\r
4016             buf=vcalloc(A->len_aln+1,sizeof (char));\r
4017             for ( a=0; a< A->nseq; a++)\r
4018                 {\r
4019                     sprintf ( buf, "%s",A->seq_al[a]);\r
4020                     ungap(buf);\r
4021                     l=strlen (buf);\r
4022                     s=A->order[a][0];\r
4023                     \r
4024                     for ( b=1; b<= l; b++)\r
4025                         {\r
4026                         r=A->seq_cache[s][b];\r
4027                         \r
4028                         if ( r>=0)S->seq[s][r-1]=(A->S)->seq[s][r-1];\r
4029                         }\r
4030                 }\r
4031             vfree(buf);\r
4032             return S;\r
4033         }\r
4034 Alignment *thread_defined_residues_on_aln ( Alignment *A, Sequence *S1)\r
4035         {\r
4036         int a, b;\r
4037         int gap, r,s, r2;\r
4038         for ( a=0; a< A->nseq; a++)\r
4039             {\r
4040                 s=A->order[a][0];\r
4041                 r=A->order[a][1];\r
4042                 for (b=0;b< A->len_aln; b++)\r
4043                     {\r
4044                     gap=is_gap(A->seq_al[a][b]);\r
4045                     \r
4046                     if (!gap)\r
4047                         {\r
4048                         r+=!gap;\r
4049                         r2=A->seq_cache[s][r]-1;\r
4050                         \r
4051                         if (r2>=0 && S1->seq[s][r2]==UNDEFINED_RESIDUE)\r
4052                             A->seq_al[a][b]=UNDEFINED_RESIDUE;\r
4053                         }\r
4054                     }\r
4055             }\r
4056         return A;\r
4057         }\r
4058 \r
4059 int ** trim_aln_borders (char **seq1, char **seq2, int nseq)\r
4060         {\r
4061         int a, b, c,l1,l2;\r
4062         char *buf1;\r
4063         char *buf2;\r
4064         int max;\r
4065 \r
4066         \r
4067 \r
4068         \r
4069         max=MAX(get_longest_string (seq1,-1, NULL, NULL),get_longest_string (seq2,-1, NULL, NULL))+1;\r
4070         buf1=vcalloc ( max, sizeof(char));\r
4071         buf2=vcalloc ( max, sizeof(char));\r
4072         \r
4073         for ( a=0; a< nseq; a++)\r
4074             {\r
4075             sprintf ( buf1, "%s", seq1[a]);\r
4076             sprintf ( buf2, "%s", seq2[a]);\r
4077 \r
4078 \r
4079            \r
4080             ungap (buf1);\r
4081             ungap (buf2);\r
4082 \r
4083             if (str_overlap ( buf1, buf2,'*')!=0)\r
4084                 {                     \r
4085                 l1=strlen ( seq1[a]);\r
4086                 l2=strlen ( seq2[a]);\r
4087                 for ( b=0,c=0; c< l1; c++)\r
4088                     if ( !is_gap(seq1[a][c]))seq1[a][c]=buf1[b++];\r
4089                 seq1[a][c]='\0';\r
4090                 for ( b=0,c=0; c< l2; c++)\r
4091                     if ( !is_gap(seq2[a][c]))seq2[a][c]=buf2[b++]; \r
4092                 seq2[a][c]='\0';\r
4093                 }\r
4094             }\r
4095         vfree (buf1);\r
4096         vfree (buf2);\r
4097         return NULL;\r
4098 \r
4099         }\r
4100 Sequence * merge_seq    ( Sequence *IN, Sequence *OUT)\r
4101         {\r
4102         int a;\r
4103         \r
4104         if ( OUT==NULL)return duplicate_sequence (IN);\r
4105         else\r
4106             {\r
4107              if ( IN && check_list_for_dup( IN->name, IN->nseq))\r
4108                   {\r
4109                       fprintf ( stderr, "\nERROR: %s is duplicated in file %s[FATAL]\n", check_list_for_dup( IN->name, IN->nseq), IN->file[0]);\r
4110                       myexit (EXIT_FAILURE);\r
4111                   }\r
4112             for ( a=0; a< IN->nseq; a++)\r
4113                 if ((OUT=add_sequence ( IN, OUT, a))==NULL)return NULL;\r
4114             return OUT;\r
4115             }\r
4116         }\r
4117 \r
4118 Alignment *seq_name2removed_seq_name(Sequence *S, Alignment *NA, float **diff)\r
4119 {\r
4120   int a, b, rb, s;\r
4121   float min_diff;\r
4122   for (a=0; a< S->nseq; a++)\r
4123     {\r
4124       if (name_is_in_list( S->name[a], NA->name, NA->nseq, 100)!=-1) continue;\r
4125       for ( min_diff=100, s=0, b=0; b< NA->nseq; b++)\r
4126         {\r
4127           rb=name_is_in_list ( NA->name[b], S->name, S->nseq, 100);\r
4128           if ( diff[a][rb]<min_diff)\r
4129             {   \r
4130               s=b;\r
4131               min_diff=diff[a][rb];\r
4132 \r
4133             }\r
4134         }\r
4135       strcat ( NA->seq_comment[s], " ");\r
4136       strcat ( NA->seq_comment[s], S->name[a]);\r
4137     }\r
4138   return NA;\r
4139 }\r
4140   \r
4141       \r
4142               \r
4143      \r
4144 int seq_name2index (char *name, Sequence *S)\r
4145 {\r
4146   if ( !S) return -1;\r
4147   else return name_is_in_list ( name, S->name, S->nseq, MAXNAMES+1);\r
4148 }\r
4149 char * seq_name2coor ( char *s, int *start, int *end, char sep)\r
4150 {\r
4151   /*name|start|end */\r
4152   char n1[100], n2[100];\r
4153   int a=0, b=0, c=0;\r
4154   \r
4155   n1[0]=n2[0]='\0';\r
4156   start[0]=end[0]=0;\r
4157   \r
4158   while ( s[a]!=sep && s[a]!='\0')a++;\r
4159   if ( s[a]=='\0')return s;\r
4160   else \r
4161     s[a++]='\0';\r
4162 \r
4163  \r
4164   \r
4165   while ( s[a]!=sep && s[a]!='\0')n1[b++]=s[a++];\r
4166   \r
4167   if ( s[a]=='\0'){n1[b]='\0';if ( n1[0])start[0]=atoi(n1);return s;}\r
4168   else s[a++]=n1[b]='\0';\r
4169  \r
4170   \r
4171   while ( s[a]!=sep && s[a]!='\0')n2[c++]=s[a++];\r
4172   n2[c]='\0';\r
4173 \r
4174   \r
4175   if ( n1[0])start[0]=atoi(n1);\r
4176   if ( n2[0])end[0]=atoi(n2);\r
4177 \r
4178 \r
4179   return s;\r
4180 }\r
4181   \r
4182 Sequence *extract_one_seq(char *n,int start, int end, Alignment *S, int keep_name)\r
4183        {\r
4184         \r
4185          int seq, a;\r
4186          FILE*fp;\r
4187          char *name;\r
4188          Sequence *OUT_S;\r
4189          \r
4190 \r
4191          if ( n[0]=='#')seq=S->nseq;\r
4192          else if ( (seq=name_is_in_list (n, S->name, S->nseq, 100)+1)!=0);\r
4193          else if (is_number (n) && (seq=atoi(n))!=0) seq=atoi(n);\r
4194          else\r
4195            {\r
4196              fprintf ( stderr, "\nCould not find Sequence %s [FATAL]", n);\r
4197              myexit (EXIT_FAILURE);\r
4198            }\r
4199          seq--;\r
4200          \r
4201          name=vtmpnam ( NULL);\r
4202          fp=vfopen ( name, "w");\r
4203          if ( start && end &&!keep_name)fprintf (fp, ">%s_%d_%d\n",S->name[seq],start, end);\r
4204          else if ( start && end==0 && !keep_name)fprintf (fp, ">%s_%d_%d\n",S->name[seq],start,(int)strlen ( S->seq_al[seq]));\r
4205          else fprintf (fp, ">%s\n", S->name[seq]);\r
4206          \r
4207          if ( start==0 && end==0){fprintf (fp, "%s\n", S->seq_al[seq]);}\r
4208          else if (end==0){fprintf (fp, "%s\n", S->seq_al[seq]+start-1);}\r
4209          else\r
4210            {\r
4211              for ( a=start-1; a<end; a++){fprintf ( fp, "%c", S->seq_al[seq][a]);}\r
4212              fprintf ( fp, "\n");\r
4213            }\r
4214          \r
4215          \r
4216          vfclose (fp);\r
4217          OUT_S=get_fasta_sequence_num (name, NULL);\r
4218          \r
4219          return OUT_S;\r
4220        }\r
4221          \r
4222 \r
4223          \r
4224 Sequence * extract_sub_seq( Sequence  *COOR, Sequence *S)\r
4225         {\r
4226         int a, b, c,s;\r
4227         int start, end;\r
4228         \r
4229         for ( a=0; a< S->nseq; a++)\r
4230             {\r
4231             if ( (s=name_is_in_list ( S->name[a], COOR->name, COOR->nseq, 100))!=-1)\r
4232                  {\r
4233                  \r
4234                  sscanf ( COOR->seq_comment[s], "%d %d", &start, &end);\r
4235                  for (c=0,b=start-1; b< end; b++, c++)S->seq[a][c]=S->seq[a][b];\r
4236                  S->seq[a][c]='\0';\r
4237                  sprintf ( S->seq_comment[a], "%s",COOR->seq_comment[s]);\r
4238                  \r
4239                  }\r
4240             }\r
4241         S=reorder_seq ( S, COOR->name, COOR->nseq);\r
4242         return S;\r
4243         }\r
4244                  \r
4245 \r
4246 \r
4247 char *    aln_column2string (Alignment *A, int p)\r
4248   {\r
4249     char *s;\r
4250     int a;\r
4251     if (p>=A->len_aln)\r
4252       {\r
4253         HERE ("ERROR: index (p=%d) loger than aln (l=%d) [FATAL]", p, A->len_aln);\r
4254         exit (EXIT_FAILURE);\r
4255       }\r
4256     else\r
4257       {\r
4258         s=vcalloc (A->nseq+1, sizeof (char));\r
4259         for (a=0; a< A->nseq; a++)s[a]=A->seq_al[a][p];\r
4260       }\r
4261     return s;\r
4262   }\r
4263 Alignment * fix_aln_seq  ( Alignment *A, Sequence *S)\r
4264         {\r
4265         int a, b, c;\r
4266         char *buf1, *buf2;\r
4267         int g0, g1, nr0, nr1;\r
4268         int id, tot;\r
4269         Alignment *B;\r
4270 \r
4271 \r
4272         /*This function establishes the correspondance between every (1..N+1) residue of each aligned sequence\r
4273           and its correspondance in S:\r
4274           A->seq_cache[a][b]=x means that residue b of aligned sequence a corresponds to residue x of the sequence with tye same index in S\r
4275           A->seq_cache[a][b]=0 means there is no correspondance.\r
4276           a is the index of the sequence\r
4277           Applying this function is needed for turning an alignment into a constraint list\r
4278         */\r
4279         \r
4280 \r
4281         if ( S==NULL)return A;\r
4282         \r
4283         A->seq_cache=declare_int ( S->nseq, MAX((A->len_aln+1), S->max_len+1));\r
4284         \r
4285         for (a=0; a< S->nseq; a++)\r
4286           for ( b=0; b< A->len_aln; b++)A->seq_cache[a][b]=-1;\r
4287         \r
4288         buf1=buf2=NULL;\r
4289         for ( a=0; a< S->nseq; a++)\r
4290             {\r
4291             for (b=0; b< A->nseq; b++) \r
4292                 {\r
4293                 if (strm ( S->name[a], A->name[b]))\r
4294                    {\r
4295                    A->order[b][0]=a;\r
4296                    \r
4297                    vfree (buf1);\r
4298                    buf1=vcalloc ( A->len_aln+1, sizeof (char));\r
4299                    sprintf (buf1, "%s", A->seq_al[b]);\r
4300                    ungap (buf1);\r
4301                    upper_string (buf1);\r
4302                    \r
4303                    vfree(buf2);\r
4304                    buf2=vcalloc (strlen(S->seq[a])+1, sizeof (char));\r
4305                    sprintf (buf2, "%s",S->seq[a]);\r
4306                    ungap (buf2);\r
4307                    upper_string (buf2);\r
4308                    \r
4309                    \r
4310 \r
4311                    if ( strm (buf1,buf2))\r
4312                        {\r
4313                            \r
4314                            for ( c=0; c<S->len[a]; c++)A->seq_cache[a][c+1]=c+1;\r
4315                        }\r
4316                    else\r
4317                        {\r
4318                           \r
4319                            B=align_two_sequences (buf2,buf1,"blosum62mt",-4,-1, "myers_miller_pair_wise");\r
4320                            if ( getenv ("DEBUG_RECONCILIATION"))\r
4321                              {\r
4322                                fprintf (stderr, "\n[DEBUG_RECONCILIATION:fix_aln_seq]\nReconciliation of %s\nA=Ref_sequence\nB=New_seq", S->name[a]);\r
4323                                print_aln (B);\r
4324                              }\r
4325                            \r
4326                            for (id=0, tot=0,nr0=0,nr1=0,c=0; c<B->len_aln; c++)\r
4327                              {\r
4328                                g0=is_gap(B->seq_al[0][c]);\r
4329                                g1=is_gap(B->seq_al[1][c]);\r
4330                                nr0+=1-g0;\r
4331                                nr1+=1-g1;\r
4332                                if ( !g0 && !g1)\r
4333                                  {\r
4334                                    tot++;\r
4335                                    id+=(B->seq_al[0][c]==B->seq_al[1][c])?1:0;\r
4336                                    A->seq_cache[a][nr1]=nr0;\r
4337                                  }\r
4338                                else if (g0 && !g1)\r
4339                                  {\r
4340                                    A->seq_cache[a][nr1]=0;\r
4341                                  }\r
4342                              }\r
4343                            if ( ((id*100)/tot)<20)\r
4344                              {\r
4345                                print_aln (B);\r
4346                                fprintf ( stderr, "\nTwo different sequences have the same name: %s", S->name[a]);               \r
4347                                fprintf ( stderr, "\nIf %s is a PDBID, Make sure it identifies the right chain (A, B, 1, 2...)", S->name[a]);\r
4348                                fprintf ( stderr, "\nChain number or index must be added to the PDB id (i.e. 1gowA)");\r
4349                                fprintf ( stderr, "\nIf You want to use %s anyway, rename it with a non-PDB identifier such as seq_%s\n",S->name[a],S->name[a]); \r
4350                                myexit (EXIT_FAILURE);\r
4351                              }\r
4352 \r
4353                            free_sequence ( B->S, -1);\r
4354                            free_aln (B);\r
4355                        }\r
4356                    \r
4357                    }\r
4358                 }\r
4359             }\r
4360             vfree(buf1);vfree(buf2);\r
4361             return A;\r
4362         }\r
4363 \r
4364 Sequence * add_prf2seq  ( char *file, Sequence *S)\r
4365     {\r
4366       char **new_seq;\r
4367       Sequence *NS;\r
4368       \r
4369       if ( !is_aln (file)&& !is_seq (file))return S;\r
4370       else\r
4371         {\r
4372           X_template *R;\r
4373           Alignment *A;\r
4374         \r
4375 \r
4376           R=fill_R_template(file,file, S);\r
4377         \r
4378           A=(R->VR)->A;\r
4379           ((R->VR)->A)->expand=1;\r
4380           new_seq=declare_char (1,A->len_aln+1);\r
4381           sprintf ( new_seq[0], "%s",aln2cons_seq_mat(A, "blosum62mt"));\r
4382           \r
4383           NS=fill_sequence_struc(1, new_seq,A->file);\r
4384           S=add_sequence (NS, S, 0);\r
4385           (S->T[S->nseq-1])->R=R;\r
4386           \r
4387           free_sequence (NS, NS->nseq);\r
4388           free_char( new_seq, -1);\r
4389           \r
4390           return S;\r
4391         }\r
4392     }\r
4393 int prf_in_seq ( Sequence *S)\r
4394 {\r
4395   int a;\r
4396   \r
4397   if ( !S) return 0;\r
4398   else \r
4399     {\r
4400       for ( a=0; a< S->nseq; a++)\r
4401         if (seq2R_template_profile(S, a)) return 1;\r
4402     }\r
4403   return 0;\r
4404 }\r
4405 Sequence * add_sequence ( Sequence *IN, Sequence *OUT, int i)\r
4406     {\r
4407       int s, a;\r
4408    \r
4409     char *buf;\r
4410     if (OUT==NULL)\r
4411       {\r
4412         \r
4413         OUT=duplicate_sequence (IN);\r
4414         return OUT;\r
4415       }\r
4416     for (a=0; a<OUT->nseq; a++)\r
4417       {\r
4418         Alignment *P;\r
4419         P=seq2R_template_profile (OUT, a);\r
4420         if (!P) continue;\r
4421         else if (name_is_in_list (IN->name[i], P->name, P->nseq, 100)!=-1) return OUT;\r
4422       }\r
4423     \r
4424     /*Adds sequence i of IN at the end of OUT*/\r
4425     \r
4426     if ((s=name_is_in_list ( IN->name[i], OUT->name, OUT->nseq,STRING))==-1 )\r
4427        {\r
4428          OUT=realloc_sequence (OUT, OUT->nseq+1, IN->len[i]);    \r
4429          sprintf ( OUT->name[OUT->nseq],"%s",IN->name[i]);\r
4430          sprintf ( OUT->file[OUT->nseq],"%s",IN->file[i]);\r
4431          sprintf ( OUT->seq_comment[OUT->nseq],"%s",IN->seq_comment[i]);\r
4432          sprintf ( OUT->aln_comment[OUT->nseq],"%s",IN->aln_comment[i]);\r
4433          \r
4434          sprintf ( OUT->seq[OUT->nseq],"%s",IN->seq[i]);\r
4435          OUT->len[OUT->nseq]=IN->len[i];\r
4436          OUT->T[OUT->nseq][0]=IN->T[i][0];\r
4437          OUT->nseq++;\r
4438          return OUT;\r
4439        }\r
4440     else if ( s!=-1 && !case_insensitive_strcmp ( IN->seq[i], OUT->seq[s]))\r
4441        {\r
4442 \r
4443          if ( getenv4debug("DEBUG_RECONCILIATION"))fprintf ( stderr,"[DEBUG_RECONCILIATION:add_sequence]\n%s\n%s\n", IN->seq[i], OUT->seq[s]);\r
4444          \r
4445          add_warning (stderr, "WARNING: DISCREPANCY:%s in [%s] and  [%s]\n", IN->name[i], IN->file[i], OUT->file[s]);\r
4446          \r
4447          \r
4448        if (((buf=build_consensus(IN->seq[i], OUT->seq[s],"cfasta_pair_wise" ))!=NULL)||((buf=build_consensus(IN->seq[i], OUT->seq[s],"myers_miller_pair_wise" ))!=NULL))\r
4449            {\r
4450             \r
4451              OUT->max_len=MAX(OUT->max_len, strlen(buf));\r
4452              OUT->min_len=MIN(OUT->min_len, strlen(buf));\r
4453              OUT->seq    =realloc_char ( OUT->seq, -1, -1,OUT->nseq,OUT->max_len+1);\r
4454              \r
4455              sprintf ( OUT->seq[s],"%s",buf);\r
4456              OUT->len[s]=strlen (buf);\r
4457              vfree (buf);\r
4458              return OUT;\r
4459            }\r
4460        else\r
4461          {\r
4462            fprintf ( stderr, "IMPOSSIBLE TO RECONCILIATE SOME SEQUENCES[FATAL:%s]\n", PROGRAM);\r
4463            print_aln ( align_two_sequences (IN->seq[i], OUT->seq[s], "idmat", 0, 0, "fasta_pair_wise"));\r
4464            myexit (EXIT_FAILURE);\r
4465            return NULL;\r
4466          }\r
4467        \r
4468        }\r
4469     else\r
4470        {\r
4471        return OUT;\r
4472        }\r
4473     }\r
4474                            \r
4475 \r
4476 Sequence  * trim_seq       ( Sequence  *A, Sequence  *B)\r
4477         {\r
4478         int a;\r
4479         Sequence *R;\r
4480         \r
4481         if (A->nseq>B->nseq)\r
4482           {\r
4483             Sequence *I;\r
4484             I=A;A=B;B=I;\r
4485           }\r
4486 \r
4487         R=declare_sequence (MIN(A->min_len,B->min_len), MAX(A->max_len, B->max_len), MIN(A->nseq, B->nseq));\r
4488         R->nseq=0;\r
4489         \r
4490         for (a=0; a< A->nseq; a++)\r
4491             {  \r
4492             if ( name_is_in_list ( A->name[a], B->name, B->nseq,STRING+1)!=-1)\r
4493                 {\r
4494                   sprintf ( R->name[R->nseq], "%s", A->name[a]);\r
4495                   sprintf ( R->seq[R->nseq], "%s", A->seq[a]);\r
4496                   sprintf ( R->file[R->nseq], "%s", A->file[a]);\r
4497                   sprintf ( R->aln_comment[R->nseq], "%s", A->aln_comment[a]);\r
4498                   sprintf ( R->seq_comment[R->nseq], "%s", A->seq_comment[a]);\r
4499                   \r
4500                   R->len[R->nseq]=A->len[a];\r
4501                   R->nseq++;\r
4502                 }\r
4503             }\r
4504         return R;\r
4505         }\r
4506 \r
4507 Sequence * trim_aln_seq ( Alignment *A, Alignment *B)\r
4508         {\r
4509         int a;\r
4510         static char **name_list;\r
4511         int n=0;\r
4512         Sequence *SA, *SB;\r
4513         int **cache_A=NULL;\r
4514         int **cache_B=NULL;\r
4515         int * p;\r
4516 \r
4517         /*This function inputs two alignments A and B\r
4518           It removes sequences that are not common to both of them\r
4519           It rearange the sequences so that they are in the same order\r
4520           A decides on the order\r
4521           The Sequences (A->S) and (B->S) are treated the same way\r
4522           Sequences are also merged in order to detects discrepencies.\r
4523           A pointer to S is returned\r
4524         */\r
4525         if (name_list)free_char (name_list, -1);\r
4526         name_list=declare_char (MAX(A->nseq, B->nseq), STRING+1);\r
4527         \r
4528         for ( a=0; a< A->nseq; a++)\r
4529             {  \r
4530             if ( name_is_in_list ( A->name[a], B->name, B->nseq,STRING)!=-1)\r
4531                 {\r
4532                 sprintf ( name_list[n++], "%s", A->name[a]);\r
4533                 }\r
4534             }\r
4535         \r
4536         \r
4537         \r
4538         reorder_aln ( A, name_list, n);\r
4539         if (A->seq_cache)cache_A=duplicate_int (A->seq_cache, -1, -1);\r
4540         if (B->seq_cache)cache_B=duplicate_int (B->seq_cache, -1, -1);\r
4541         reorder_aln ( B, name_list, n);\r
4542         for ( a=0; a< n; a++)\r
4543           {\r
4544             if ( cache_A)\r
4545               {\r
4546                 p=A->seq_cache[A->order[a][0]];\r
4547                 A->seq_cache[A->order[a][0]]=cache_A[a];\r
4548                 cache_A[a]=p;\r
4549               }\r
4550            if ( cache_B)\r
4551               {\r
4552                 p=B->seq_cache[B->order[a][0]];\r
4553                 B->seq_cache[B->order[a][0]]=cache_B[a];\r
4554                 cache_B[a]=p;\r
4555               } \r
4556            A->order[a][0]=B->order[a][0]=a;\r
4557           }\r
4558         free_int(A->seq_cache, -1);\r
4559         free_int(B->seq_cache, -1);\r
4560 \r
4561         A->seq_cache=cache_A;\r
4562         B->seq_cache=cache_B;\r
4563           \r
4564 \r
4565         \r
4566         SA=aln2seq(A);\r
4567         SB=aln2seq(B);\r
4568         \r
4569         A->S=B->S=merge_seq (SA, SB);\r
4570         return A->S;\r
4571         }\r
4572 Sequence * trim_aln_seq_name ( Alignment *A, Alignment *B)\r
4573         {\r
4574         int a;\r
4575         Sequence *S;\r
4576         \r
4577         /*This function inputs two alignments A and B\r
4578           It removes sequences that are not common to both of them\r
4579           It rearange the sequences so that they are in the same order\r
4580           A decides on the order\r
4581         */\r
4582         S=declare_sequence ( 1, 1, A->nseq+B->nseq);\r
4583         S->nseq=0;\r
4584         for ( a=0; a< A->nseq; a++)\r
4585             {  \r
4586             if ( name_is_in_list ( A->name[a], B->name, B->nseq,STRING)!=-1)\r
4587                 {\r
4588                 sprintf ( S->name[S->nseq++], "%s", A->name[a]);\r
4589                 }\r
4590             }\r
4591         return S;\r
4592         }\r
4593 \r
4594 \r
4595 \r
4596 char ** rm_name_tag (char **name, int nseq, char *tag)\r
4597 {\r
4598   int a , b, ntag;\r
4599   char **tag_list;\r
4600   char *s;\r
4601   char **template_list; \r
4602   if ( !name )return NULL;\r
4603 \r
4604   tag_list=declare_char (10, 4);\r
4605 \r
4606   if ( tag)\r
4607     {\r
4608       ntag=1; sprintf ( tag_list[0], "%s", tag);\r
4609     }\r
4610   else\r
4611     {\r
4612       ntag=0;\r
4613       sprintf ( tag_list[ntag++], "_S_");\r
4614       sprintf ( tag_list[ntag++], "_G_");\r
4615     }\r
4616   template_list=declare_char (nseq, 100);\r
4617   for ( a=0; a<nseq ; a++)\r
4618     {\r
4619       for ( b=0; b<ntag; b++)\r
4620         {\r
4621         s=strstr(name[a], tag_list[b]);\r
4622         if ( s)\r
4623           {\r
4624             s[0]='\0';\r
4625             s[2]='\0';\r
4626             sprintf ( template_list[a], ">%s _%s_ %s", name[a], s+1, s+3);\r
4627             break;\r
4628           }\r
4629         }\r
4630     }\r
4631                 \r
4632   free_char (tag_list, -1);     \r
4633   return template_list;\r
4634 }\r
4635 Sequence * swap_header ( Sequence *S, Sequence *H)\r
4636 {\r
4637   int a, b, n;\r
4638 \r
4639   for ( a=0; a< S->nseq; a++)\r
4640     {\r
4641       if ( (n=name_is_in_list (S->name[a],H->name, H->nseq, 1000))!=-1)\r
4642            {\r
4643              char **list;\r
4644 \r
4645              \r
4646              list=string2list (H->seq_comment[n]);\r
4647              if ( list==NULL || atoi(list[0])==1)continue;\r
4648              S->seq_comment[a]='\0';\r
4649              sprintf (S->name[a], "%s%s%s",H->name[n], list[1], list[2]);\r
4650              vfree ( S->seq_comment[a]);S->seq_comment[a]=vcalloc ( strlen (H->seq_comment[n])+1, sizeof (char));\r
4651              for (b=3; b< atoi(list[0]); b++)S->seq_comment[a]=strcat (S->seq_comment[a], list[b]);\r
4652              free_char (list, -1);\r
4653            }\r
4654     }\r
4655   return S;\r
4656 }\r
4657 \r
4658 \r
4659 Sequence * profile_seq2template_seq ( Sequence *S, char *template_file, Fname *F)\r
4660 {\r
4661   /*This function fetches potential templates associated with sequences within a profile*/\r
4662   int i;\r
4663   Alignment *A;\r
4664   char *tmp;\r
4665 \r
4666   if ( !check_file_exists (template_file)) return S;\r
4667   tmp=vtmpnam (NULL);\r
4668   for ( i=0; i< S->nseq; i++)\r
4669     {\r
4670       if ( (A=seq2R_template_profile (S, i)))\r
4671         {\r
4672           printf_system ("cp %s %s", template_file, tmp);//seq2template over-writes the temnplate file with a list of the templates effectively encounter\r
4673           A->S=aln2seq (A);\r
4674           A->S=seq2template_seq (A->S, tmp, F);   \r
4675           if (!A->S)return NULL;\r
4676         }\r
4677     }\r
4678 \r
4679   return S;\r
4680 }\r
4681       \r
4682 Sequence * seq2template_type(Sequence *Seq)\r
4683 {\r
4684   //add template\r
4685   int a, e;\r
4686   int s;\r
4687   struct X_template *S=NULL;\r
4688   struct X_template *P=NULL;\r
4689   struct X_template *R=NULL;\r
4690   struct X_template *G=NULL;\r
4691   struct X_template *F=NULL;\r
4692   struct X_template *T=NULL;\r
4693   struct X_template *E=NULL;\r
4694   struct X_template *U=NULL;\r
4695   Alignment *A;\r
4696 \r
4697 \r
4698   e=' ';\r
4699   for (a=0; a< Seq->nseq; a++)\r
4700     {\r
4701       if (!Seq->T[a])continue;\r
4702       //HERE ADD a Template\r
4703       P=seq_has_template (Seq, a, "_P_");\r
4704       S=seq_has_template (Seq, a, "_S_");\r
4705       R=seq_has_template (Seq, a, "_R_");\r
4706       G=seq_has_template (Seq, a, "_G_");\r
4707       F=seq_has_template (Seq, a, "_F_");\r
4708       T=seq_has_template (Seq, a, "_T_");\r
4709       E=seq_has_template (Seq, a, "_E_");\r
4710       U=seq_has_template (Seq, a, "_U_");\r
4711       \r
4712       s=(!P)?1:0;\r
4713       sprintf ( (Seq->T[a])->seq_type, "%c%c%c%c%c%c%c%c", (P)?'P':e, (S)?'S':e, (S &&!P)?'s':e,(R)?'R':e, (G)?'G':e,(T)?'T':e,(E)?'E':e,(U)?'U':e);\r
4714    \r
4715       if (R && (A=seq2R_template_profile (Seq,a)))\r
4716         {\r
4717         \r
4718           A->S=seq2template_type ( A->S);\r
4719         }         \r
4720     }\r
4721   return Seq;\r
4722 }\r
4723 \r
4724 char * string_contains_template_tag (char *string_in)\r
4725 {\r
4726   char string[100];\r
4727   \r
4728   if ( strstr (string, "_P_"))return "_P_";\r
4729   if ( strstr (string, "_S_"))return "_S_";\r
4730   if ( strstr (string, "_R_"))return "_R_";\r
4731   if ( strstr (string, "_G_"))return "_G_";\r
4732   if ( strstr (string, "_F_"))return "_F_";\r
4733   if ( strstr (string, "_T_"))return "_T_";\r
4734   if ( strstr (string, "_E_"))return "_E_";\r
4735   if ( strstr (string, "_U_"))return "_U_";\r
4736   \r
4737   return NULL;\r
4738 }\r
4739 static int check_blast_is_installed (char *server);\r
4740 \r
4741 \r
4742  \r
4743 static int check_blast_is_installed (char *server)\r
4744 {\r
4745   if (strm (server, "EBI"));\r
4746   else if ( strm (server, "NCBI"))\r
4747     return check_program_is_installed (NCBIWEBBLAST_4_TCOFFEE,NULL, NULL,NCBIWEBBLAST_ADDRESS, INSTALL_OR_DIE);\r
4748   else if ( strm (server, "LOCAL"))\r
4749     return check_program_is_installed (NCBIBLAST_4_TCOFFEE,NULL, NULL,NCBIBLAST_ADDRESS, INSTALL_OR_DIE);\r
4750   return 1;\r
4751 }\r
4752 \r
4753 \r
4754 Sequence * vremove_seq_template_files(Sequence *S)\r
4755 {\r
4756     return handle_seq_template_file (S, "remove");\r
4757 }\r
4758 Sequence * display_seq_template_files(Sequence *S)\r
4759 {\r
4760   return handle_seq_template_file (S, "display");\r
4761 }\r
4762 Sequence * handle_seq_template_file (Sequence *S, char *mode)\r
4763 {\r
4764   int a;\r
4765   Template *T;\r
4766   \r
4767   for (a=0; a< S->nseq; a++)\r
4768     {\r
4769       T=S->T[a];\r
4770       if (T)\r
4771         {\r
4772           handle_X_template_files (T->P, mode);\r
4773           handle_X_template_files (T->F, mode);\r
4774           handle_X_template_files (T->R, mode);\r
4775           handle_X_template_files (T->T, mode);\r
4776           handle_X_template_files (T->E, mode);\r
4777         }\r
4778     }\r
4779                \r
4780   return S;\r
4781 }\r
4782 int handle_X_template_files ( X_template *T, char *mode)\r
4783   {\r
4784     if (!T)return 0;\r
4785     \r
4786     if ( strm (mode, "remove"))\r
4787       {\r
4788         vremove (T->template_file);\r
4789         vremove (T->template_name);\r
4790       }\r
4791     else if (strm (mode, "display"))\r
4792       {\r
4793         char buf[100];\r
4794         sprintf ( buf, "Template %s",  template_type2type_name (T->template_type));\r
4795         if (check_file_exists (T->template_name))display_output_filename ( stdout,buf,T->template_format,T->template_name, STORE); \r
4796       }\r
4797     else\r
4798       {\r
4799         printf_exit (EXIT_FAILURE, stderr, "\nUnkonwn mode %s for template handling [FATAL:%s]", mode, PROGRAM);\r
4800       }\r
4801     return 1;\r
4802   }\r
4803 Sequence * seq2template_seq ( Sequence *S, char *template_list, Fname *F)\r
4804 {\r
4805   /*Expected format for the template file:\r
4806     >seq_name _X_ Target_template\r
4807     X: S for Structures \r
4808     G for genomes (Exoset)\r
4809     When alternative templates are given for a sequence, the first one superseeds all the others\r
4810   */\r
4811   \r
4812   /*Fill the sequences*/\r
4813   /*1: No template*/\r
4814   char buf[1000];\r
4815 \r
4816   int PmC,PmI,PMI;\r
4817   int BmC,BmI,BMI;\r
4818   char *server;\r
4819   char *pdb_db,*prot_db;\r
4820 \r
4821   int remove_template_file=0;\r
4822   \r
4823   remove_template_file=get_int_variable ("remove_template_file");\r
4824   server=get_string_variable ("blast_server");\r
4825   pdb_db=get_string_variable ("pdb_db");\r
4826   prot_db=get_string_variable ("prot_db");\r
4827   \r
4828   PmI=get_int_variable ("pdb_min_sim");\r
4829   PMI=get_int_variable ("pdb_max_sim");\r
4830   PmC=get_int_variable ("pdb_min_cov");\r
4831 \r
4832   BmI=get_int_variable ("prot_min_sim");\r
4833   BMI=get_int_variable ("prot_max_sim");\r
4834   BmC=get_int_variable ("prot_min_cov");\r
4835     \r
4836   if ( (template_list && template_list[0]=='\0') || strm ( template_list, "no_template")) \r
4837     {\r
4838       return S;\r
4839     }\r
4840   else if ( strstr (template_list, "MODE_"))//pre_set mode\r
4841     {\r
4842       return seq2template_seq ( S,template_list+strlen ("MODE_"),F);\r
4843     }\r
4844   else if ( strm ( template_list, "SSP")|| strm ( template_list, "GOR"))\r
4845     {\r
4846       \r
4847       /*use GOR to Predict the secondary structure*/\r
4848       check_program_is_installed (GOR4_4_TCOFFEE,NULL, NULL,GOR4_ADDRESS, INSTALL_OR_DIE);\r
4849       sprintf ( buf, "SCRIPT_tc_generic_method.pl@mode#ssp_template@seq#%s/%s@obs#%s/%s@cache#%s@type#_E_",get_mcoffee_4_tcoffee(), "New_KS.267.seq", get_mcoffee_4_tcoffee(), "New_KS.267.obs", get_cache_dir());\r
4850       S=seq2template_seq (S,buf, F);\r
4851       return S;\r
4852     }\r
4853   else if ( strm ( template_list, "PSISSP") || strm (template_list, "PSIGOR"))\r
4854     {\r
4855       \r
4856       /*Computes a GOR consensus on a psi-blast output*/\r
4857       check_program_is_installed (GOR4_4_TCOFFEE,NULL, NULL,GOR4_ADDRESS, INSTALL_OR_DIE);\r
4858       check_blast_is_installed(server);\r
4859       \r
4860       sprintf ( buf, "SCRIPT_tc_generic_method.pl@mode#psissp_template@seq#%s/%s@obs#%s/%s@cache#%s@minid#%d@maxid#%d@mincov#%d@server#%s@type#_E_",get_mcoffee_4_tcoffee(), "New_KS.267.seq", get_mcoffee_4_tcoffee(), "New_KS.267.obs", get_cache_dir(), BmI,BMI,BmC,server);\r
4861       S=seq2template_seq (S,buf, F);\r
4862       return S;\r
4863     }\r
4864   else if ( strm ( template_list, "TM"))\r
4865     {\r
4866       \r
4867       /*predict transmembrane structure*/\r
4868       check_program_is_installed (HMMTOP_4_TCOFFEE,NULL, NULL,HMMTOP_ADDRESS, INSTALL_OR_DIE);\r
4869       sprintf ( buf, "SCRIPT_tc_generic_method.pl@mode#tm_template@arch#%s/%s@psv#%s/%s@type#_T_",get_mcoffee_4_tcoffee(), "hmmtop.arch", get_mcoffee_4_tcoffee(), "hmmtop.psv");\r
4870       S=seq2template_seq (S,buf, F);\r
4871       return S;\r
4872     }\r
4873   else if ( strm ( template_list, "PSITM"))\r
4874     {\r
4875       \r
4876       /*predict transmembrane structure*/\r
4877       check_program_is_installed (HMMTOP_4_TCOFFEE,NULL, NULL,HMMTOP_ADDRESS, INSTALL_OR_DIE);\r
4878       check_blast_is_installed(server);\r
4879       \r
4880       sprintf ( buf, "SCRIPT_tc_generic_method.pl@mode#psitm_template@arch#%s/%s@psv#%s/%s@cache#%s@minid#%d@maxid#%d@mincov#%d@server#%s@type#_T_",get_mcoffee_4_tcoffee(), "hmmtop.arch", get_mcoffee_4_tcoffee(), "hmmtop.psv",get_cache_dir(), BmI,BMI,BmC,server);\r
4881       S=seq2template_seq (S,buf, F);\r
4882       return S;\r
4883     }\r
4884   \r
4885   else if (strm ( template_list, "PSIBLAST"))\r
4886     {\r
4887       check_blast_is_installed(server);\r
4888       sprintf ( buf, "SCRIPT_tc_generic_method.pl@mode#psiprofile_template@database#%s@method#psiblast@cache#%s@minid#%d@maxid#%d@mincov#%d@server#%s@type#_R_", prot_db,get_cache_dir(),BmI,BMI,BmC,server);\r
4889       S=seq2template_seq (S,buf, F);\r
4890       \r
4891       return S;\r
4892     }\r
4893   else if (strm ( template_list, "BLAST") )\r
4894     {\r
4895       check_blast_is_installed(server);\r
4896       sprintf ( buf, "SCRIPT_tc_generic_method.pl@mode#profile_template@database#%s@method#blastp@cache#%s@minid#%d@maxid#%d@mincov#%d@server#%s@type#_R_", prot_db,get_cache_dir(),BmI,BMI,BmC,server);\r
4897       S=seq2template_seq (S,buf, F);\r
4898       \r
4899       return S;\r
4900     }\r
4901   else if ( strm ( template_list, "EXPRESSO") || strm (template_list, "PDB"))\r
4902     {\r
4903       check_blast_is_installed(server);\r
4904       \r
4905       int isRNA = 0;\r
4906       int i;\r
4907       for (i= 0; i < S->len[0]; ++i)\r
4908         {\r
4909           isRNA =  (isRNA || is_rna(S->seq[0][i]));\r
4910         }\r
4911       \r
4912       if (isRNA)\r
4913         {\r
4914           sprintf ( buf, "SCRIPT_tc_generic_method.pl@mode#pdb_template@database#%s@method#blastn@cache#%s@minid#%d@maxid#%d@mincov#%d@server#%s@type#_P_",pdb_db, get_cache_dir(),PmI,PMI,PmC, server);\r
4915         }\r
4916       else\r
4917         {\r
4918           sprintf ( buf, "SCRIPT_tc_generic_method.pl@mode#pdb_template@database#%s@method#blastp@cache#%s@minid#%d@maxid#%d@mincov#%d@server#%s@type#_P_",pdb_db, get_cache_dir(),PmI,PMI,PmC, server);\r
4919         }\r
4920       return seq2template_seq (S,buf, F);\r
4921     }\r
4922   \r
4923   else if ( strm (template_list, "RCOFFEE") || strm (template_list, "RNA"))\r
4924     {\r
4925       char *file_struc_clac = vtmpnam (NULL);\r
4926       FILE* struc_calc_f =vfopen(file_struc_clac,"w");\r
4927       int i;\r
4928           int j = 0;\r
4929       for (i = 0; i< S->nseq; ++i)\r
4930         {\r
4931           if (S->T[i]->P)\r
4932             {\r
4933                   ++j;\r
4934               fprintf(struc_calc_f,"%s %s\n",S->name[i],S->T[i]->P->template_file); \r
4935             }\r
4936         }\r
4937       \r
4938       vfclose(struc_calc_f);\r
4939       check_program_is_installed (RNAPLFOLD_4_TCOFFEE,NULL, NULL,RNAPLFOLD_ADDRESS, IS_FATAL);\r
4940       sprintf ( buf, "SCRIPT_tc_generic_method.pl@mode#RNA_template@type#_F_");\r
4941           if (j > 0)\r
4942           {\r
4943         S = seq2template_seq (S,buf,F);\r
4944         sprintf ( buf, "SCRIPT_tc_generic_method.pl@mode#calc_rna_template@pdbfile#%s@cache#%s@type#_F_", file_struc_clac,get_cache_dir());\r
4945           }\r
4946 //        printf("IN T_\n");\r
4947       return seq2template_seq (S,buf,F);\r
4948     }\r
4949   \r
4950   /*2: Templates from seqnames (SELF) or named like the sequences (SEQFILE)*/\r
4951   else if ( strstr (template_list, "SELF_") ||strstr (template_list, "SEQFILE_") )\r
4952     {\r
4953       int a;\r
4954       char *p;\r
4955 \r
4956       //add template\r
4957       for (a=0; a< S->nseq; a++)\r
4958         {\r
4959 \r
4960           if ( (p=strstr (template_list,"SELF_")))p=S->name[a];\r
4961           else if ( strstr (template_list, "SEQFILE_"))p=template_list;\r
4962           else \r
4963             {\r
4964               fprintf ( stderr, "\nUnkown mode for Template [FATAL:%s]\n", PROGRAM);\r
4965               myexit (EXIT_FAILURE);\r
4966             }\r
4967           \r
4968           if (      strstr (template_list, "_P_") && !(S->T[a])->P)\r
4969             {\r
4970               (S->T[a])->P  =fill_P_template  ( S->name[a], p,S);//PDB\r
4971              \r
4972             }\r
4973           else if ( strstr (template_list, "_S_") && !(S->T[a])->S)(S->T[a])->S  =fill_S_template  ( S->name[a], p,S);//Sequence          \r
4974           else if ( strstr (template_list, "_R_" )&& !(S->T[a])->R)(S->T[a])->R  =fill_R_template  ( S->name[a], p,S);//pRofile\r
4975           else if ( strstr (template_list, "_G_" )&& !(S->T[a])->G)(S->T[a])->G  =fill_G_template  ( S->name[a], p,S);//Genomic\r
4976           else if ( strstr (template_list, "_F_" )&& !(S->T[a])->F)(S->T[a])->F  =fill_F_template  ( S->name[a], p,S);//Fold \r
4977           else if ( strstr (template_list, "_T_" )&& !(S->T[a])->T)(S->T[a])->T  =fill_T_template  ( S->name[a], p,S);//Trans Membrane\r
4978           else if ( strstr (template_list, "_E_" )&& !(S->T[a])->E)(S->T[a])->E  =fill_E_template  ( S->name[a], p,S);//Secondary Structure\r
4979           else if ( strstr (template_list, "_U_" )&& !(S->T[a])->U)(S->T[a])->U  =fill_U_template  ( S->name[a], p,S);//unicode, list template\r
4980           \r
4981         }\r
4982       return S;\r
4983     }\r
4984 \r
4985   /*2: Templates comes in a template_file*/\r
4986   else if ( template_list==NULL || format_is_fasta (template_list))\r
4987     {\r
4988       Sequence *T;\r
4989       int a, i;\r
4990       int ntemp=0;\r
4991       T=(template_list!=NULL)?get_fasta_sequence (template_list, NULL):S;\r
4992       for (a=0; a< T->nseq; a++)\r
4993         {\r
4994           \r
4995           char *p;\r
4996           if ((i=name_is_in_list(T->name[a], S->name, S->nseq, MAXNAMES))!=-1)\r
4997             {\r
4998               if (       (p=strstr (T->seq_comment[a], " _P_ ")) && !(S->T[i])->P &&( (S->T[i])->P=fill_P_template (S->name[i],p,S)))\r
4999                 {\r
5000                   ntemp++;\r
5001                 }\r
5002               else if (  (p=strstr (T->seq_comment[a], " _F_ ")) && !(S->T[i])->F &&( (S->T[i])->F=fill_F_template (S->name[i],p,S)))ntemp++;\r
5003               else if (  (p=strstr (T->seq_comment[a], " _S_ ")) && !(S->T[i])->S &&( (S->T[i])->S=fill_S_template (S->name[i],p,S)))ntemp++;\r
5004               \r
5005               else if (  (p=strstr (T->seq_comment[a], " _R_ ")) && !(S->T[i])->R &&( (S->T[i])->R=fill_R_template (S->name[i],p,S)))ntemp++;\r
5006               else if (  (p=strstr (T->seq_comment[a], " _G_ ")) && !(S->T[i])->G &&( (S->T[i])->G=fill_G_template (S->name[i],p,S)))ntemp++;\r
5007               else if (  (p=strstr (T->seq_comment[a], " _T_ ")) && !(S->T[i])->T &&( (S->T[i])->T=fill_T_template (S->name[i],p,S)))ntemp++;\r
5008               else if (  (p=strstr (T->seq_comment[a], " _E_ ")) && !(S->T[i])->E &&( (S->T[i])->E=fill_E_template (S->name[i],p,S)))ntemp++;\r
5009               else if (  (p=strstr (T->seq_comment[a], " _U_ ")) && !(S->T[i])->U &&( (S->T[i])->E=fill_U_template (S->name[i],p,S)))ntemp++;\r
5010               \r
5011               if (T!=S)strcat (S->seq_comment[i], T->seq_comment[a]);\r
5012             }\r
5013         }\r
5014       \r
5015       if (T!=S)free_sequence (T, -1);\r
5016       \r
5017       if ( remove_template_file==2 || ntemp==0)\r
5018         {\r
5019           vremove (template_list);\r
5020         }\r
5021       else \r
5022         if (template_list)display_output_filename ( stdout, "Template_List","fasta_seq", template_list, STORE); \r
5023       return S;\r
5024     }\r
5025   \r
5026   /*3 Templates are generated with a script*/\r
5027   else if (strstr (template_list, "SCRIPT_") && get_string_variable ("multi_core") && strstr (get_string_variable ("multi_core"), "templates") && get_nproc()>1)\r
5028     {\r
5029       char *tmp1,*command;\r
5030       Alignment *A;\r
5031       char **temp_file,**seq_file;\r
5032       int  * pid_list, pid, npid, submited;\r
5033       int nproc, max_nproc;\r
5034       \r
5035       char outfile[1000];\r
5036       static char *script;\r
5037       static int ntemp;\r
5038       char *p;\r
5039       int z, i;\r
5040       if (!script)script=vcalloc ( 1000, sizeof(char));\r
5041       \r
5042       ntemp++;\r
5043       \r
5044       command=vcalloc ( 1000, sizeof (char));\r
5045       tmp1=vtmpnam (NULL); \r
5046       \r
5047       A=seq2aln (S,NULL, 0);\r
5048       string_array_upper(A->seq_al, A->nseq);\r
5049       output_fasta_seq (tmp1, A);\r
5050       sprintf ( script, "%s", after_strstr (template_list, "SCRIPT_"));\r
5051       \r
5052       if ((p=strstr (template_list, "@type#")))\r
5053         p+=strlen ("@type#");\r
5054       if (F)\r
5055         {\r
5056           sprintf (outfile, "%s%s_%s%d.template_list", F->path,F->name,template_type2short_type_name(p),ntemp);\r
5057         }\r
5058       else\r
5059         {\r
5060           F=parse_fname (S->file[0]);\r
5061           sprintf (outfile, "%s%s_%s%d.template_list",F->path, F->name,template_type2short_type_name(p),ntemp);\r
5062           free_fname (F);\r
5063         }\r
5064       \r
5065       nproc=get_nproc();\r
5066       max_nproc=2*nproc;\r
5067                   \r
5068       script=substitute(script, "@", " -");\r
5069       script=substitute(script, "#", "=");\r
5070            \r
5071       temp_file=vcalloc ( A->nseq, sizeof (char*));\r
5072       seq_file =vcalloc (A->nseq, sizeof (char*)); \r
5073       pid_list =vcalloc (MAX_N_PID, sizeof (int *));\r
5074       \r
5075       fprintf ( stderr, "\n\t------ Fetch %Templates [Multi Core Mode %d CPUs]\n",get_nproc());\r
5076       for (npid=0, submited=0,i=0; i<S->nseq; i++)\r
5077         {\r
5078           FILE *fp2;\r
5079           seq_file[i]=vtmpnam (NULL);\r
5080           temp_file[i]=vtmpnam (NULL);\r
5081           fp2=vfopen (seq_file[i], "w");\r
5082           fprintf ( fp2, ">%s\n%s\n", S->name[i], S->seq[i]);\r
5083           vfclose (fp2);\r
5084                   \r
5085           pid=vfork();\r
5086           if (pid==0)\r
5087             {\r
5088               initiate_vtmpnam (NULL);\r
5089               if  ( strstr (script, "tc_generic_method"))\r
5090                 {\r
5091                   //sprintf ( command, "%s -other_pg %s -infile=%s -outfile=%s -tmpdir=%s",get_string_variable ("t_coffee"),script,seq_file[i],temp_file[i],get_tmp_4_tcoffee());\r
5092                   sprintf ( command, "%s -infile=%s -outfile=%s -tmpdir=%s",script,seq_file[i],temp_file[i],get_tmp_4_tcoffee());\r
5093                   if (strstr (command, "EBI"))get_email ();\r
5094                 }\r
5095               else \r
5096                 //sprintf ( command, "%s -other_pg %s -infile=%s -outfile=%s",get_string_variable("t_coffee"),script,seq_file[i],temp_file[i]);\r
5097                 sprintf ( command, "%s -infile=%s -outfile=%s",script,seq_file[i],temp_file[i]);\r
5098               command=substitute(command, "@", " ");\r
5099               my_system ( command);\r
5100               exit (EXIT_SUCCESS);\r
5101             }\r
5102           else\r
5103             {\r
5104               pid_list[pid]=npid;\r
5105               set_pid(pid);\r
5106               npid++;\r
5107               submited++;\r
5108               submited=vwait_npid(submited,max_nproc,nproc);\r
5109             }\r
5110         }\r
5111       \r
5112       submited=vwait_npid(submited,0,0);\r
5113       //Concatenate all the files\r
5114       vremove (outfile);\r
5115       for (i=0; i<npid; i++)  file_cat (temp_file[i],outfile);\r
5116       \r
5117       //Free the process table\r
5118       vfree (temp_file);\r
5119       vfree (pid_list);\r
5120       vfree (seq_file);\r
5121       \r
5122       free_aln (A);\r
5123       if ( check_file_exists (outfile) && format_is_fasta(outfile))\r
5124         {\r
5125           S=seq2template_seq (S, outfile, F);\r
5126         }\r
5127       else if (strstr (command, "webblast.pl"))return S; \r
5128       else \r
5129         {\r
5130           \r
5131           add_warning (stderr, "\nWARNING: Could not Run %s to find templates[%s]\n",command, PROGRAM);\r
5132           return NULL;\r
5133         }\r
5134   \r
5135       vfree (command);\r
5136       return S;\r
5137     }\r
5138   \r
5139   else if (strstr (template_list, "SCRIPT_"))\r
5140     {\r
5141           char x[299];\r
5142       char *tmp1,*command;\r
5143       Alignment *A;\r
5144       char outfile[1000];\r
5145       static char *script;\r
5146       static int ntemp;\r
5147       char *p;\r
5148       int z;\r
5149       if (!script)script=vcalloc ( 1000, sizeof(char));\r
5150       \r
5151       ntemp++;\r
5152       \r
5153       command=vcalloc ( 1000, sizeof (char));\r
5154       tmp1=vtmpnam (NULL); \r
5155       \r
5156       A=seq2aln (S,NULL, 0);\r
5157       string_array_upper(A->seq_al, A->nseq);\r
5158       output_fasta_seq (tmp1, A);\r
5159       sprintf ( script, "%s", after_strstr (template_list, "SCRIPT_"));\r
5160       fprintf ( stderr, "\n");\r
5161       if ((p=strstr (template_list, "@type#")))\r
5162         p+=strlen ("@type#");\r
5163       if (F)\r
5164         {\r
5165           sprintf (outfile, "%s%s_%s%d.template_list", F->path,F->name,template_type2short_type_name(p),ntemp);\r
5166         }\r
5167       else\r
5168         {\r
5169           F=parse_fname (S->file[0]);\r
5170           sprintf (outfile, "%s%s_%s%d.template_list",F->path, F->name,template_type2short_type_name(p),ntemp);\r
5171           free_fname (F);\r
5172         }\r
5173       \r
5174       script=substitute(script, "@", " -");\r
5175       script=substitute(script, "#", "=");\r
5176       \r
5177       if  ( strstr (script, "tc_generic_method"))\r
5178         {\r
5179           sprintf ( command, "%s -other_pg %s -infile=%s -outfile=%s -tmpdir=%s",get_string_variable ("t_coffee"),script, tmp1,outfile,get_tmp_4_tcoffee());\r
5180           if (strstr (command, "EBI"))get_email ();\r
5181         }\r
5182       else sprintf ( command, "%s -other_pg %s -infile=%s -outfile=%s",get_string_variable("t_coffee"),script, tmp1, outfile);\r
5183       \r
5184       vremove (outfile);\r
5185       command=substitute(command, "@", " ");\r
5186       \r
5187       my_system ( command);\r
5188     \r
5189       free_aln (A);\r
5190       \r
5191       if ( check_file_exists (outfile) && format_is_fasta(outfile))\r
5192         {\r
5193           S=seq2template_seq (S, outfile, F);\r
5194         }\r
5195       else if (strstr (command, "webblast.pl"))return S; \r
5196       else \r
5197         {\r
5198           \r
5199           add_warning (stderr, "\nWARNING: Could not Run %s to find templates[%s]\n",command, PROGRAM);\r
5200           return NULL;\r
5201         }\r
5202       \r
5203       vfree (command);\r
5204       return S;\r
5205     }\r
5206   \r
5207   return S;\r
5208 }\r
5209 \r
5210 char* seq2template_file (Sequence *S, char *file)\r
5211 {\r
5212   Alignment *A;\r
5213   int i;\r
5214   \r
5215   if (file==NULL)file=vtmpnam (NULL);\r
5216   \r
5217   seq2template_file2 (S, file, "w");\r
5218   for (i=0; i<S->nseq; i++)\r
5219     if ( (A=seq2R_template_profile (S, i)))\r
5220       {\r
5221         seq2template_file2 (A->S, file, "a");\r
5222       }\r
5223   return file;\r
5224 }\r
5225   \r
5226 int seq2template_file2 (Sequence *S, char *file, char *mode)\r
5227 {\r
5228   FILE *fp;\r
5229   int i;\r
5230   char buf1[10000];\r
5231   char buf2[10000];\r
5232   struct X_template *X;\r
5233   \r
5234   fp=vfopen ( file, mode);\r
5235   for ( i=0; i< S-> nseq; i++)\r
5236     {\r
5237       buf1[0]=0;\r
5238       if ( (X=(S->T[i])->P)){sprintf (buf2, " %s %s ", X->template_type, X->template_file);strcat (buf1, buf2);}\r
5239       /*if ( (X=(S->T[i])->S)){sprintf (buf2, " %s %s ", X->template_type, X->template_file);strcat (buf1, buf2);}*/\r
5240       if ( (X=(S->T[i])->R)){sprintf (buf2, " %s %s ", X->template_type, X->template_file);strcat (buf1, buf2);}\r
5241       if ( (X=(S->T[i])->G)){sprintf (buf2, " %s %s ", X->template_type, X->template_file);strcat (buf1, buf2);}\r
5242       if (buf1[0])fprintf ( fp, ">%s %s\n", S->name[i], buf1);\r
5243     }\r
5244   vfclose (fp);\r
5245   return EXIT_SUCCESS;\r
5246 }\r
5247            \r
5248       \r
5249         \r
5250         \r
5251 int seq2n_X_template ( Sequence *S, char *type)\r
5252 {\r
5253   int a, n;\r
5254   \r
5255   for (n=0,a=0; a< S->nseq; a++)\r
5256     {\r
5257       if ( strm2 (type, "_P_","_*_") && (S->T[a])->P)n++;\r
5258       if ( strm2 (type, "_F_","_*_") && (S->T[a])->F)n++;\r
5259       if ( strm2 (type, "_S_","_*_") && (S->T[a])->S)n++;\r
5260       if ( strm2 (type, "_R_","_*_") && (S->T[a])->R)n++;\r
5261       if ( strm2 (type, "_G_","_*_") && (S->T[a])->G)n++;\r
5262     }\r
5263   return n;\r
5264 }\r
5265 struct X_template *fill_X_template ( char *name, char *p, char *token)\r
5266 {\r
5267   struct X_template *X;\r
5268 \r
5269 \r
5270 \r
5271 \r
5272   char *k;\r
5273   \r
5274   X=vcalloc (1, sizeof (X_template));\r
5275   sprintf ( X->seq_name, "%s", name);\r
5276   if ( (k=strstr (p, token)))sscanf (k+strlen(token), "%s",X->template_name);\r
5277   else sprintf (X->template_name, "%s", p);\r
5278   \r
5279    \r
5280   /*Add a Structure HERE*/\r
5281   sprintf ( X->template_type, "%s", token);\r
5282   if ( strm (token, "_P_"))X->VP=vcalloc (1, sizeof (P_template));\r
5283   if ( strm (token, "_F_"))X->VF=vcalloc (1, sizeof (F_template));\r
5284   \r
5285   if ( strm (token, "_S_"))X->VS=vcalloc (1, sizeof (S_template));\r
5286   if ( strm (token, "_R_"))X->VR=vcalloc (1, sizeof (R_template));\r
5287   if ( strm (token, "_G_"))X->VG=vcalloc (1, sizeof (G_template));\r
5288   if ( strm (token, "_T_"))X->VT=vcalloc (1, sizeof (T_template));\r
5289   if ( strm (token, "_E_"))X->VE=vcalloc (1, sizeof (E_template));\r
5290   if ( strm (token, "_U_"))X->VU=vcalloc (1, sizeof (U_template));\r
5291   \r
5292   return X;\r
5293 }\r
5294 \r
5295 struct X_template* free_X_template ( struct X_template *X)\r
5296 {\r
5297   if (X->VP)\r
5298     {\r
5299       vfree (X->VP);\r
5300     }\r
5301   if (X->VF)\r
5302     {\r
5303       vfree (X->VF);\r
5304     }\r
5305   if ( X->VS)\r
5306     {\r
5307       free_sequence ((X->VS)->S, -1);\r
5308       vfree (X->VS);\r
5309     }\r
5310   if ( X->VR)\r
5311     {\r
5312       free_aln ((X->VR)->A);\r
5313       vfree (X->VR);\r
5314     }\r
5315   if ( X->VG)\r
5316     {\r
5317       free_sequence ((X->VG)->S, -1);\r
5318       vfree (X->VG);\r
5319     }\r
5320   \r
5321   vfree (X);\r
5322   return NULL;\r
5323 }\r
5324 \r
5325 FILE * display_sequence_templates (Sequence *S,int i, FILE *io)\r
5326 {\r
5327   \r
5328 \r
5329   io=display_X_template ( (S->T[i])->P, io);\r
5330 \r
5331   io=display_X_template ( (S->T[i])->F, io);\r
5332 \r
5333   io=display_X_template ( (S->T[i])->S, io);\r
5334 \r
5335   io=display_X_template ( (S->T[i])->R, io);\r
5336   io=display_X_template ( (S->T[i])->G, io);\r
5337   io=display_X_template ( (S->T[i])->T, io);\r
5338   io=display_X_template ( (S->T[i])->E, io);\r
5339 \r
5340   return io;\r
5341 }\r
5342  \r
5343 FILE * display_X_template (struct X_template *X, FILE *io)\r
5344 {\r
5345   \r
5346   if ( !X) return io;\r
5347   if ( !strm (X->template_type, "_S_"))fprintf (io, "\n\t%s: Template=%s, File=%s",template_type2type_name (X->template_type), X->template_name,X->template_file);\r
5348   return io;\r
5349 }\r
5350 char *template_type2short_type_name (char *type)\r
5351 {\r
5352   //add_template\r
5353   if (!type)return "";\r
5354   else if ( strstr (type, "_P_"))       return "pdb";\r
5355   else if ( strstr (type, "_F_")) return "rfold";\r
5356   else if ( strstr (type, "_S_")) return "seq";\r
5357   else if ( strstr (type, "_R_")) return "prf";\r
5358   else if ( strstr (type, "_G_")) return "genome";\r
5359   else if ( strstr (type, "_E_")) return "ssp";\r
5360   else if ( strstr (type, "_T_")) return "tmp";\r
5361   else if ( strstr (type, "_U_")) return "unicode";\r
5362   else return type;\r
5363 }\r
5364 char *template_type2type_name (char *type)\r
5365 {\r
5366   //add_template\r
5367   if ( strstr (type, "_P_"))      return "PDB struc";\r
5368   else if ( strstr (type, "_F_")) return "RNA Fold";\r
5369   else if ( strstr (type, "_S_")) return "Sequeence";\r
5370   else if ( strstr (type, "_R_")) return "Profile";\r
5371   else if ( strstr (type, "_G_")) return "Genomic";\r
5372   else if ( strstr (type, "_E_")) return "Protein Secondary Structure";\r
5373   else if ( strstr (type, "_T_")) return "Protein Trans Membrane Structure ";\r
5374   else if ( strstr (type, "_U_")) return "Unicode and strings";\r
5375   \r
5376   else return type;\r
5377 }\r
5378 struct X_template *fill_F_template ( char *name,char *p, Sequence *S)\r
5379 {\r
5380   /*Profile template*/\r
5381   struct X_template *F;\r
5382   \r
5383   F=fill_X_template ( name, p, "_F_");  \r
5384   sprintf (F->template_format , "TCOFFEE_LIBRARY");\r
5385   if (!F || !check_file_exists (F->template_name))\r
5386     {\r
5387       fprintf ( stderr, "\nWARNING: Could Not Fill _F_ (Fold) template for sequence |%s|", name);\r
5388       free_X_template (F);\r
5389       return NULL;\r
5390     }\r
5391   else if ( check_file_exists (F->template_name))\r
5392     {\r
5393       sprintf ( F->template_file, "%s", F->template_name);\r
5394     }\r
5395   \r
5396   return F;\r
5397 \r
5398 }\r
5399  \r
5400 \r
5401 struct X_template *fill_P_template ( char *name,char *p, Sequence *S)\r
5402 {\r
5403   struct X_template *P;\r
5404   Sequence *PS;\r
5405   Alignment *A;\r
5406   int sim, cov, i;\r
5407   char *buf;\r
5408   \r
5409   \r
5410   P=fill_X_template ( name, p, "_P_");  \r
5411   sprintf (P->template_format , "pdb");\r
5412   \r
5413   if (!P)\r
5414     {\r
5415       //fprintf ( stderr, "\nWARNING: Could Not Fill _P_ template for sequence |%s|", name);\r
5416       free_X_template (P);\r
5417       return NULL;\r
5418     }\r
5419   else if ( check_file_exists (P->template_name))\r
5420     {\r
5421       \r
5422       sprintf ( P->template_file, "%s", P->template_name);\r
5423       buf=path2filename (P->template_name);\r
5424       if (P->template_name!=buf)\r
5425         {\r
5426           sprintf ( P->template_name, "%s",buf );\r
5427           vfree (buf);\r
5428         }\r
5429     }\r
5430    else\r
5431      {\r
5432        char *st;\r
5433        \r
5434       \r
5435        st=is_pdb_struc (P->template_name);\r
5436        if (st)\r
5437          {\r
5438            if (st!=P->template_file)sprintf ( P->template_file, "%s", st);\r
5439          }\r
5440      }\r
5441   \r
5442   /*Make a first run to fix relaxed PDB files*/\r
5443   buf=fix_pdb_file (P->template_file);\r
5444   \r
5445   if ( buf!=P->template_file)\r
5446   {\r
5447     \r
5448     sprintf ( P->template_file, "%s",buf);\r
5449     vfree (buf);\r
5450   }\r
5451  \r
5452   /*Check the PDB FILE EXISTS*/\r
5453   if (!is_pdb_file (P->template_file))\r
5454     {\r
5455 \r
5456       add_warning(stderr, "\nWARNING: _P_ Template |%s| Could Not Be Found\n",p);\r
5457       free_X_template (P);\r
5458       return NULL;\r
5459     }\r
5460   else\r
5461     {\r
5462       buf= get_pdb_id (P->template_file);\r
5463       if (buf!=(P->VP)->pdb_id)\r
5464         {\r
5465           sprintf ((P->VP)->pdb_id, "%s", buf);\r
5466           vfree (buf);\r
5467         }\r
5468     }\r
5469 \r
5470   /*Check the target sequence is similar enough*/\r
5471   \r
5472   PS=get_pdb_sequence (P->template_file);\r
5473   \r
5474 \r
5475   if ( PS==NULL)\r
5476     {\r
5477       add_warning( stderr, "\nWARNING:  _P_  Template |%s| Could Not be Used for Sequence |%s|: Structure Not Found", P->template_name, name);\r
5478       free_X_template (P);P=NULL;\r
5479     }\r
5480   else\r
5481     {\r
5482       int minsim=get_int_variable ("pdb_min_sim");\r
5483       int mincov=get_int_variable ("pdb_min_cov");\r
5484 \r
5485       \r
5486       i=name_is_in_list (name, S->name, S->nseq, 100);\r
5487      \r
5488       A=align_two_sequences (S->seq[i], PS->seq[0],"idmat",-3,0, "fasta_pair_wise");\r
5489       cov=aln2coverage (A, 0);\r
5490       sim=aln2sim (A, "idmat");\r
5491      \r
5492       if (sim<minsim)\r
5493         {\r
5494           add_warning( stderr, "\nWARNING:  _P_  Template %s Could Not be Used for Sequence %s: Similarity too low [%d, Min=%d]",P->template_name,name, sim, minsim);\r
5495           free_X_template (P);\r
5496           P=NULL;\r
5497         }\r
5498       else if ( cov<mincov)\r
5499         {\r
5500           add_warning( stderr, "\nWARNING:  _P_  Template |%s| Could Not be Used for Sequence |%s|: Coverage too low [%d, Min=%d]", P->template_name,name, cov, mincov);\r
5501           free_X_template (P);P=NULL;\r
5502         }\r
5503       free_aln(A);\r
5504       free_sequence (PS, -1);\r
5505     }\r
5506   \r
5507   return P;\r
5508 }\r
5509 \r
5510 struct X_template *fill_S_template ( char *name,char *p, Sequence *Seq)\r
5511 {\r
5512   struct X_template *S;\r
5513   S=fill_X_template ( name, p, "_S_"); \r
5514   if ( strm (name, p))sprintf ( S->template_file, "%s",output_fasta_seqX (NULL,"w",Seq,NULL, seq_name2index (name, Seq)));\r
5515   (S->VS)->S=get_fasta_sequence (S->template_file, NULL);\r
5516   return S;\r
5517 }\r
5518 struct X_template *fill_R_template ( char *name,char *p, Sequence *S)\r
5519 {\r
5520   /*Profile template*/\r
5521   struct X_template *R;\r
5522   \r
5523 \r
5524   R=fill_X_template ( name, p, "_R_");\r
5525   sprintf (R->template_format , "fasta_aln");\r
5526   \r
5527   \r
5528   if (!is_aln(R->template_name) && !is_seq (R->template_name))\r
5529     {\r
5530       \r
5531       add_warning ( stderr, "\nWARNING: _R_ Template %s Could Not Be Found\n",R->template_name);\r
5532       free_X_template (R);\r
5533       return NULL;\r
5534     }\r
5535   else\r
5536     {\r
5537       int s;\r
5538       Sequence *S1;\r
5539       Alignment *A1;\r
5540       \r
5541       (R->VR)->A=main_read_aln (R->template_name, NULL);\r
5542       \r
5543       if ( !S)\r
5544         sprintf ( R->template_file, "%s", R->template_name);\r
5545       else\r
5546         {\r
5547           s=name_is_in_list(name, S->name, S->nseq, 100);\r
5548           if ( s!=-1)\r
5549             {\r
5550               S1=fill_sequence_struc (1, &S->seq[s], &S->name[s]);\r
5551               A1=seq2aln (S1,NULL, RM_GAP);\r
5552               \r
5553               (R->VR)->A=trim_aln_with_seq (A1, (R->VR)->A);\r
5554         \r
5555               sprintf ( R->template_file, "%s", vtmpnam (NULL));\r
5556               output_clustal_aln (R->template_file, (R->VR)->A);\r
5557             }\r
5558           else\r
5559             sprintf ( R->template_file, "%s", R->template_name);\r
5560         }\r
5561       (R->VR)->A=aln2profile ((R->VR)->A);\r
5562     }\r
5563   return R;\r
5564 }\r
5565 \r
5566 struct X_template *fill_T_template ( char *name,char *p, Sequence *S)\r
5567 {\r
5568   /*Profile template*/\r
5569   struct X_template *T;\r
5570   \r
5571   T=fill_X_template ( name, p, "_T_");\r
5572   sprintf (T->template_format , "fasta_seq");\r
5573   \r
5574   if (!is_aln(T->template_name) && !is_seq (T->template_name))\r
5575     {\r
5576       \r
5577       add_warning ( stderr, "\nWARNING: _T_ Template %s Could Not Be Found\n",T->template_name);\r
5578       free_X_template (T);\r
5579       return NULL;\r
5580     }\r
5581   else\r
5582     {\r
5583   \r
5584       (T->VT)->S=main_read_seq(T->template_name);\r
5585       sprintf ( T->template_file, "%s", T->template_name);\r
5586     }\r
5587   return T;\r
5588 }\r
5589 //add template\r
5590 struct X_template *fill_U_template ( char *name,char *p, Sequence *S)\r
5591 {\r
5592   /*Profile template*/\r
5593   struct X_template *U;\r
5594   \r
5595   U=fill_X_template ( name, p, "_U_");\r
5596   sprintf (U->template_format , "string list");\r
5597   \r
5598   if (!check_file_exists(U->template_name))\r
5599     {\r
5600       add_warning ( stderr, "\nWARNING: _U_ Template %s Could Not Be Found\n",U->template_name);\r
5601       free_X_template (U);\r
5602       return NULL;\r
5603     }\r
5604   else\r
5605     {\r
5606       //(U->VU)->list=file2string(U->template_name);\r
5607       sprintf ( U->template_file, "%s", U->template_name);\r
5608     }\r
5609   return U;\r
5610 }\r
5611 struct X_template *fill_E_template ( char *name,char *p, Sequence *S)\r
5612 {\r
5613   /*Profile template*/\r
5614   struct X_template *E;\r
5615   \r
5616 \r
5617   E=fill_X_template ( name, p, "_E_");\r
5618   sprintf (E->template_format , "fasta_seq");\r
5619   \r
5620   if (!is_aln(E->template_name) && !is_seq (E->template_name))\r
5621     {\r
5622       \r
5623       add_warning ( stderr, "\nWARNING: _E_ Template %s Could Not Be Found\n",E->template_name);\r
5624       free_X_template (E);\r
5625       return NULL;\r
5626     }\r
5627   else\r
5628     {\r
5629       (E->VE)->S=main_read_seq (E->template_name);\r
5630       sprintf ( E->template_file, "%s", E->template_name);\r
5631     }\r
5632   return E;\r
5633 }\r
5634 struct X_template *fill_G_template ( char *name,char *p, Sequence *S)\r
5635 {\r
5636   struct X_template *G;\r
5637   G=fill_X_template ( name, p, "_G_");  \r
5638   sprintf (G->template_format , "fasta_seq");\r
5639   \r
5640   /*1: Get the sequence from another file if needed*/\r
5641   if ( strm (name, p))sprintf ( G->template_file, "%s",output_fasta_seqX (NULL,"w",S,NULL, seq_name2index (name, S)));\r
5642   else if ( strstr (p, "SEQFILE_"))\r
5643     {\r
5644       Sequence *ST;\r
5645       int i2;\r
5646       \r
5647    \r
5648       ST=main_read_seq (after_strstr ( p,"SEQFILE_G_"));\r
5649    \r
5650       i2=seq_name2index (name, ST);\r
5651       if ( i2!=-1)\r
5652         {\r
5653           sprintf ( G->template_file, "%s",output_fasta_seqX (NULL,"w",ST,NULL, i2));\r
5654           sprintf ( G->template_name, "%s", name);\r
5655         }\r
5656       free_sequence (ST, -1);\r
5657     }\r
5658   else sprintf (G->template_file, "%s", G->template_name);\r
5659         \r
5660   \r
5661   /*2: Put the template in VG->S*/\r
5662   if (!is_seq (G->template_file))\r
5663     {\r
5664       add_warning ( stderr, "\nWARNING: _G_ Template %s Could Not Be Found \n",p);\r
5665 \r
5666       free_X_template (G);\r
5667       return NULL;\r
5668     }\r
5669   else\r
5670     {\r
5671       (G->VG)->S=get_fasta_sequence (G->template_file, NULL);\r
5672     }\r
5673   return G;\r
5674 }\r
5675 \r
5676 \r
5677 char *seq2T_value ( Sequence *S, int n, char *value, char *type)\r
5678 {\r
5679   static char *rv_buf;\r
5680   X_template *X;\r
5681 \r
5682   if ( !rv_buf)rv_buf=vcalloc (100, sizeof(char));\r
5683   if (!(X=seq_has_template (S, n, type)))return NULL;\r
5684   else\r
5685     {\r
5686       if (strm (value, "template_file"))return X->template_file;\r
5687       else if ( strm (value, "template_name"))return X->template_name;\r
5688       else if ( strm (value, "seq_name"))return X->seq_name;\r
5689       else if (strm (type, "_P_"))\r
5690         {\r
5691           if ( strm (value, "pdb_id"))return (X->VP)->pdb_id;\r
5692         }\r
5693       else if ( strm (type, "_R_"))\r
5694         {\r
5695           if ( strm (value, "A"))\r
5696             {\r
5697               if ((X->VR)->A){sprintf ( rv_buf, "%d", (int)(X->VR)->A);return rv_buf;}\r
5698               else return NULL;\r
5699             }\r
5700         }\r
5701       \r
5702     }\r
5703   return NULL;\r
5704 }\r
5705 char *seq2P_pdb_id (Sequence *S, int n)\r
5706 {\r
5707   if (!S->T || !S->T[n] || !(S->T[n])->P ) return NULL;\r
5708   else return ((S->T[n])->P)->template_name;\r
5709 }\r
5710 \r
5711   \r
5712 char *seq2P_template_file(Sequence *S, int n)\r
5713 {\r
5714  \r
5715   return seq2T_value (S, n, "template_file", "_P_");\r
5716 }\r
5717 \r
5718 char *profile2P_template_file (Sequence *S, int n)\r
5719 {\r
5720   Alignment *A;\r
5721   int a;\r
5722   char *p;\r
5723   \r
5724   if ( !(A=seq2R_template_profile (S, n)))return NULL;\r
5725   for (a=0; a<A->nseq; a++)\r
5726     {\r
5727       if ((p=seq2P_template_file (A->S, a))!=NULL)return p;\r
5728     }\r
5729   return NULL;\r
5730 }\r
5731 Alignment * seq2R_template_profile (Sequence *S, int n)\r
5732 {\r
5733  \r
5734  \r
5735   return (Alignment *)atop(seq2T_value (S, n, "A", "_R_"));\r
5736 }\r
5737 char * seq2E_template_string (Sequence *S, int n)\r
5738 {\r
5739   struct X_template *T;\r
5740   \r
5741   if ( (T=seq_has_template (S, n, "_E_"))!=NULL)\r
5742     return  ((T->VE)->S)->seq[0];\r
5743   else \r
5744     return NULL;\r
5745 }\r
5746 //add template\r
5747 int* seq2U_template (Sequence *S, int n)\r
5748 {\r
5749    struct X_template *T;\r
5750   \r
5751    if ( (T=seq_has_template (S, n, "_U_"))!=NULL)\r
5752      return  (T->VU)->list;\r
5753    else \r
5754      return NULL;\r
5755 }\r
5756 char * seq2T_template_string (Sequence *S, int n)\r
5757 {\r
5758   struct X_template *T;\r
5759   \r
5760   if ( (T=seq_has_template (S, n, "_T_"))!=NULL)\r
5761     return  ((T->VT)->S)->seq[0];\r
5762   else \r
5763     return NULL;\r
5764 }\r
5765 \r
5766 struct X_template* seq_has_template ( Sequence *S, int n, char *mode)\r
5767 {\r
5768   Template *T;\r
5769   \r
5770   if ( !S || !mode) return NULL;\r
5771   else if ( n<0 || n>=S->nseq)return NULL;\r
5772   else if ( !(S->T)) return NULL;\r
5773   else if ( !(S->T[n]))return NULL;\r
5774 \r
5775   T=S->T[n];\r
5776   //ADD STRUCTURE\r
5777   //add template\r
5778   if      ( strm (mode, "_P_"))return T->P;\r
5779   else if ( strm (mode, "_F_"))return T->F;\r
5780   else if ( strm (mode, "_S_"))return T->S;\r
5781   else if ( strm (mode, "_R_"))return T->R;\r
5782   else if ( strm (mode, "_T_"))return T->T;\r
5783   else if ( strm (mode, "_E_"))return T->E;\r
5784   else if ( strm (mode, "_U_"))return T->U;\r
5785   else if ( strm (mode, "_G_"))return T->G;\r
5786   else return NULL;\r
5787 }  \r
5788 \r
5789 char ** name2random_subset (char **in_name, int n_in, int n_out)\r
5790 {\r
5791   char **out_name;\r
5792   \r
5793   int **list;\r
5794   int a,max;\r
5795   \r
5796   \r
5797   vsrand (0);\r
5798   max=n_in*10000;\r
5799   out_name=declare_char (n_out,MAXNAMES+1 );\r
5800   list=declare_int (n_in, 2);\r
5801     \r
5802   for (a=0; a<n_in; a++)\r
5803       {\r
5804         list[a][0]=a;\r
5805         list[a][1]=rand ()%max;\r
5806       }\r
5807   sort_int ( list,2, 1, 0, n_in-1);\r
5808   \r
5809   for ( a=0; a<n_out; a++)\r
5810     sprintf ( out_name[a], "%s", in_name[list[a][0]]);\r
5811   free_int (list, -1);\r
5812   return out_name;\r
5813 }\r
5814     \r
5815 Alignment * aln2random_order (Alignment *A)\r
5816 {\r
5817   \r
5818   char **name_list;\r
5819   \r
5820   name_list=name2random_subset (A->name, A->nseq, A->nseq);\r
5821   A=reorder_aln (A, name_list, A->nseq);\r
5822   free_char (name_list, -1);\r
5823   return A;\r
5824 }\r
5825 Alignment *aln2jacknife (Alignment *A, int nseq, int len)\r
5826 {\r
5827   int a, b;\r
5828   \r
5829   if (nseq!=0 && nseq<A->nseq)\r
5830     {\r
5831       char **name;\r
5832       \r
5833       name=name2random_subset (A->name, A->nseq, nseq);\r
5834       A=reorder_aln (A, name, nseq);\r
5835       free_char (name, -1);\r
5836     }\r
5837   \r
5838   if (len!=0 && len<A->len_aln)\r
5839     {\r
5840       int **l;\r
5841       Alignment *B;\r
5842       \r
5843       l=declare_int (A->len_aln, 2);\r
5844       for (a=0; a< A->len_aln; a++)\r
5845         {\r
5846           l[a][0]=a; \r
5847           l[a][1]=rand()%(A->len_aln*1000);\r
5848         }\r
5849       sort_int ( l,2, 1, 0, A->len_aln-1);\r
5850       B=copy_aln (A, NULL);\r
5851       for ( a=0; a< len; a++)\r
5852         {\r
5853           for ( b=0; b<A->nseq; b++)\r
5854             {\r
5855               A->seq_al[b][a]=B->seq_al[b][l[a][0]];\r
5856             }\r
5857         }\r
5858       for (b=0; b<A->nseq; b++)A->seq_al[b][len]='\0';\r
5859       free_aln (B);\r
5860       free_int (l, -1);\r
5861     }\r
5862   return A;\r
5863 }\r
5864 Alignment * aln2scramble_seq (Alignment *A)\r
5865 {\r
5866   int **list;\r
5867   char **name_list;\r
5868   int a,max;\r
5869 \r
5870   max=100*A->nseq;\r
5871   vsrand (0);\r
5872   \r
5873   list=declare_int (A->nseq, 2);\r
5874   name_list=vcalloc (A->nseq, sizeof (char*));\r
5875   \r
5876   \r
5877   for (a=0; a<A->nseq; a++)\r
5878       {\r
5879         list[a][0]=a;\r
5880         list[a][1]=rand ()%max;\r
5881       }\r
5882   sort_int ( list,2, 1, 0, A->nseq-1);\r
5883   \r
5884   for ( a=0; a< A->nseq; a++)\r
5885     name_list[a]=A->seq_al[a];\r
5886   for (a=0; a<A->nseq; a++)\r
5887     {\r
5888       A->seq_al[a]=name_list[list[a][0]];\r
5889     }\r
5890   vfree (name_list);\r
5891   free_int (list, -1);\r
5892   return aln2random_order (A);\r
5893 }\r
5894   \r
5895   \r
5896 \r
5897 Alignment * reorder_aln ( Alignment *A, char **name, int nseq)\r
5898         {\r
5899         int a,sn;\r
5900         Alignment *BUF;\r
5901         int  n=0;\r
5902         int *tpp_int;\r
5903         \r
5904         if ( name==NULL)return aln2random_order(A);\r
5905         \r
5906         \r
5907         BUF=copy_aln ( A,NULL); \r
5908         for ( a=0; a<nseq; a++)\r
5909                 {\r
5910                   sn =name_is_in_list ( name[a],BUF->name, A->nseq,STRING);\r
5911                   if ( sn==-1)\r
5912                         {\r
5913                             ;\r
5914                         }\r
5915                 else\r
5916                     {\r
5917                     \r
5918                       \r
5919                     SWAPP(A->order[n], BUF->order[sn], tpp_int);\r
5920                     sprintf ( A->name[n], "%s", BUF->name[sn]);             \r
5921                     sprintf ( A->seq_al[n], "%s",BUF->seq_al[sn]);\r
5922                     sprintf ( A->seq_comment[n], "%s",  BUF->seq_comment[sn]);\r
5923                     \r
5924                     n++;\r
5925                       \r
5926                     }\r
5927                 }\r
5928         \r
5929         for ( a=n; a< A->nseq; a++)A->name[a][0]=A->seq_al[a][0]='\0';\r
5930         A->nseq=n;\r
5931         \r
5932         if ( A->A)A->A=reorder_aln(A->A, name, nseq);\r
5933         free_aln (BUF);\r
5934         return A;\r
5935         } \r
5936 Sequence * reorder_seq_2 ( Sequence *A, int **order,int field, int nseq)\r
5937         {\r
5938           char **name;\r
5939           int a;\r
5940           \r
5941           if (!A || !order) return A;\r
5942           name=declare_char (A->nseq, 100);\r
5943           for (a=0; a<nseq; a++)\r
5944             sprintf ( name[a], "%s", A->name[order[a][field]]);\r
5945           A=reorder_seq (A, name,nseq);\r
5946           free_char (name, -1);\r
5947           return A;\r
5948         }\r
5949 Sequence * reorder_seq ( Sequence *A, char **name, int nseq)\r
5950         {\r
5951         int a,sn;\r
5952         Sequence *nA;\r
5953 \r
5954         \r
5955         nA=duplicate_sequence (A);\r
5956         \r
5957         \r
5958         for ( a=0; a< nseq; a++)\r
5959           {\r
5960             sn=name_is_in_list (name[a] ,nA->name, nA->nseq, 100);\r
5961             if (sn==-1)continue;\r
5962             \r
5963             if ( nA->file)       sprintf ( A->file[a], "%s", nA->file[sn]);\r
5964             \r
5965             if ( nA->seq_comment)sprintf ( A->seq_comment[a], "%s", nA->seq_comment[sn]);\r
5966             if ( nA->aln_comment)sprintf ( A->aln_comment[a], "%s", nA->aln_comment[sn]);\r
5967             sprintf ( A->seq[a], "%s", nA->seq[sn]);\r
5968             A->len[a]=nA->len[sn];\r
5969             sprintf ( A->name[a], "%s", nA->name[sn]);\r
5970             A->T[a][0]=nA->T[sn][0];\r
5971           }\r
5972         A->nseq=nseq;\r
5973         free_sequence (nA, nA->nseq);\r
5974         \r
5975         return A;\r
5976 } \r
5977 \r
5978 char * concatenate_seq ( Sequence *S, char *conc, int *order)\r
5979         {\r
5980             int a;\r
5981             \r
5982             vfree (conc);\r
5983             conc=vcalloc ( S->nseq*S->max_len, sizeof (char));\r
5984 \r
5985             for ( a=0; a< S->nseq; a++)\r
5986                 {\r
5987                     conc=strcat ( conc, S->seq[order[a]]);\r
5988                 }\r
5989             return conc;\r
5990 \r
5991         }\r
5992 \r
5993 \r
5994           \r
5995 \r
5996 Alignment * rotate_aln ( Alignment *A, char *name)\r
5997 {\r
5998   Alignment *B;\r
5999   int a, b;\r
6000   \r
6001   B=declare_aln2 (A->len_aln, A->nseq+1);\r
6002   for ( a=0; a< A->nseq; a++)\r
6003     for ( b=0; b< A->len_aln; b++)\r
6004       {\r
6005         B->seq_al[b][a]=A->seq_al[a][b];\r
6006       }\r
6007   for (a=0; a< A->len_aln; a++)\r
6008     if (name && name[0])sprintf ( B->name[a], "%s_%s%d", name, (a<9)?"0":"",a+1);\r
6009     else\r
6010       sprintf ( B->name[a], "%d", a+1);\r
6011   \r
6012   \r
6013   for (a=0; a< A->len_aln; a++)B->seq_al[a][A->nseq]='\0';\r
6014   B->len_aln=A->nseq;\r
6015   B->nseq=A->len_aln;\r
6016   /*free_aln (A);*/\r
6017   return B;\r
6018 }\r
6019   \r
6020 Alignment * invert_aln ( Alignment *A)\r
6021 {\r
6022   char *buf;\r
6023   int l, a, b, c;\r
6024   \r
6025   for ( a=0; a< A->nseq; a++)\r
6026     {\r
6027         l=strlen ( A->seq_al[a]);\r
6028         buf=vcalloc ( l+1,sizeof (char) );\r
6029         \r
6030         for ( c=l-1,b=0; b< l; b++, c--)\r
6031           {\r
6032             buf[c]=A->seq_al[a][b];\r
6033           }\r
6034         buf[l]='\0';\r
6035         sprintf ( A->seq_al[a], "%s", buf);\r
6036     }\r
6037   vfree(buf);\r
6038   return A;\r
6039 }\r
6040 char * complement_string (char *s)\r
6041 {\r
6042   char *buf;\r
6043   int l, a, b, c;\r
6044   \r
6045   l=strlen (s);\r
6046   for ( b=0; b< l; b++)\r
6047     {\r
6048       char r;\r
6049       r=s[b];\r
6050       if ( r=='a')r='t';\r
6051       else if (r=='A')r='T';\r
6052       else if (r=='t')r='a';\r
6053       else if (r=='T')r='A';\r
6054       else if (r=='g')r='c';\r
6055       else if (r=='G')r='C';\r
6056       else if (r=='c')r='g';\r
6057       else if (r=='C')r='G';\r
6058       s[b]=r;\r
6059     }\r
6060   \r
6061   return invert_string (s);\r
6062 }\r
6063 Alignment * complement_aln ( Alignment *A)\r
6064 {\r
6065   char *buf;\r
6066   int l, a, b, c;\r
6067   \r
6068   for ( a=0; a< A->nseq; a++)\r
6069     {\r
6070       A->seq_al[a]=complement_string (A->seq_al[a]);\r
6071     }\r
6072 \r
6073   return A;\r
6074 }\r
6075 \r
6076 Alignment * extract_nol_local_aln(Alignment *A, int start, int max_end)\r
6077      {\r
6078      A=extract_aln ( A, start, max_end);\r
6079      A=trunkate_local_aln (A);\r
6080      return A;\r
6081      }\r
6082 \r
6083 Alignment * alnpos_list2block (Alignment *A, int n, char **in_list)\r
6084 {\r
6085   int *pos;\r
6086   int a;\r
6087   char **list;\r
6088   int list_declared=0;\r
6089   Alignment *B;\r
6090   \r
6091   if (check_file_exists (in_list[0]))\r
6092     {\r
6093       int mn;\r
6094       char ***tmp_list;\r
6095       \r
6096       mn=count_n_line_in_file (in_list[0]);\r
6097       list=declare_char (mn, 100);\r
6098       list_declared=1;\r
6099       tmp_list=file2list (in_list[0], " ");\r
6100       a=0;\r
6101       n=0;\r
6102       while (tmp_list[a])\r
6103         {\r
6104           if (tmp_list[a][1][0]!='!')\r
6105             {\r
6106               sprintf (list[n++], "%s", tmp_list[a][1]);\r
6107             }\r
6108           a++;\r
6109         }\r
6110       free_arrayN ((void **)tmp_list, 3);\r
6111     }\r
6112   else\r
6113     {\r
6114       list=in_list;\r
6115     }\r
6116           \r
6117   \r
6118   pos=vcalloc (A->len_aln, sizeof (int));\r
6119   for (a=0; a<n; a++)\r
6120     {\r
6121       \r
6122       if (strstr (list[a], "-"))\r
6123         {\r
6124           int start, end, x;\r
6125           x=sscanf (list[a], "%d-%d", &start, &end);\r
6126           if (x!=2 || !A || start<=0 || start>=end || end>A->len_aln+1)\r
6127             {\r
6128               add_warning ( stderr, "\nWARNING: Illegal coordinates in extract_pos_list [%s]", list[a]);\r
6129               return A;\r
6130             }\r
6131           start--; end--;\r
6132           for (a=start; a<end; a++)pos[a]=1;\r
6133         }\r
6134       else\r
6135         {\r
6136           int p;\r
6137           p=atoi (list[a]);\r
6138           if (p<1 || p>A->len_aln)\r
6139             {\r
6140               add_warning ( stderr, "\nWARNING: Illegal coordinates in extract_pos_list [%s]", list[a]);\r
6141             }\r
6142           p--;\r
6143           pos[p]=1;\r
6144         }\r
6145     } \r
6146   B=alnpos2block(A, pos, NULL);\r
6147   vfree (pos);\r
6148   if ( list_declared)free_char (list, -1);\r
6149   \r
6150   return B;\r
6151 }\r
6152 Alignment * aln2block   (Alignment  *A, int start, int end, Alignment *B)\r
6153 {\r
6154   if ( !A || start<=0 || start>=end || end>A->len_aln+1)\r
6155     {\r
6156       add_warning ( stderr, "\nWARNING: Illegal coordinates in extract_block start=%d end=%d len=%d [Note : [start-end[, with [1...n]", start, end, A->len_aln);\r
6157       return A;\r
6158     }\r
6159   else\r
6160     {\r
6161       int *pos, p;\r
6162       start--;\r
6163       end--;\r
6164       pos=vcalloc (A->len_aln, sizeof (int));\r
6165       for (p=start;p<end;p++)\r
6166             {\r
6167               pos[p]=1;\r
6168             }\r
6169       B=alnpos2block (A, pos, B);\r
6170       vfree (pos);\r
6171       return B;\r
6172     }\r
6173 }\r
6174 Alignment * alnpos2block   (Alignment  *A, int *pos, Alignment *B)\r
6175 {\r
6176  \r
6177   //extract a subset of B without over-writing A\r
6178   int a, b;\r
6179   \r
6180   B=copy_aln (A, B);\r
6181   B->len_aln=0;\r
6182   for (a=0; a<=A->len_aln; a++)\r
6183     {\r
6184       if ( pos[a]!=0 || a==A->len_aln)\r
6185         {\r
6186           for ( b=0; b<A->nseq; b++)\r
6187             B->seq_al[b][B->len_aln]=A->seq_al[b][a];\r
6188           if ( a!=A->len_aln)B->len_aln++;\r
6189         }\r
6190     }\r
6191  \r
6192   return B;\r
6193 }\r
6194 Alignment * extract_aln ( Alignment *A, int start, int end)\r
6195 {\r
6196   return extract_aln2 ( A, start, end, "cons");\r
6197 }\r
6198 \r
6199 Alignment * extract_aln2 ( Alignment *A, int in_start, int in_end, char *seq)\r
6200      {\r
6201        char *tmp;\r
6202        FILE *fp;\r
6203        \r
6204 \r
6205        tmp=vtmpnam (NULL);\r
6206        fp=vfopen (tmp, "w");\r
6207        fprintf ( fp, "%s %d %d\n", seq, in_start, in_end);\r
6208        vfclose (fp);\r
6209        return extract_aln3 (A,tmp);\r
6210      }\r
6211 Alignment * extract_aln3 ( Alignment *B, char *file)\r
6212      {\r
6213      int a, b, c;\r
6214      int start, end;\r
6215      int n, i, s, nline=0;\r
6216      FILE *fp;\r
6217      Alignment *A=NULL;\r
6218      int *col;\r
6219      char name[MAXNAMES];\r
6220      char line[VERY_LONG_STRING];\r
6221      int *offset;\r
6222      \r
6223      /*Reads in a file\r
6224        #comment\r
6225        ! seq_name offset\r
6226        seqname pos\r
6227        OR\r
6228        seqname start end[\r
6229        modifies the incoming alignment\r
6230      */\r
6231    \r
6232      offset=vcalloc ( B->nseq+1, sizeof (int));\r
6233      fp=vfopen (file,"r");\r
6234      while ( (c=fgetc(fp))!=EOF)\r
6235        {\r
6236          s=-1;\r
6237          fgets ( line, VERY_LONG_STRING,fp);\r
6238          if ( c=='!')\r
6239            {\r
6240              sscanf (line, "%s %d", name, &start);\r
6241              s=name_is_in_list (name,B->name,B->nseq,MAXNAMES);\r
6242            }\r
6243          if (s!=-1)\r
6244            offset[s]=start;\r
6245        }\r
6246      \r
6247      vfclose (fp);\r
6248      \r
6249      A=copy_aln (B, A);     \r
6250      col=vcalloc ( A->len_aln, sizeof (int));\r
6251      \r
6252      fp=vfopen ( file, "r");\r
6253      while ( (c=fgetc(fp))!=EOF)\r
6254        {\r
6255          nline++;\r
6256          if ( c=='#' || c=='!')fgets ( line, VERY_LONG_STRING,fp);\r
6257          else\r
6258            {\r
6259              ungetc(c, fp);\r
6260              fgets ( line, VERY_LONG_STRING,fp);\r
6261              \r
6262              if (sscanf (line, "%s %d %d", name, &start, &end)==3);\r
6263              else if (sscanf (line, "%s %d", name, &start)==2)\r
6264                {\r
6265                  end=start+1;\r
6266                }\r
6267              else\r
6268                {\r
6269                  add_warning ( stderr, "\nWARNING: wrong format in coordinate file (line=%d)\n", nline);\r
6270                  continue;\r
6271                }\r
6272              if ( end==0)end=A->len_aln+1;\r
6273 \r
6274              s=name_is_in_list (name,A->name,A->nseq,MAXNAMES);\r
6275              \r
6276              \r
6277              if ( s==-1 && !strm (name, "cons"))\r
6278                {\r
6279                  add_warning ( stderr, "\nWARNING: Seq %s does not belong to the alignment (line %d)\n", name,nline);\r
6280                  continue;\r
6281                }\r
6282              else if ( start>end)\r
6283                {\r
6284                  add_warning ( stderr, "\nWARNING: Illegal coordinates [%s %d %d] (line %d)\n", name,start, end,nline);\r
6285                  continue;\r
6286                }\r
6287              else\r
6288                {\r
6289                  int done=0;\r
6290                  if ( s!=-1)\r
6291                    { \r
6292                      start-=offset[s]-1;\r
6293                      end-=offset[s]-1;\r
6294                    }\r
6295                  for (n=0, a=0; done!=1 && a< A->len_aln; a++)\r
6296                    {\r
6297                      i=(strm (name, "cons"))?1:!is_gap(A->seq_al[s][a]);\r
6298                      \r
6299                      n+=i;\r
6300                      if (n>=start && n<end)\r
6301                        {\r
6302                          col[a]=1;\r
6303                        }\r
6304                      if (n>=end)done=1;\r
6305                      //if (n>=start && n<end && !(i==0 && n==end-1))\r
6306                      //{\r
6307                      // col[a]=1;\r
6308                      //}\r
6309                      //else if ( n>=end)a=A->len_aln;\r
6310                    }\r
6311                  if ( done==0)\r
6312                    {\r
6313                      HERE ("Warning Missing positions in File %s",file );\r
6314                    }\r
6315                }\r
6316            }\r
6317        }\r
6318      vfclose ( fp);\r
6319      \r
6320 \r
6321                  \r
6322      /*Extract [start-end[*/\r
6323      for ( b=0,a=0; a< A->len_aln; a++)\r
6324        {\r
6325          if ( col[a])\r
6326            {\r
6327              for (c=0; c< A->nseq; c++)A->seq_al[c][b]=A->seq_al[c][a];\r
6328              b++;\r
6329            }\r
6330        }\r
6331      A->len_aln=b;\r
6332 \r
6333      for (c=0; c< A->nseq; c++)A->seq_al[c][A->len_aln]='\0';\r
6334      vfree (col);\r
6335      \r
6336      return A;\r
6337 \r
6338      }\r
6339 Alignment * trunkate_local_aln ( Alignment *A)\r
6340      {\r
6341      int a, b;\r
6342      int **pos;\r
6343      int **cache;\r
6344      int seq;\r
6345    \r
6346      \r
6347      cache=declare_int (return_max_int (A->order,read_size_int ( A->order,sizeof (int*)),0)+1,return_max_int (A->order,read_size_int ( A->order,sizeof (int*)),1)+A->len_aln+1);    \r
6348      pos=aln2pos_simple(A,A->nseq);\r
6349      \r
6350      for ( b=0; b<A->len_aln; b++)\r
6351          for ( a=0; a< A->nseq; a++)     \r
6352              {\r
6353              seq=A->order[a][0];\r
6354              if ( pos[a][b]<=0);\r
6355              else if ( pos[a][b]>0)\r
6356                  {\r
6357                  \r
6358                  if (cache[seq][pos[a][b]]==0)cache[seq][pos[a][b]]++;\r
6359                  else if ( cache[seq][pos[a][b]]>=1)\r
6360                       {      \r
6361                       cache[seq][pos[a][b]]++;\r
6362                       A->seq_al[a][b]='\0';\r
6363                       }\r
6364                  }\r
6365              }\r
6366      \r
6367      A->len_aln=get_shortest_string ( A->seq_al, A->nseq, NULL, NULL);\r
6368      pad_string_array ( A->seq_al, A->nseq, A->len_aln, '-');\r
6369      \r
6370      free_int (pos, -1);\r
6371      free_int ( cache,-1);\r
6372      \r
6373      \r
6374      return A;\r
6375      }\r
6376 \r
6377 int get_nol_aln_border ( Alignment *A, int start, int direction)\r
6378      {\r
6379      int a, b;\r
6380      int **pos;\r
6381      int **cache;\r
6382      int seq,end;\r
6383      \r
6384      /*This Function Returns the limit position for a non overlaping alignment*/\r
6385      \r
6386      cache=declare_int (return_max_int (A->order,read_size_int ( A->order,sizeof (int*)),0)+1,return_max_int (A->order,read_size_int ( A->order,sizeof (int)),1)+A->len_aln+1);\r
6387      pos=aln2pos_simple(A,A->nseq);\r
6388      end=(direction==GO_RIGHT)?A->len_aln:-1;\r
6389      \r
6390 \r
6391      for ( b=start; b!=end;b+=direction)\r
6392          for ( a=0; a< A->nseq; a++)     \r
6393              {\r
6394              seq=A->order[a][0];\r
6395              if ( pos[a][b]<=0);\r
6396              else if ( pos[a][b]>0)\r
6397                  {\r
6398                  \r
6399                  if (cache[seq][pos[a][b]]==0)cache[seq][pos[a][b]]++;\r
6400                  else if ( cache[seq][pos[a][b]]>=1)\r
6401                       {      \r
6402                       cache[seq][pos[a][b]]++;\r
6403                       free_int(cache, -1);\r
6404                       return b-direction;\r
6405                       }\r
6406                  }\r
6407              }\r
6408      \r
6409      free_int ( cache,-1);\r
6410      free_int (pos, -1);\r
6411      return end-direction;\r
6412      }\r
6413 \r
6414 \r
6415 \r
6416 \r
6417 \r
6418 char * extract_defined_seq ( char *in, int in_of, int in_start, int *aa_def, int dir, int *out_start, char *out)\r
6419      {\r
6420      int start=0, end,l;\r
6421      int b, c, d;\r
6422 \r
6423      \r
6424 \r
6425      if ( dir==GO_LEFT){start=in_start-1;}\r
6426      else if ( dir==GO_RIGHT){start=in_start+1;}        \r
6427         \r
6428      end=start;\r
6429      while (aa_def[end]!=UNDEFINED)\r
6430          {\r
6431          end+=dir;\r
6432          }\r
6433      end-=dir;\r
6434      \r
6435      if (end<start)SWAP(end,start);\r
6436      \r
6437      l=strlen ( in);\r
6438      out_start[0]=-1;\r
6439      for (b=0,d=0,c=in_of;b<l; b++)\r
6440          {\r
6441          c+=1-is_gap(in[b]);\r
6442          if ( c>=start && c<=end)\r
6443              {\r
6444              if ( out_start[0]==-1)out_start[0]=c-!is_gap(in[b]);\r
6445              out[d++]=in[b];\r
6446              }\r
6447          }\r
6448      out[d]='\0';\r
6449      \r
6450     \r
6451      return out;\r
6452      }\r
6453 Alignment * concatenate_aln ( Alignment *A1, Alignment *A2, char *spacer)\r
6454 {\r
6455   Alignment *A;\r
6456   int a, i;\r
6457   \r
6458   A=declare_aln2( A1->nseq+A2->nseq , A1->len_aln+A2->len_aln+1);\r
6459   for ( a=0; a< A1->nseq; a++)\r
6460     {\r
6461       if ((i=name_is_in_list ( A1->name[a], A2->name, A2->nseq, 100))!=-1)\r
6462         {\r
6463           sprintf ( A->name[A->nseq], "%s", A1->name[a]);\r
6464           sprintf (A->seq_al[A->nseq], "%s%s%s", A1->seq_al[a],(spacer)?spacer:"", A2->seq_al[i]);\r
6465           A->nseq++;\r
6466         }\r
6467       else \r
6468         {\r
6469           char *buf;\r
6470           buf=generate_string (A2->len_aln, '-');\r
6471           sprintf ( A->name[A->nseq], "%s", A1->name[a]);\r
6472           sprintf (A->seq_al[A->nseq], "%s%s",  A1->seq_al[a], buf);\r
6473           A->nseq++;\r
6474           vfree (buf);\r
6475         }\r
6476     }\r
6477   for ( a=0; a< A2->nseq; a++)\r
6478     {\r
6479       if ((i=name_is_in_list ( A2->name[a], A1->name, A1->nseq, 100))==-1)\r
6480         {\r
6481           char *buf;\r
6482           buf=generate_string (A1->len_aln, '-');\r
6483           sprintf ( A->name[A->nseq], "%s", A2->name[a]);\r
6484           sprintf (A->seq_al[A->nseq], "%s%s",  buf, A2->seq_al[a]);\r
6485           A->nseq++;\r
6486           vfree (buf);\r
6487         }\r
6488     }\r
6489   A->len_aln=A1->len_aln+A2->len_aln;\r
6490   return A;\r
6491 }\r
6492 Alignment * aln_cat ( Alignment *A, Alignment *B)\r
6493      { \r
6494      int a;\r
6495      \r
6496      if ( A->nseq!=B->nseq) \r
6497          {\r
6498          fprintf ( stderr, "\nERROR IN ALN CAT: DIFFERENT NSEQ\n");\r
6499          myexit(EXIT_FAILURE);\r
6500          }\r
6501 \r
6502      A=realloc_alignment2(A, A->nseq,A->len_aln+B->len_aln+1);\r
6503     \r
6504      for ( a=0;a< A->nseq; a++)\r
6505          {      \r
6506          strcat ( A->seq_al[a], B->seq_al[a]);\r
6507          }\r
6508      A->len_aln+=B->len_aln;\r
6509      return A;\r
6510      }\r
6511 int verify_aln ( Alignment *A, Sequence *S, char *message)\r
6512      {\r
6513      int a, b, c,s,r;\r
6514 \r
6515 \r
6516      for ( a=0;a< A->nseq; a++)\r
6517          {\r
6518          s=A->order[a][0];\r
6519          r=A->order[a][1];\r
6520          for ( b=0, c=0; b< A->len_aln; b++)\r
6521              {\r
6522              if ( !is_gap(A->seq_al[a][b]))\r
6523                   {\r
6524                   if (tolower(A->seq_al[a][b])!=tolower(S->seq[s][c+r]))\r
6525                       {\r
6526                       fprintf ( stderr, "\n%s\nResidue [%c %d, %c %d] line %d seq %d",message,A->seq_al[a][b], b,S->seq[s][c+r], c+r,a,s);  \r
6527                       output_Alignment_with_res_number(A, stderr);\r
6528                       myexit(EXIT_FAILURE);\r
6529                       return 0;\r
6530                       }\r
6531                   c++;\r
6532                   }\r
6533              }\r
6534          }\r
6535      return 1;\r
6536      }\r
6537 \r
6538 Alignment *adjust_est_aln ( Alignment *PW, Alignment *M, int s)\r
6539 {\r
6540   /*This function reajusts M, threading M onto PW\r
6541    two seqences in PW\r
6542    s+1 seq in M\r
6543    \r
6544    seq 0 PW ----> 0->s-1 in M\r
6545    seq 1 PW ----> 1->s   in M;\r
6546    \r
6547    */\r
6548   int a, b;\r
6549   static char **array;\r
6550 \r
6551   \r
6552   int top_M=0;\r
6553   int bottom_M=0;\r
6554   \r
6555   \r
6556   if ( array==NULL)\r
6557     {\r
6558       array=declare_char (500, 100000);\r
6559     }\r
6560 \r
6561   for ( a=0; a< PW->len_aln; a++)\r
6562     {\r
6563       if ( is_gap(PW->seq_al[0][a]))\r
6564         {\r
6565           for ( b=0; b< s; b++)\r
6566             array[b][a]='-';\r
6567         }\r
6568       else\r
6569         {\r
6570           for ( b=0; b< s; b++)\r
6571             array[b][a]=M->seq_al[b][top_M];\r
6572         top_M++;\r
6573         }\r
6574       \r
6575       if ( is_gap(PW->seq_al[1][a]))\r
6576         {\r
6577           array[s][a]='-';\r
6578         }\r
6579       else\r
6580         {\r
6581           \r
6582           array[s][a]=M->seq_al[s][bottom_M];\r
6583         bottom_M++;\r
6584         } \r
6585     }\r
6586   \r
6587   M->len_aln=PW->len_aln;\r
6588   for (a=0; a<s; a++)\r
6589     {\r
6590       for (b=0; b<PW->len_aln; b++)\r
6591         M->seq_al[a][b]=array[a][b];\r
6592       M->seq_al[a][b]='\0';\r
6593     }\r
6594 \r
6595 \r
6596   M->nseq=s+1;\r
6597   \r
6598   return M;\r
6599 }\r
6600 \r
6601 \r
6602 Alignment * rename_seq_in_aln (Alignment *A, char ***list)\r
6603 {\r
6604   int n, i;\r
6605   if ( !A)return A;\r
6606   \r
6607 \r
6608   \r
6609   n=0;\r
6610   while ( list[n][0][0])\r
6611     {\r
6612       if ( (i=name_is_in_list (list[n][0], A->name, A->nseq, 100))!=-1)\r
6613         {\r
6614           sprintf ( A->name[i], "%s", list[n][1]);\r
6615         }\r
6616       n++;\r
6617     }\r
6618   \r
6619   A->S=rename_seq_in_seq (A->S, list);\r
6620   return A;\r
6621 }\r
6622 Sequence * rename_seq_in_seq (Sequence *A, char ***list)\r
6623 {\r
6624   int n, i;\r
6625   if ( !A || !list)return A;\r
6626   \r
6627   n=0;\r
6628   while ( list[n][0][0])\r
6629     {\r
6630       if ( (i=name_is_in_list (list[n][0], A->name, A->nseq, 100))!=-1)\r
6631         {\r
6632           sprintf ( A->name[i], "%s", list[n][1]);\r
6633         }\r
6634       n++;\r
6635     }\r
6636   return A;\r
6637 }\r
6638 /********************************************************************/\r
6639 /*                                                                  */\r
6640 /*                   FLOAT SIMILARITIES                             */\r
6641 /*                                                                  */\r
6642 /*                                                                  */\r
6643 /*                                                                  */\r
6644 /********************************************************************/\r
6645 float get_seq_fsim ( char *string1, char *string2, char *ignore, char *similarity_set,int **matrix, int MODE )\r
6646         {\r
6647         int len, a, r1, r2, nr1=0, nr2=0;\r
6648         float pos=0, sim=0;\r
6649                 \r
6650 \r
6651         len=MIN((strlen (string1)),(strlen (string2)));\r
6652         if ( len==0)return 0;\r
6653         \r
6654         for ( a=0; a< len; a++)\r
6655                 {\r
6656                   \r
6657                   r1=string1[a];\r
6658                   r2=string2[a];\r
6659                   nr1+=!is_gap(r1);\r
6660                   nr2+=!is_gap(r2);\r
6661                   \r
6662                   if ( !is_in_set (r1, ignore) && !is_in_set (r2, ignore))\r
6663                         {\r
6664                         pos++;\r
6665                         if ( matrix)sim+=matrix[r1-'A'][r2-'A'];\r
6666                         else if (is_in_same_group_aa(r1,r2,0, NULL,similarity_set))\r
6667                                 {\r
6668                                 sim++;\r
6669                                 }\r
6670                         }\r
6671                 }\r
6672         if ( MODE==UNGAPED_POSITIONS)return ( sim*100)/pos;\r
6673         else if ( MODE==ALIGNED_POSITIONS)return (sim*100)/len;\r
6674         else if ( MODE==AVERAGE_POSITIONS)return (sim*200)/(nr1+nr2);\r
6675         else\r
6676           {\r
6677             return 0;\r
6678           }\r
6679         \r
6680         }\r
6681 float get_seq_fsim2 ( char *string1, char *string2, char *ignore, char *in_mode)\r
6682         {\r
6683         int len1;\r
6684         int a;\r
6685         int p1, p2;\r
6686         int r1=0,r2=0;\r
6687         char *p;\r
6688         char mode[1000];\r
6689         float r=0, pos1, pos2, pos0, gap, sim;\r
6690         \r
6691 \r
6692         sprintf ( mode, "%s", in_mode);\r
6693         \r
6694         /*mode: <mat>__<sim_mode>\r
6695           mat: idscore to get the alignment done\r
6696                any legal cw matrix\r
6697           sim_mode: sim1->identities/matches\r
6698                     sim2->identities/min len     \r
6699         */\r
6700 \r
6701                 \r
6702         if ( (p=strstr (mode, "_"))!=NULL)\r
6703           {\r
6704             p[0]='\0';\r
6705             p++;\r
6706           }\r
6707 \r
6708                 \r
6709         if (strstr (mode, "idscore"))\r
6710           {\r
6711             static int **mat;\r
6712             if (!mat) mat=read_matrice ("blosum62mt");\r
6713             return idscore_pairseq (string1, string2, -12, -1, mat,mode);\r
6714             \r
6715           }\r
6716         \r
6717         len1=strlen (string1);\r
6718         for ( sim=pos1=pos2=pos0=gap=0,a=0; a< len1; a++)\r
6719                 {\r
6720                   r1=string1[a];\r
6721                   r2=string2[a];\r
6722                   p1=1-is_in_set (r1, ignore);\r
6723                   p2=1-is_in_set (r2, ignore);\r
6724                   pos1+=p1; pos2+=p2;\r
6725                   if (p1 && p2)\r
6726                         {\r
6727                           pos0++;\r
6728                           if (is_in_same_group_aa(r1,r2,0, NULL, mode))\r
6729                             {                 \r
6730                               sim++;\r
6731                             }\r
6732                         }\r
6733                   else if (p1+p2==1)\r
6734                     {\r
6735                       gap++;\r
6736                     }\r
6737                 }\r
6738 \r
6739         if ( p==NULL || strm (p, "sim1") || strm (p, "sim"))\r
6740           {\r
6741             r=(pos0==0)?0:(sim*MAXID)/pos0;\r
6742           }\r
6743         else if ( strm (p, "sim2"))\r
6744           {\r
6745             r=(pos1==0 || pos2==0)?0:(sim*MAXID)/MIN(pos1,pos2);\r
6746           }\r
6747         else if ( strm (p, "sim3"))\r
6748           {\r
6749             r=(pos1==0 || pos2==0)?0:(sim*MAXID)/MAX(pos1,pos2);\r
6750           }\r
6751         else if ( strm (p, "gap1"))\r
6752           {\r
6753             r=(len1==0)?MAXID:(gap*MAXID)/len1;\r
6754             r=MAXID-r;\r
6755           }\r
6756         else if ( strm (p, "logid"))\r
6757           {\r
6758             r=logid_score (pos0, sim);\r
6759           }\r
6760 \r
6761         return r;\r
6762         \r
6763         }       \r
6764 \r
6765 /********************************************************************/\r
6766 /*                                                                  */\r
6767 /*                   ALIGNMENT ANALYSES                             */\r
6768 /*                                                                  */\r
6769 /*                                                                  */\r
6770 /*                                                                  */\r
6771 /********************************************************************/\r
6772 int **dist_array2sim_array ( int **p, int max)\r
6773 {\r
6774   int s1, s2, a, b;\r
6775   s1=read_array_size ((void *)p, sizeof (void *));\r
6776   s2=read_array_size ((void*)p[0],sizeof (int));\r
6777   /*  s2=read_array_size ((void*)p[0],sizeof (void *)); OLD before 64 BITS*/\r
6778   for ( a=0; a< s1; a++)\r
6779     for ( b=0; b< s2; b++)\r
6780       {\r
6781         p[a][b]=max-p[a][b];\r
6782       } \r
6783   return p;\r
6784 }\r
6785 \r
6786 int **sim_array2dist_array ( int **p, int max)\r
6787 {\r
6788   int s1, s2, a, b;\r
6789   s1=read_array_size ((void *)p, sizeof (void *));\r
6790   s2=read_array_size ((void*)p[0],sizeof (int));\r
6791 \r
6792   /*s2=read_array_size ((void*)p[0],sizeof (void *)); OLD before 64 Bits stuff*/ \r
6793  for ( a=0; a< s1; a++)\r
6794     for ( b=0; b< s2; b++)\r
6795       {\r
6796         p[a][b]=max-(int)p[a][b];\r
6797       } \r
6798   return p;\r
6799 }\r
6800 \r
6801 int **normalize_array (int **p, int max, int norm)\r
6802 {\r
6803 int s1, s2, a, b;\r
6804  s1=read_array_size ((void *)p, sizeof (void *));\r
6805  s2=read_array_size ((void*)p[0],sizeof (int));\r
6806  \r
6807  /*s2=read_array_size ((void*)p[0],sizeof (void *)); OLD before 64 Bits stuff*/ \r
6808  for ( a=0; a< s1; a++)\r
6809    for ( b=0; b< s2; b++)\r
6810      {\r
6811        p[a][b]=(p[a][b]*norm)/max;\r
6812       } \r
6813  return p;\r
6814 }\r
6815 \r
6816 int aln2most_similar_sequence ( Alignment *A, char *mode)\r
6817 {\r
6818   int **w;\r
6819   int a, b;\r
6820   int avg, best_avg=0, best_seq=0;\r
6821   char *buf;\r
6822   int coverage;\r
6823 \r
6824   \r
6825   if ( !A) return -1;\r
6826   else if ( A->nseq==1)return 0;\r
6827   else\r
6828     {\r
6829       buf=vcalloc ( A->len_aln+1, sizeof (char));\r
6830       w=get_sim_aln_array ( A, mode);\r
6831       \r
6832       for ( a=0; a< A->nseq; a++)\r
6833         {\r
6834           sprintf ( buf, "%s", A->seq_al[a]);\r
6835           ungap(buf);\r
6836           coverage=(strlen(buf)*MAXID)/A->len_aln;\r
6837           \r
6838           for ( avg=0,b=0; b< A->nseq; b++)avg+=w[a][b]*coverage;\r
6839           if ( avg>best_avg){best_avg=avg; best_seq=a;}\r
6840         }\r
6841       free_int (w, -1);\r
6842       vfree (buf);\r
6843       return best_seq;\r
6844     }\r
6845   \r
6846 }\r
6847 \r
6848 \r
6849 \r
6850 int aln2coverage ( Alignment *A, int ref_seq)\r
6851 {\r
6852   int a,b;\r
6853   int cov_pos=0, npos=0;\r
6854 \r
6855   for ( a=0; a< A->len_aln; a++)\r
6856     {\r
6857       if ( !is_gap ( A->seq_al[ref_seq][a]))\r
6858         {\r
6859           npos++;\r
6860           for ( b=0; b< A->nseq; b++)\r
6861             {\r
6862               if ( b!=ref_seq && !is_gap ( A->seq_al[b][a])){cov_pos++;break;}\r
6863             }\r
6864         }\r
6865     }\r
6866   return  (int) (npos==0)?0:(( MAXID*cov_pos)/A->len_aln);\r
6867 }\r
6868  \r
6869 \r
6870 int sub_aln2sim ( Alignment *A, int *ns, int **ls, char *mode)\r
6871 {\r
6872   int a, b, n;\r
6873   float avg;\r
6874 \r
6875   n=0; avg=0;\r
6876   if (!A || (ns==NULL && A->nseq<2))return -1;\r
6877   else if (ns==NULL)\r
6878     {\r
6879       for (a=0; a< A->nseq-1; a++)\r
6880         for ( b=a+1; b< A->nseq;b++, n++)\r
6881           avg+=generic_get_seq_sim (A->seq_al[a], A->seq_al[b], NULL, mode);\r
6882     }\r
6883   else\r
6884     {\r
6885       for (a=0; a<ns[0]; a++)\r
6886         for (b=0; b< ns[1]; b++, n++)\r
6887           {\r
6888             avg+=generic_get_seq_sim (A->seq_al[ls[0][a]], A->seq_al[ls[1][b]], NULL, mode);\r
6889           }\r
6890     }\r
6891   return (int)(n==0)?0:((float)avg/(float)n);\r
6892 }\r
6893 int sub_aln2max_sim ( Alignment *A, int *ns, int **ls, char *mode)\r
6894 {\r
6895   int a, b, n;\r
6896   float avg;\r
6897 \r
6898   n=0; avg=0;\r
6899   if (!A || (ns==NULL && A->nseq<2))return -1;\r
6900   else if (ns==NULL)\r
6901     {\r
6902       for (a=0; a< A->nseq-1; a++)\r
6903         for ( b=a+1; b< A->nseq;b++, n++)\r
6904           avg=MAX(avg,generic_get_seq_sim (A->seq_al[a], A->seq_al[b], NULL, mode));\r
6905     }\r
6906   else\r
6907     {\r
6908       for (a=0; a<ns[0]; a++)\r
6909         for (b=0; b< ns[1]; b++, n++)\r
6910           {\r
6911             avg=MAX(avg,generic_get_seq_sim (A->seq_al[ls[0][a]], A->seq_al[ls[1][b]], NULL, mode));\r
6912           }\r
6913     }\r
6914   return avg;\r
6915 }       \r
6916 \r
6917 \r
6918 double aln2entropy (Alignment *A, int *in_ls, int in_ns, float gap_threshold)\r
6919 {\r
6920   int ns, a, s, col, r,ncol;\r
6921   int *ls;\r
6922   double *count;\r
6923   double entropy=0;\r
6924   float ng;\r
6925     \r
6926   ls=vcalloc ( A->nseq, sizeof (int));\r
6927   count=vcalloc ( 26, sizeof (double));\r
6928   \r
6929   \r
6930   if ( in_ls)\r
6931     {\r
6932       ns=in_ns;\r
6933       for ( a=0; a< ns; a++)ls[a]=in_ls[a];\r
6934     }\r
6935   else \r
6936     {\r
6937       ns=A->nseq;\r
6938       for ( a=0; a< ns; a++)ls[a]=a;\r
6939     }\r
6940   \r
6941   if ( ns==0)\r
6942     {\r
6943       vfree(ls);vfree(count);return 0;\r
6944     }\r
6945   for (ncol=0,col=0; col<A->len_aln; col++)\r
6946     {\r
6947       for (ng=0,a=0; a< ns; a++) \r
6948         {\r
6949           s=ls[a];\r
6950           ng+=is_gap(A->seq_al[s][col]);\r
6951         }\r
6952       ng/=ns;\r
6953       if ( ng>gap_threshold)continue;\r
6954       \r
6955       ncol++;\r
6956       \r
6957       for ( a=0; a<ns; a++)\r
6958         {\r
6959           s=ls[a];\r
6960           r=tolower(A->seq_al[s][col]);\r
6961           if (!is_gap(r))count[r-'a']++;\r
6962         }\r
6963       for (a=0; a<26; a++)\r
6964         {\r
6965           if ( count[a]==0);\r
6966           else \r
6967             {\r
6968               count[a]/=(double)ns;\r
6969               \r
6970               entropy+=count[a]*log(count[a]);\r
6971               count[a]=0;\r
6972             }\r
6973         }\r
6974     }\r
6975   entropy/=-ncol;\r
6976   vfree (ls); vfree(count);\r
6977   \r
6978   return entropy;\r
6979 }\r
6980 int aln2sim ( Alignment *A, char *mode)\r
6981 {\r
6982   return sub_aln2sim ( A, NULL, NULL, mode);\r
6983   /*\r
6984   if ( !A || A->nseq<2) return -1;\r
6985   w=get_sim_aln_array ( A, mode);\r
6986 \r
6987   for (c=0, a=0; a< A->nseq-1; a++)\r
6988     for ( b=a+1; b< A->nseq; b++, c++)\r
6989       {\r
6990         avg+=(float)w[a][b];\r
6991       }\r
6992   free_int (w, -1);\r
6993   return (int)((float)avg/(float)c);\r
6994   */\r
6995 }\r
6996 \r
6997 int aln_is_aligned ( Alignment *A)\r
6998 {\r
6999   int a, b;\r
7000   \r
7001   if ( !A)return 0;\r
7002   for (a=0; a< A->nseq; a++)\r
7003     for ( b=A->len_aln-1; b>0; b--)\r
7004       {\r
7005         if (!is_gap(A->seq_al[a][b]) && is_gap(A->seq_al[a][b-1]))return 1;\r
7006       }\r
7007   return 0;\r
7008 }\r
7009         \r
7010 \r
7011 int seq2aln2sim_old ( char *seq1, char *seq2, char *mode_aln, char *mode_id)\r
7012 {\r
7013   Alignment *A;\r
7014   int sim;\r
7015 \r
7016   A=align_two_sequences (seq1, seq2, "pam250mt", -10, -1, mode_aln);\r
7017   sim=aln2sim (A, mode_id);\r
7018   free_aln (A);\r
7019   return sim;\r
7020 }\r
7021 int seq2aln2sim ( char *seq1, char *seq2, char *mode_aln, char *mode_id)\r
7022 {\r
7023   Alignment *A;\r
7024   int sim;\r
7025   static int gop;\r
7026   \r
7027   if (!gop)\r
7028     {\r
7029       int **m;\r
7030       m=read_matrice ("blosum62mt");\r
7031       gop=get_avg_matrix_mm(m, AA_ALPHABET)*10;\r
7032       free_int (m, -1);\r
7033     }\r
7034   \r
7035   A=align_two_sequences (seq1, seq2, "blosum62mt",gop,-1, mode_aln);\r
7036   sim=aln2sim (A, mode_id);\r
7037   free_aln (A);\r
7038   return sim;\r
7039 }\r
7040 int* get_cdna_seq_winsim ( int *cache, char *string1, char *string2, char *ignore, char *mode,int *w )\r
7041         {\r
7042         int len1, len2;\r
7043         int a, x;\r
7044 \r
7045         \r
7046         len1=strlen (string1);\r
7047         len2=strlen (string2);\r
7048                 \r
7049         if ( len1!=len2)\r
7050           {\r
7051             fatal_exit( stderr,EXIT_FAILURE, "\nTHE TWO cDNAs DO NOT HAVE THE SAME LENGTH [FATAL:get_cdna_seq_sim:%s", PROGRAM);\r
7052           }\r
7053         \r
7054         x=get_cdna_seq_sim(cache, string1, string2, ignore, "");\r
7055         for ( a=0; a< len1; a++)\r
7056           w[a]=x;\r
7057 \r
7058         add_warning (stderr, "\nWARNING: winsim not implemented for cDNA");\r
7059         return w;\r
7060         }\r
7061 \r
7062 int get_cdna_seq_sim ( int *cache, char *string1, char *string2, char *ignore, char *mode)\r
7063         {\r
7064         int len1;\r
7065         int len2;\r
7066         int a;\r
7067         int pos=0;\r
7068         int sim=0;\r
7069         char r1=0, r2=0;\r
7070         \r
7071         len1=strlen (string1);\r
7072         len2=strlen (string2);\r
7073 \r
7074 \r
7075         \r
7076         if ( len1!=len2)\r
7077           {\r
7078             fprintf ( stderr, "\nTHE TWO cDNAs DO NOT HAVE THE SAME LENGTH [FATAL:get_cdna_seq_sim:%s", PROGRAM);\r
7079             crash("");\r
7080           }\r
7081             \r
7082         for ( a=0; a< len1;)\r
7083                 {\r
7084                  \r
7085                   if ( cache[a]==0){a++;continue;}\r
7086                   else if ( cache[a]==1)\r
7087                     {\r
7088                       \r
7089                       r1=translate_dna_codon (string1+a, 'x');\r
7090                       r2=translate_dna_codon (string2+a, 'x');\r
7091                       a+=3;\r
7092                     }\r
7093                   \r
7094                   if ( !is_in_set (r1, ignore) && !is_in_set (r2, ignore))\r
7095                         {\r
7096                         pos++;\r
7097                         if (is_in_same_group_aa(r1,r2,0, NULL,mode+4))\r
7098                                 {\r
7099                                 sim++;\r
7100                                 }\r
7101                         }\r
7102                 }\r
7103 \r
7104 \r
7105 \r
7106         if (pos==0)\r
7107                  return 0;\r
7108         else    \r
7109                 return (int) (sim*MAXID)/pos;\r
7110         \r
7111         }       \r
7112 \r
7113 int* get_seq_winsim ( char *string1, char *string2, char *ignore, char *mode, int*w)\r
7114         {\r
7115         int len1, len2, len;\r
7116         int left, right;\r
7117         int a,b;\r
7118         int sim=0;\r
7119         int window;\r
7120         int r1, r2;\r
7121 \r
7122         len1=strlen (string1);\r
7123         len2=strlen (string2);\r
7124         window=atoi(mode);\r
7125         len=2*window+1;\r
7126         \r
7127         if ( len1!=len2)return 0;\r
7128         if (window==0 || (window*2+1)>=len1)\r
7129           {\r
7130             sim=get_seq_sim (string1, string2, ignore, "");\r
7131             for (a=0; a<len1; a++)w[a]=sim;\r
7132             return w;\r
7133           }\r
7134         \r
7135 \r
7136         for ( a=0; a< len1; a++)\r
7137                 {\r
7138                   \r
7139                   left =MAX(0, a-window);\r
7140                   right=MIN(len1, left+len);\r
7141                   for (sim=0,b=left; b<right; b++)\r
7142                     {\r
7143                       r1=string1[b];\r
7144                       r2=string2[b];\r
7145                       if (  !is_in_set (r1, ignore) && !is_in_set (r2, ignore))\r
7146                         {\r
7147                           if (r1==r2)sim++;\r
7148                         }\r
7149                     }\r
7150                   w[a]=(sim*MAXID)/len;\r
7151                 }\r
7152         return w;\r
7153         }\r
7154 \r
7155 \r
7156 int get_seq_sim ( char *string1, char *string2, char *ignore, char *in_mode)\r
7157         {\r
7158         int len1;\r
7159         int a;\r
7160         int pos1, pos2, pos0,gap=0, sim;\r
7161         int p1, p2;\r
7162         int r=0,r1=0,r2=0;\r
7163         char *p;\r
7164         static char *mode;\r
7165         \r
7166         if (!mode)mode=vcalloc (100, sizeof (char));\r
7167         else mode[0]='\0';\r
7168         if (in_mode)\r
7169           {\r
7170             while (in_mode[0]=='_')in_mode++;\r
7171             sprintf ( mode, "%s", in_mode);\r
7172           }\r
7173         \r
7174         /*mode: <mat>__<sim_mode>\r
7175           mat: idscore to get the alignment done\r
7176                any legal cw matrix\r
7177           sim_mode: sim1->identities/matches\r
7178                     sim2->identities/min len     \r
7179         */\r
7180 \r
7181         \r
7182         if ( (p=strstr (mode, "_"))!=NULL)\r
7183           {\r
7184             p[0]='\0';\r
7185             p++;\r
7186           }\r
7187 \r
7188             \r
7189         if (strstr (mode, "idscore"))\r
7190           {\r
7191             static int **mat;\r
7192             if (!mat) mat=read_matrice ("blosum62mt");\r
7193             return idscore_pairseq (string1, string2, -12, -1, mat,mode);\r
7194             \r
7195           }\r
7196         len1=strlen (string1);\r
7197         for ( sim=pos1=pos2=pos0=0,a=0; a< len1; a++)\r
7198                 {\r
7199                   r1=string1[a];\r
7200                   r2=string2[a];\r
7201                   p1=1-is_in_set (r1, ignore);\r
7202                   p2=1-is_in_set (r2, ignore);\r
7203                   \r
7204                   pos1+=p1; pos2+=p2;\r
7205                   if (p1 && p2)\r
7206                         {\r
7207                           pos0++;\r
7208                           if (is_in_same_group_aa(r1,r2,0, NULL, mode))\r
7209                             {                 \r
7210                               sim++;\r
7211                             }\r
7212                         }\r
7213                   else if (p1+p2==1)\r
7214                     {\r
7215                       gap++;\r
7216                     }\r
7217                 }\r
7218         \r
7219         if ( strstr (mode, "cov"))\r
7220           {\r
7221             r=(pos0+gap==0)?0:(pos0*MAXID)/(pos0+gap);\r
7222           }\r
7223         else if ( p==NULL || strm (p, "sim1") || strm (p, "sim"))\r
7224           {\r
7225             r=(pos0==0)?0:(sim*MAXID)/pos0;\r
7226           }\r
7227         else if ( strm (p, "sim2"))\r
7228           {\r
7229             r=(pos1==0 || pos2==0)?0:(sim*MAXID)/MIN(pos1,pos2);\r
7230           }\r
7231         else if ( strm (p, "sim3"))\r
7232           {\r
7233             r=(pos1==0 || pos2==0)?0:(sim*MAXID)/MAX(pos1,pos2);\r
7234           }\r
7235         else if ( strm (p, "gap1"))\r
7236           {\r
7237             r=(len1==0)?MAXID:(gap*MAXID)/len1;\r
7238             r=MAXID-r;\r
7239           }\r
7240         else if ( strm (p, "logid"))\r
7241           {\r
7242             r=logid_score (pos0, sim);\r
7243           }\r
7244         else if ( strstr (mode, "sim"))\r
7245           {\r
7246             r=(pos0==0)?0:(sim*MAXID)/pos0;\r
7247           }\r
7248 \r
7249         \r
7250         return r;\r
7251         \r
7252         }       \r
7253 int get_seq_sim_2 ( char *string1, char *string2, char *ignore, char **gr, int ng)\r
7254         {\r
7255         int len1;\r
7256         int len2;\r
7257         int a;\r
7258         int pos=0;\r
7259         int sim=0;\r
7260         char r1, r2;\r
7261         \r
7262         \r
7263         len1=strlen (string1);\r
7264         len2=strlen (string2);\r
7265         \r
7266         if ( len1!=len2)return 0;\r
7267         \r
7268         for ( a=0; a< len1; a++)\r
7269                 {\r
7270                 r1=string1[a];\r
7271                 r2=string2[a];\r
7272                 if ( !is_in_set (r1, ignore) && !is_in_set (r2, ignore))\r
7273                         {\r
7274                         pos++;\r
7275                         if (is_in_same_group_aa(r1,r2,ng, gr, NULL))\r
7276                                 {\r
7277                                 sim++;\r
7278                                 }\r
7279                         }\r
7280                 }\r
7281         \r
7282         if (pos==0)\r
7283                  return 0;\r
7284         else    \r
7285                 return (int) (sim*MAXID)/pos;\r
7286         \r
7287         }\r
7288 \r
7289 int get_seq_sim_3 ( char *string1, char *string2, char *ignore, int **mat)\r
7290         {\r
7291         int len1;\r
7292         int len2;\r
7293         int a;\r
7294         \r
7295         int sim=0;\r
7296         char r1, r2;\r
7297         \r
7298         \r
7299         len1=strlen (string1);\r
7300         len2=strlen (string2);\r
7301         \r
7302         if ( len1!=len2)return 0;\r
7303         \r
7304         for ( a=0; a< len1; a++)\r
7305                 {\r
7306                 r1=string1[a];\r
7307                 r2=string2[a];\r
7308                 if ( !is_in_set (r1, ignore) && !is_in_set (r2, ignore))\r
7309                         {\r
7310                         sim+=mat[r1-'A'][r2-'A'];\r
7311                         }\r
7312                 }\r
7313         return sim;\r
7314         \r
7315         }       \r
7316 int * get_aln_col_weight ( Alignment *A, char *mode)\r
7317         {\r
7318         int a, b;\r
7319         char *col;\r
7320         int *weight;\r
7321         \r
7322         col=vcalloc ( A->nseq, sizeof (int));\r
7323         weight=vcalloc (A->len_aln, sizeof (int));\r
7324         \r
7325         for (a=0; a< A->len_aln; a++)\r
7326                 {\r
7327                 for ( b=0; b< A->nseq; b++)\r
7328                         col[b]=A->seq_al[b][a];\r
7329                 weight[a]=(find_group_aa_distribution (col, A->nseq,0,NULL,NULL, mode )*MAXID)/A->nseq;          \r
7330                 }\r
7331         vfree (col);\r
7332         return weight;\r
7333         \r
7334         }       \r
7335                         \r
7336 int analyse_aln_column ( Alignment *B, int col)\r
7337     {\r
7338 \r
7339     char r=' ';\r
7340     int a, b, c=0;\r
7341     static char *mat;\r
7342     static int ng_cw_star;\r
7343     static char **cw_star;\r
7344     int *cw_star_count;\r
7345     \r
7346     static int ng_cw_col;\r
7347     static char **cw_col;\r
7348     int *cw_col_count;\r
7349     \r
7350     static int ng_cw_dot;\r
7351     static char **cw_dot;\r
7352     int *cw_dot_count;\r
7353     \r
7354 \r
7355 \r
7356 \r
7357     \r
7358     \r
7359     if ( !B->S || !(B->S)->type)B= get_aln_type (B);\r
7360     \r
7361     if ( !mat)mat=vcalloc ( STRING, sizeof (char));\r
7362 \r
7363     if ( !ng_cw_star)\r
7364        {\r
7365            cw_star=make_group_aa ( &ng_cw_star, strcpy ( mat,"idmat"));\r
7366            cw_col=make_group_aa ( &ng_cw_col, strcpy (mat,"clustalw_col"));\r
7367            cw_dot=make_group_aa ( &ng_cw_dot, strcpy (mat, "clustalw_dot"));\r
7368        }\r
7369 \r
7370     cw_star_count=vcalloc (ng_cw_star, sizeof (int));\r
7371     cw_col_count=vcalloc ( ng_cw_col, sizeof (int));\r
7372     cw_dot_count=vcalloc (ng_cw_dot, sizeof (int));\r
7373     \r
7374     for ( a=0; a< B->nseq; a++)\r
7375         {\r
7376         c=tolower (B->seq_al[a][col]);\r
7377         if (is_gap(c)){r=' ';break;}\r
7378           \r
7379         for ( b=0; b< ng_cw_star; b++)\r
7380             cw_star_count[b]+=is_in_set (c, cw_star[b]);        \r
7381         for ( b=0; b< ng_cw_col; b++)\r
7382             cw_col_count[b]+=is_in_set  (c, cw_col[b]);\r
7383         for ( b=0; b< ng_cw_dot; b++)\r
7384             cw_dot_count[b]+=is_in_set  (c, cw_dot[b]);\r
7385         }\r
7386     \r
7387    \r
7388    \r
7389    \r
7390     \r
7391     if ( !is_gap(c) && r==' ')\r
7392         for ( b=0; b< ng_cw_star; b++)if ( cw_star_count[b]==B->nseq){r='*'; break;}\r
7393     if ( !is_gap(c) && r==' ' && !(strm((B->S)->type, "DNA")||strm ((B->S)->type,"RNA")))\r
7394         for ( b=0; b< ng_cw_col ; b++)if ( cw_col_count [b]==B->nseq){r=':'; break;}\r
7395     if ( !is_gap(c) && r==' ' && !(strm((B->S)->type, "DNA")||strm ((B->S)->type,"RNA")))\r
7396         for ( b=0; b< ng_cw_dot ; b++)if ( cw_dot_count [b]==B->nseq){r='.'; break;}\r
7397     \r
7398     \r
7399     \r
7400     vfree(cw_star_count);\r
7401     vfree(cw_col_count);\r
7402     vfree(cw_dot_count);   \r
7403         \r
7404     return r;\r
7405     }\r
7406 \r
7407 \r
7408 int ** get_cov_aln_array ( Alignment *A, char *mode)\r
7409 {\r
7410   int **w;\r
7411   int a, b, c, t;\r
7412   \r
7413   w=declare_int ( A->nseq, A->nseq);\r
7414   \r
7415   \r
7416   for ( a=0; a< A->nseq-1; a++)\r
7417     {\r
7418       w[a][a]=100;\r
7419       for ( t=0,b=a+1; b< A->nseq; b++)\r
7420         {\r
7421           for ( c=0; c< A->len_aln; c++)\r
7422             {\r
7423               t+=(!is_gap(A->seq_al[a][c]) &&!is_gap(A->seq_al[b][c]));\r
7424             }\r
7425           w[a][b]=w[b][a]=(t*100)/A->len_aln;\r
7426         }\r
7427     }\r
7428   return w;\r
7429 }\r
7430 \r
7431 int ** get_cov_master_aln_array ( Alignment *A,int n, char *mode)\r
7432 {\r
7433   int **w;\r
7434   int    b, c, t;\r
7435   \r
7436   w=declare_int ( A->nseq, A->nseq);\r
7437   \r
7438   \r
7439   for (b=0; b< A->nseq; b++)\r
7440         {\r
7441           \r
7442           for (t=0, c=0; c< A->len_aln; c++)\r
7443             {\r
7444               t+=(!is_gap(A->seq_al[n][c]) &&!is_gap(A->seq_al[n][c]));\r
7445             }\r
7446           w[n][b]=w[b][n]=(t*100)/A->len_aln;\r
7447         }\r
7448     \r
7449   return w;\r
7450 }\r
7451 int ** get_sim_master_aln_array ( Alignment *A,int n, char *mode)\r
7452         {\r
7453         int **w;\r
7454         int a;\r
7455         \r
7456         w=declare_int ( A->nseq, A->nseq);\r
7457         \r
7458         \r
7459         for ( a=0; a< A->nseq; a++)\r
7460           {\r
7461             if ( strm (mode, "cdna"))\r
7462             w[n][a]=w[a][n]=get_cdna_seq_sim ( A->cdna_cache[0], A->seq_al[a], A->seq_al[n],GAP_LIST, mode);                    \r
7463           else\r
7464             w[n][a]=w[a][n]=get_seq_sim ( A->seq_al[n], A->seq_al[a],GAP_LIST, mode);\r
7465           }\r
7466         return w;\r
7467         }\r
7468 int ** get_dist_aln_array ( Alignment *A, char *mode)\r
7469 {\r
7470   \r
7471   int **w;\r
7472 \r
7473   w=get_sim_aln_array ( A, mode);\r
7474   return sim_array2dist_array(w,MAXID);\r
7475 }\r
7476 Sequence * seq2filter (Sequence *Sin, int min, int max)\r
7477 {\r
7478   int *keep;\r
7479   char *tmpfile;\r
7480   Sequence *S, *Sout;\r
7481   int a, b, sim;\r
7482   int **M;\r
7483   FILE *fp;\r
7484   int n;\r
7485 \r
7486   S=duplicate_sequence (Sin);\r
7487   for (a=0; a<S->nseq; a++)ungap(S->seq[a]);\r
7488   keep=vcalloc (S->nseq, sizeof (int));\r
7489   M=read_matrice ("blossum62mt");\r
7490   for (a=0; a<S->nseq; a++)\r
7491     {\r
7492       output_completion ( stderr, a, S->nseq, 100, "Distance Matrix Computation: ");\r
7493       for ( b=a+1; b<S->nseq; b++)\r
7494         {\r
7495           \r
7496           sim=idscore_pairseq(S->seq[a], S->seq[b],-10, -2,M, "sim");\r
7497           if ( sim>min && sim<max)keep[a]=keep[b]=1;\r
7498           fprintf ( stderr, "\nSim %d Min %d Max %d", sim, min, max);\r
7499         }\r
7500     }\r
7501 \r
7502   tmpfile=vtmpnam (NULL);\r
7503   fp=vfopen (tmpfile, "w");\r
7504   for (n=0,a=0; a< S->nseq; a++)\r
7505     if ( keep[a]) \r
7506       {\r
7507       fprintf ( fp, ">%s %s\n%s", S->name[a], S->seq_comment[a], S->seq[a]);\r
7508       n++;\r
7509       }\r
7510   vfclose (fp);\r
7511   if (n==0) return NULL;\r
7512   Sout=main_read_seq(tmpfile);\r
7513   free_int (M, -1); vfree (keep); free_sequence (S, -1);\r
7514   return Sout;\r
7515 }\r
7516 \r
7517 Alignment * grep_seq (Alignment *S,char *field, char *mode, char *string)\r
7518 {\r
7519   int a;\r
7520   FILE *fp;\r
7521   char *tmp;\r
7522   int n=0;\r
7523   \r
7524   tmp=vtmpnam (NULL);\r
7525   fp=vfopen (tmp, "w");\r
7526   \r
7527   if ( !strm(mode, "KEEP") && ! strm (mode, "REMOVE"))\r
7528     {\r
7529       add_warning ( stderr, "\nERROR: +grep <field> <KEEP|REMOVE> <string> [FATAL: %s]", PROGRAM);\r
7530       myexit (EXIT_FAILURE);\r
7531     }\r
7532   else if ( !strm(field, "SEQ") && ! strm (field, "COMMENT") && ! strm(field, "NAME"))\r
7533     {\r
7534       add_warning ( stderr, "\nERROR: +grep <NAME|COMMENT|SEQ> <mode> <string> [FATAL: %s]", PROGRAM);\r
7535       myexit (EXIT_FAILURE);\r
7536     }\r
7537   \r
7538 \r
7539   for (n=0, a=0; a< S->nseq; a++)\r
7540     {\r
7541       int found=0;\r
7542 \r
7543       if (strm(field, "NAME") && perl_strstr (S->name[a], string))found=1;\r
7544       else if (strm(field, "COMMENT") && S->seq_comment[a][0] && perl_strstr (S->seq_comment[a], string) )found=1;\r
7545       else if (strm(field, "SEQ") && perl_strstr (S->seq_al[a], string))found=1;\r
7546       \r
7547       if ( (strm (mode, "KEEP") && found) || (strm (mode, "REMOVE") && !found))\r
7548         {\r
7549           n++;\r
7550           fprintf (fp, ">%s", S->name[a]);\r
7551           if (S->seq_comment[a][0])fprintf (fp, " %s", S->seq_comment[a]);\r
7552           fprintf (fp, "\n%s\n", S->seq_al[a]);\r
7553         }\r
7554     }\r
7555   \r
7556   vfclose (fp);\r
7557   \r
7558   free_aln (S);\r
7559   if ( n==0) return NULL;\r
7560   else\r
7561     return main_read_aln (tmp, NULL);\r
7562 }\r
7563 \r
7564 Alignment * modify_seq (Alignment *S, char *field, char *string1, char *string2)\r
7565 {\r
7566   int a;\r
7567   FILE *fp;\r
7568   char *tmp;\r
7569 \r
7570   tmp=vtmpnam (NULL);\r
7571   fp=vfopen (tmp, "w");\r
7572   for ( a=0; a< S->nseq; a++)\r
7573     {\r
7574       if (strm(field, "NAME"))S->name[a]=substitute ( S->name[a], string1, string2); \r
7575       else if (strm(field, "COMMENT"))S->seq_comment[a]=substitute ( S->seq_comment[a], string1, string2); \r
7576       else if (strm(field, "SEQ"))S->seq_al[a]=substitute ( S->seq_al[a], string1, string2);\r
7577       fprintf (fp, ">%s", S->name[a]);\r
7578       if (S->aln_comment[a][0])fprintf (fp, " %s", S->aln_comment[a]);\r
7579       fprintf (fp, "\n%s\n", S->seq_al[a]);\r
7580     }\r
7581   vfclose (fp);\r
7582   free_aln (S);\r
7583   S=main_read_aln (tmp, NULL);\r
7584   return S;\r
7585 }\r
7586 \r
7587 int ** seq2sim_mat (Sequence *S, char *mode)\r
7588 {\r
7589   return seq2comp_mat ( S,mode, "sim");\r
7590 }\r
7591 int ** seq2cov_mat (Sequence *S, char *mode)\r
7592 {\r
7593   return seq2comp_mat ( S,mode, "cov");\r
7594 }\r
7595 \r
7596 int ** seq2comp_mat (Sequence *S, char *mode, char *comp_mode)\r
7597 {\r
7598   int a, b;\r
7599   int **sim;\r
7600   char file[1000];\r
7601   Alignment *A;\r
7602   char *name;\r
7603 \r
7604   \r
7605   /*Use pre_computed value if available in the current dir*/\r
7606 \r
7607   name=path2filename(S->file[0]);\r
7608   sprintf ( file, "%s%s.%s.%s_file", get_cache_dir(),name, mode, comp_mode);\r
7609   A=seq2aln(S,NULL, RM_GAP);\r
7610   if ( check_file_exists (file) && is_distance_matrix_file (file) && (sim=input_similarities(file, A, NULL))!=NULL)\r
7611     {\r
7612       display_input_filename (stderr, "SIMILARITY_MATRIX", "SIMILARITY_MATRIX_FORMAT_01", file, CHECK);\r
7613       fprintf ( stderr, "\n");\r
7614     }\r
7615   else\r
7616     {\r
7617       char mode2[1000];\r
7618       int **M;\r
7619       \r
7620       M=read_matrice (mode);\r
7621       sim=declare_int ( S->nseq, S->nseq);\r
7622       for ( a=0; a< S->nseq; a++)\r
7623         {\r
7624           ungap (S->seq[a]);\r
7625           sim[a][a]=100;\r
7626         }\r
7627 \r
7628       for ( a=0; a<S->nseq-1; a++)\r
7629         {\r
7630           \r
7631           output_completion4halfmat ( stderr, a, S->nseq, 100, "Similarity Matrix Computation: ");\r
7632           for ( b=a+1; b< S->nseq; b++)\r
7633             {\r
7634               sim[a][b]=sim[b][a]=idscore_pairseq(S->seq[a], S->seq[b],-12, -1,M, comp_mode);\r
7635             }\r
7636         }\r
7637       free_int (M,-1);\r
7638       sprintf ( mode2, "_memory_%ld", (long int)sim);\r
7639       output_similarities( file, A, mode2);\r
7640       display_output_filename (stderr, "SIMILARITY_MATRIX", "SIMILARITY_MATRIX_FORMAT_01", file, CHECK);\r
7641       fprintf ( stderr, "\n");\r
7642     }\r
7643   free_aln (A);\r
7644   return sim;\r
7645 }\r
7646 \r
7647 int ** fast_aln2sim_list (Alignment *A,  char *mode, int *ns, int **ls)\r
7648 {\r
7649   int **simm;\r
7650   int p1, p2, p3, r1, r2;\r
7651   int gap,pos0,pos1,pos2,len,sim;\r
7652   int a, b, c, m, s=0,s1, s2, n;\r
7653   int free_ns=0;\r
7654 \r
7655   if (ns==NULL)\r
7656     {\r
7657       free_ns=1;\r
7658       ns=vcalloc (2, sizeof (int));\r
7659       ns[0]=ns[1]=A->nseq;\r
7660       ls=declare_int (2, A->nseq);\r
7661       for ( a=0; a< 2; a++)\r
7662         for (b=0; b<A->nseq; b++)\r
7663           ls[a][b]=b;\r
7664     }\r
7665   \r
7666 \r
7667   simm=declare_int (ns[0]*ns[1]+1, 3);\r
7668   \r
7669   if (strstr (mode, "sim1"))m=0;\r
7670   else if (strstr (mode, "sim2"))m=1;\r
7671   else if (strstr (mode, "sim3"))m=2;\r
7672   else if (strstr (mode, "gap1"))m=3;\r
7673   else if (strstr (mode, "cov1"))m=4;\r
7674   else if (strstr (mode, "logid"))m=5;\r
7675   else m=0;\r
7676   \r
7677   \r
7678 \r
7679   for (n=0,a=0; a<ns[0]; a++)\r
7680     {\r
7681       s1=ls[0][a];\r
7682       for ( b=0; b<ns[1]; b++, n++)\r
7683         {\r
7684           s2=ls[1][b];\r
7685           gap=pos0=pos1=pos2=len=sim=0;\r
7686           \r
7687           for ( c=0; c< A->len_aln; c++)\r
7688             {\r
7689               r1=tolower (A->seq_al[s1][c]);\r
7690               r2=tolower (A->seq_al[s2][c]);\r
7691               p1=(r1!='-')?1:0;\r
7692               p2=(r2!='-')?1:0;\r
7693               p3=p1+p2;\r
7694               if ( p3==0)continue;\r
7695               if ( p3==1)gap++;\r
7696               if ( r1==r2)sim++;\r
7697               pos1+=p1;\r
7698               pos2+=p2;\r
7699               pos0+=(p3==2)?1:0;\r
7700               len++;\r
7701             }\r
7702 \r
7703           if (m==0)s=(pos0==0)?0:(sim*MAXID)/pos0; //sim1\r
7704           else if (m==1)  s=(MIN(pos1,pos2)==0)?0:(sim*MAXID)/MIN(pos1,pos2);//sim2\r
7705           else if (m==2)  s=(MAX(pos1,pos2)==0)?0:(sim*MAXID)/MAX(pos1,pos2);//sim3\r
7706           else if (m==3)  s=(len==0) ?0:((len-gap)*MAXID)/len;//gap1\r
7707           else if (m==4)  s=(len==0) ?0:((pos0)*MAXID)/len; //cov\r
7708           else if (m==5)   \r
7709             {\r
7710               s=logid_score ( sim, len);\r
7711             }\r
7712           simm[n][0]=s1;\r
7713           simm[n][1]=s2;\r
7714           simm[n][2]=s;\r
7715         }\r
7716     }\r
7717 \r
7718   if ( free_ns) {vfree(ns); free_int (ls, -1);}\r
7719   simm[n][0]=-1;\r
7720   return simm;\r
7721 }\r
7722 \r
7723 int ** fast_aln2sim_mat (Alignment *A,  char *mode)\r
7724 {\r
7725   int **simm;\r
7726   int p1, p2, p3, r1, r2;\r
7727   int gap,pos0,pos1,pos2,len,sim;\r
7728   int a, b, c, m;\r
7729   \r
7730   simm=declare_int (A->nseq, A->nseq);\r
7731 \r
7732 \r
7733   \r
7734   if (strstr (mode, "sim1"))m=0;\r
7735   else if (strstr (mode, "sim2"))m=1;\r
7736   else if (strstr (mode, "sim3"))m=2;\r
7737   else if (strstr (mode, "gap1"))m=3;\r
7738   else if (strstr (mode, "cov1"))m=4;\r
7739   else if (strstr (mode, "logid"))m=5;\r
7740   else m=0;\r
7741   \r
7742   \r
7743   \r
7744   for ( a=0; a< A->nseq-1; a++)\r
7745     {\r
7746       simm[a][a]=MAXID;\r
7747       for ( b=a+1; b< A->nseq; b++)\r
7748         {\r
7749           gap=pos0=pos1=pos2=len=sim=0;\r
7750           \r
7751           for ( c=0; c< A->len_aln; c++)\r
7752             {\r
7753               r1=tolower (A->seq_al[a][c]);\r
7754               r2=tolower (A->seq_al[b][c]);\r
7755               p1=(r1!='-')?1:0;\r
7756               p2=(r2!='-')?1:0;\r
7757               p3=p1+p2;\r
7758               if ( p3==0)continue;\r
7759               if ( p3==1)gap++;\r
7760               if ( r1==r2)sim++;\r
7761               pos1+=p1;\r
7762               pos2+=p2;\r
7763               pos0+=(p3==2)?1:0;\r
7764               len++;\r
7765             }\r
7766 \r
7767           if (m==0)simm[a][b]=simm[b][a]=(pos0==0)?0:(sim*MAXID)/pos0; //sim1\r
7768           else if (m==1)  simm[a][b]=simm[b][a]=(MIN(pos1,pos2)==0)?0:(sim*MAXID)/MIN(pos1,pos2);//sim2\r
7769           else if (m==2)   simm[a][b]=simm[b][a]=(MAX(pos1,pos2)==0)?0:(sim*MAXID)/MAX(pos1,pos2);//sim3\r
7770           else if (m==3)   simm[a][b]=simm[b][a]=(len==0) ?0:((len-gap)*MAXID)/len;//gap1\r
7771           else if (m==4)   simm[a][b]=simm[b][a]=(len==0) ?0:((pos0)*MAXID)/len; //cov\r
7772           else if (m==5)   \r
7773             {\r
7774               \r
7775               //Inspired from Muscle +mafft 5\r
7776               simm[a][b]=simm[b][a]=logid_score ( sim, len);\r
7777             }\r
7778         }\r
7779     }\r
7780   return simm;\r
7781 }\r
7782 int logid_score ( int sim, int len)\r
7783 {\r
7784   float score;\r
7785   \r
7786   if ( len==0)return (int)(0.33*(float)MAXID);\r
7787   \r
7788   score=(float)sim/(float)len;\r
7789   if (score>0.9) score=1.0;\r
7790   else score=-log10 (1.0-score);\r
7791   \r
7792   score=(score*MAXID);\r
7793   return score;\r
7794 }\r
7795 int ** aln2sim_mat (Alignment *A, char*mode)\r
7796 {\r
7797  \r
7798  \r
7799   if ( strstr (mode, "idmat"))return fast_aln2sim_mat(A, mode);\r
7800   return get_sim_aln_array(A, mode);\r
7801 }\r
7802 int ** aln2cov (Alignment *A)\r
7803 {\r
7804   int a, b, c;\r
7805   int r1, r2, gr1, gr2, pos0, gap;\r
7806   int **cov;\r
7807   cov=declare_int (A->nseq, A->nseq);\r
7808   \r
7809   for (a=0; a< A->nseq-1; a++)\r
7810     {\r
7811       cov[a][a]=100;\r
7812       for ( b=a+1; b<A->nseq; b++)\r
7813         {\r
7814           for (gap=0,pos0=0,c=0;c<A->len_aln; c++)\r
7815             {\r
7816               r1=A->seq_al[a][c];\r
7817               r2=A->seq_al[b][c];\r
7818               gr1=is_gap(r1); gr2=is_gap(r2);\r
7819               if ( gr1+gr2==0)pos0++;\r
7820               else if ( gr1+gr2<2)gap++;\r
7821             }\r
7822           cov[a][b]=cov[b][a]=((gap+pos0)==0)?0:((pos0*100)/(gap+pos0));\r
7823         }\r
7824     }\r
7825   return cov;\r
7826 }\r
7827 int ** get_raw_sim_aln_array (Alignment *A, char *mode)\r
7828 {\r
7829   int **w;\r
7830   int **M;\r
7831   int a, b, c, r1, r2, set, max, min;\r
7832   \r
7833   w=declare_int (A->nseq, A->nseq);\r
7834   if (strstr(mode, "sar"))M=NULL;\r
7835   else M=read_matrice (mode);\r
7836   \r
7837   HERE ("RAW STUFF");\r
7838   \r
7839   for ( set=0,a=0; a< A->nseq; a++)\r
7840     for (b=a; b<A->nseq; b++)\r
7841       {\r
7842         if (M)\r
7843           {\r
7844             for (c=0; c<A->len_aln; c++)\r
7845               {\r
7846                 r1=A->seq_al[a][c];\r
7847                 r2=A->seq_al[b][c];\r
7848                 \r
7849                 if ( !is_gap(r1) && !is_gap(r2))\r
7850                   w[a][b]+=M[r1-'A'][r2-'A'];\r
7851               }\r
7852           }\r
7853         else if ( strm (mode, "sarmat2"))\r
7854           {\r
7855             w[a][b]=get_sar_sim2 (A->seq_al[a], A->seq_al[b]);\r
7856           }\r
7857         else\r
7858           {\r
7859             HERE ("ERROR: %s is an unknown mode of raw_sim\n", mode); exit (0);\r
7860           }\r
7861         \r
7862         w[b][a]=w[a][b];\r
7863         if (!set){min=max=w[a][b];set=1;}\r
7864         min=MIN(min,w[a][b]);\r
7865         max=MAX(max,w[a][b]);\r
7866       }\r
7867   for (a=0; a<A->nseq; a++)\r
7868     for (b=a; b<A->nseq; b++)\r
7869       {\r
7870         w[b][a]=((max-min)==0)?0:((w[b][a]-min)*100)/(max-min);\r
7871         w[a][b]=w[b][a];\r
7872       }\r
7873   free_int (M, -1);\r
7874   return w;\r
7875 }\r
7876 int ** get_sim_aln_array ( Alignment *A, char *mode)\r
7877         {\r
7878         int **w;\r
7879         int a, b;\r
7880         \r
7881 \r
7882         w=declare_int ( A->nseq, A->nseq);\r
7883         \r
7884         for ( a=0; a< A->nseq-1; a++)\r
7885           {\r
7886             for ( b=a+1; b< A->nseq; b++)\r
7887               {\r
7888 \r
7889                 w[a][b]=w[b][a]=generic_get_seq_sim ( A->seq_al[a], A->seq_al[b], (A->cdna_cache)?A->cdna_cache[0]:NULL, mode);\r
7890               }\r
7891           }\r
7892         return w;\r
7893         }\r
7894 int generic_get_seq_sim ( char *seq1, char *seq2, int*cache, char *mode)\r
7895 {\r
7896 \r
7897   \r
7898    if ( strm (mode, "cdna"))\r
7899      return get_cdna_seq_sim ( cache, seq1, seq2,GAP_LIST, mode);                       \r
7900    else if ( strnm (mode, "ktup",4))\r
7901      return ktup_comparison (seq1, seq2,atoi(mode+4));\r
7902    else if ( strstr (mode, "sarmat2"))\r
7903      {\r
7904        \r
7905        return get_sar_sim2 (seq1, seq2);\r
7906      }\r
7907    else if ( strstr (mode, "sarmat"))\r
7908      return (int) get_sar_sim (seq1,seq2);\r
7909    else\r
7910      {\r
7911        return get_seq_sim ( seq1,seq2,GAP_LIST, mode);\r
7912      }\r
7913 }\r
7914 int *** get_winsim_aln_array ( Alignment *A,char *mode, int ***w)\r
7915         {\r
7916         int a, b;\r
7917         for ( a=0; a< A->nseq; a++)\r
7918                 for ( b=0; b< A->nseq; b++)\r
7919                         {\r
7920                           if ( strm (mode, "cdna"))\r
7921                             w[a][b]=get_cdna_seq_winsim ( A->cdna_cache[0], A->seq_al[a], A->seq_al[b],GAP_LIST, mode, w[a][b]);                        \r
7922                           else\r
7923                             w[a][b]=get_seq_winsim ( A->seq_al[a], A->seq_al[b],GAP_LIST, mode, w[a][b]);\r
7924                         }\r
7925         return w;\r
7926         }\r
7927 \r
7928 Alignment * seq2profile (Sequence *S, int i)\r
7929 {\r
7930   Alignment *A;\r
7931   \r
7932   if ((A=seq2R_template_profile (S, i)))\r
7933     {\r
7934       return A;\r
7935     }\r
7936   else\r
7937     {\r
7938       char *tmp;\r
7939       FILE *fp;\r
7940       tmp=vtmpnam (NULL);\r
7941       fp=vfopen ( tmp, "w");\r
7942       fprintf (fp, ">%s\n%s\n", S->name[i], S->seq[i]);\r
7943       vfclose (fp);\r
7944       \r
7945       (S->T[i])->R=fill_R_template (S->name[i], tmp, S);\r
7946       \r
7947       return  seq2R_template_profile (S, i);\r
7948     }\r
7949 }\r
7950 \r
7951 Alignment* aln2sub_aln_file (Alignment *A, int n, char **string)\r
7952 {\r
7953   char ***list;\r
7954   int a;\r
7955 \r
7956   list=vcalloc (A->nseq, sizeof (char***));\r
7957   if ( n==0)return A;\r
7958   else if (n>1)\r
7959     {\r
7960       int l;\r
7961       char *buf;\r
7962       \r
7963       for (l=0,a=0; a< n; a++)l+=strlen (string[a]);\r
7964       buf=vcalloc ( 2*n+l+1, sizeof (char));\r
7965       for (a=0; a< n; a++){buf=strcat (buf,string[a]), buf=strcat ( buf, " ");}     \r
7966       list[0]=string2list (buf);\r
7967       vfree (buf);\r
7968     }\r
7969   else if ( file_exists (NULL,string[0]))\r
7970     {\r
7971       list=read_group (string[0]);\r
7972 \r
7973     }\r
7974   else\r
7975     {\r
7976       fprintf (stderr, "\nERROR: file <%s> does not exist [FATAL:%s]\n",string[0], PROGRAM);\r
7977       myexit (EXIT_FAILURE);\r
7978     }  \r
7979 \r
7980   \r
7981   a=0;\r
7982   while (list[a])\r
7983     {\r
7984       int i, b;\r
7985       FILE *fp;\r
7986       n=atoi (list[a][0]);\r
7987       fp=vfopen (list[a][1], "w");\r
7988       for (b=2; b<n; b++)\r
7989         {\r
7990           i=name_is_in_list (list[a][b], A->name, A->nseq, MAXNAMES);\r
7991           if (n==3)ungap (A->seq_al[i]);\r
7992           fprintf (fp, ">%s\n%s\n", A->name[i], A->seq_al[i]);    \r
7993         }\r
7994       vfclose (fp);\r
7995       free_char (list[a], -1);\r
7996       a++;\r
7997     }\r
7998   vfree(list);\r
7999   return A;\r
8000 }\r
8001 Sequence *remove_empty_sequence (Sequence *S)\r
8002 {\r
8003   int a, b;\r
8004   char *c;\r
8005   Sequence *NS;\r
8006   \r
8007   c=vcalloc ( S->max_len+1, sizeof (char));\r
8008   \r
8009   for (a=0, b=0; a< S->nseq; a++)\r
8010     {\r
8011       sprintf ( c, "%s",S->seq[a]);\r
8012       ungap (c);\r
8013       if ( strlen (c)==0)\r
8014         {\r
8015           //vfree (S->seq[a]);\r
8016           S->seq[a]=NULL;\r
8017           add_warning ( stderr, "WARNING: Sequence %s does not contain any residue: automatically removed from the set [WARNING:%s]",S->name[a], PROGRAM);\r
8018         }\r
8019     }\r
8020   NS=duplicate_sequence (S);\r
8021   free_sequence (S, S->nseq);\r
8022   vfree (c);\r
8023   return NS;\r
8024 }\r
8025 Alignment* aln2sub_seq (Alignment *A, int n, char **string)\r
8026 {\r
8027   char ***list;\r
8028   int a;\r
8029   Sequence *S=NULL;\r
8030     \r
8031   list=vcalloc (A->nseq, sizeof (char***));\r
8032   if ( n==0)return A;\r
8033   else if (n>1)\r
8034     {\r
8035       int l;\r
8036       char *buf;\r
8037       \r
8038       for (l=0,a=0; a< n; a++)l+=strlen (string[a]);\r
8039       buf=vcalloc ( 2*n+l+1, sizeof (char));\r
8040       for (a=0; a< n; a++){buf=strcat (buf,string[a]), buf=strcat ( buf, " ");}     \r
8041       list[0]=string2list (buf);\r
8042       vfree (buf);\r
8043     }\r
8044   else if ( file_exists (NULL,string[0]))\r
8045     {\r
8046       list=read_group (string[0]);\r
8047 \r
8048     }\r
8049   else\r
8050     {\r
8051       fprintf (stderr, "\nERROR: file <%s> does not exist [FATAL:%s]\n",string[0], PROGRAM);\r
8052       myexit (EXIT_FAILURE);\r
8053     }  \r
8054 \r
8055  \r
8056   \r
8057   a=0;\r
8058   while (list[a])\r
8059     {\r
8060       int t;\r
8061       Alignment *B;\r
8062       Sequence *subS;\r
8063       \r
8064       \r
8065       B=main_read_aln (list[a][1], NULL);\r
8066       t=aln2most_similar_sequence(B, "idmat");\r
8067       subS=extract_one_seq(B->name[t],0,0,B,KEEP_NAME);\r
8068       S=add_sequence (subS,S,0);\r
8069       free_aln (B);free_sequence (subS, -1);\r
8070       vremove (list[a][1]);\r
8071       a++;\r
8072     }\r
8073   vfree(list);\r
8074   return seq2aln (S, NULL, RM_GAP);\r
8075 }\r
8076 \r
8077 Alignment * aln2collapsed_aln (Alignment * A, int n, char **string)\r
8078 {\r
8079   Alignment *B;\r
8080   char ***list;\r
8081   char **list2;\r
8082   char *buf=NULL;\r
8083   FILE *fp;\r
8084   int a, b,c, ns, m, l;\r
8085   int *collapsed;\r
8086   \r
8087   list=vcalloc (A->nseq, sizeof (char***));\r
8088   ns=0;\r
8089   if ( n==0)return A;\r
8090   else if (n>1)\r
8091     {\r
8092       for (l=0,a=0; a< n; a++)l+=strlen (string[a]);\r
8093       buf=vcalloc ( 2*n+l+1, sizeof (char));\r
8094       for (a=0; a< n; a++){buf=strcat (buf,string[a]), buf=strcat ( buf, " ");}\r
8095      \r
8096       list[0]=string2list (buf);ns=1;\r
8097       \r
8098     }\r
8099   else if ( file_exists (NULL,string[0]))\r
8100     {\r
8101       /*Format: Fasta like, the name fo the group followed with the name of the sequences\r
8102         ><Group name> <First Seq> <second seq> ....\r
8103         Groups must NOT be overlaping\r
8104       */\r
8105       l=measure_longest_line_in_file (string[0])+1; \r
8106       buf=vcalloc (l, sizeof (char));\r
8107       ns=0;\r
8108       fp=vfopen (string[0], "r");\r
8109       while ((c=fgetc(fp))!=EOF)\r
8110         {\r
8111           buf=fgets (buf,l-1, fp);\r
8112           if ( c=='>')list[ns++]=string2list (buf);\r
8113         }\r
8114       vfclose (fp);\r
8115     }\r
8116   else\r
8117     {\r
8118       fprintf (stderr, "\nERROR: file <%s> does not exist [FATAL:%s]\n",string[0], PROGRAM);\r
8119       myexit (EXIT_FAILURE);\r
8120     }\r
8121   \r
8122   vfree (buf); buf=NULL;\r
8123 \r
8124   /*Identify lost sequences*/\r
8125   collapsed=vcalloc (A->nseq, sizeof (int));\r
8126   for ( a=0; a< ns; a++)\r
8127       {\r
8128         m=atoi (list[a][0]); \r
8129         for (b=2; b<m ; b++)\r
8130           {\r
8131             c=name_is_in_list (list[a][b], A->name, A->nseq, MAXNAMES);\r
8132             if ( c>=0)collapsed[c]=1;\r
8133           }\r
8134       }\r
8135   for ( a=0; a< A->nseq; a++)\r
8136     {\r
8137       if ( collapsed[a]==0)\r
8138         {\r
8139           list[ns]=declare_char (3, MAXNAMES);\r
8140           sprintf ( list[ns][0], "3");\r
8141           sprintf ( list[ns][1], "%s", A->name[a]);\r
8142           sprintf ( list[ns][2], "%s", A->name[a]);\r
8143           ns++;\r
8144         }\r
8145     }\r
8146   vfree (collapsed);\r
8147   \r
8148   \r
8149   \r
8150 \r
8151 \r
8152   list2=declare_char (A->nseq, 100);\r
8153   /*1 Collapse the alignment*/\r
8154   for ( a=0; a< ns; a++)\r
8155     {\r
8156       sprintf ( list2[a], "%s", list[a][2]);\r
8157     }\r
8158    B=extract_sub_aln2 ( A, ns, list2);\r
8159   /*2 Rename the sequences*/\r
8160   for ( a=0; a< ns; a++)\r
8161     {\r
8162       sprintf ( B->name[a], "%s", list[a][1]);\r
8163     }\r
8164   /*replace sequence with consensus*/\r
8165   \r
8166   for ( a=0; a< ns; a++)\r
8167     {\r
8168       m=atoi (list[a][0]);\r
8169       for (c=0, b=2; b<m;c++, b++)\r
8170         {\r
8171           sprintf ( list2[c], "%s", list[a][b]);\r
8172         }\r
8173       buf=sub_aln2cons_seq_mat2 ( A,m-2,list2, "blosum62mt");\r
8174       sprintf (B->seq_al[a], "%s", buf);     \r
8175     }\r
8176   vfree (buf);\r
8177 \r
8178   free_aln (A);\r
8179   B->S=aln2seq(B);\r
8180   return B;\r
8181 }\r
8182 Alignment * aln2profile (Alignment * A)\r
8183     {\r
8184       Alignment *B=NULL;\r
8185       char *cons;\r
8186       \r
8187       if (!A->P)\r
8188         {\r
8189           A->P=declare_profile (AA_ALPHABET,A->len_aln+1);\r
8190         }\r
8191       B=copy_aln (A, B);\r
8192       free_int ((A->P)->count, -1);\r
8193       free_int ((A->P)->count2, -1);\r
8194       free_int ((A->P)->count3, -1);\r
8195       (A->P)->count=aln2count_mat (A);\r
8196       (A->P)->count2=aln2count_mat2 (A);\r
8197       \r
8198       cons=aln2cons_seq_mat (A, "blosum62mt");\r
8199       \r
8200       sprintf (B->seq_al[0], "%s", cons);\r
8201       B->nseq=1;\r
8202       (A->P)->count3=aln2count_mat2 (B);\r
8203       vfree (cons);\r
8204       free_aln (B);\r
8205       \r
8206       \r
8207 \r
8208       return A;\r
8209           \r
8210     }\r
8211 \r
8212 int** aln2count_mat2 ( Alignment *A)\r
8213 {\r
8214   return sub_aln2count_mat2 (A, 0, NULL);\r
8215 }\r
8216 \r
8217 int sub_aln2nseq_prf ( Alignment *A, int ns, int *ls)\r
8218 {\r
8219   \r
8220   \r
8221   int a, c, s;\r
8222   Alignment *R;\r
8223   int n;\r
8224   int free_ls=0;\r
8225   \r
8226   \r
8227   if ( ns==0)\r
8228     {\r
8229       n=ns=A->nseq;\r
8230       ls=vcalloc (n, sizeof (int));\r
8231       for ( a=0; a<A->nseq; a++)ls[a]=a;\r
8232       free_ls=1;\r
8233     }\r
8234   else\r
8235     {\r
8236       n=ns;\r
8237     }\r
8238 \r
8239   for (c=0,a=0; a<ns; a++)\r
8240     {\r
8241       s=ls[a];\r
8242       if ( A->S && (R=seq2R_template_profile (A->S, A->order[s][0]))!=NULL)\r
8243         {\r
8244           n+=R->nseq;\r
8245         }\r
8246       else\r
8247         {\r
8248           ;\r
8249         }\r
8250     }\r
8251   \r
8252   if ( free_ls) vfree (ls);\r
8253   return n;\r
8254 }\r
8255 \r
8256 int** sub_aln2count_mat2 ( Alignment *A, int ns, int *ls)\r
8257 {\r
8258   char **p;\r
8259   int **count;\r
8260   int a, b, c, s;\r
8261   Alignment *R;\r
8262   int n;\r
8263   int free_ls=0;\r
8264   \r
8265   if ( ns==0)\r
8266     {\r
8267       n=ns=A->nseq;\r
8268       p=vcalloc ( n, sizeof (char*));\r
8269       ls=vcalloc (n, sizeof (int));\r
8270       for ( a=0; a<A->nseq; a++)ls[a]=a;\r
8271       free_ls=1;\r
8272     }\r
8273   else\r
8274     {\r
8275       n=ns;\r
8276       p=vcalloc (n, sizeof (char*));\r
8277     }\r
8278 \r
8279   for (c=0,a=0; a<ns; a++)\r
8280     {\r
8281       s=ls[a];\r
8282       if ( A->S && (R=seq2R_template_profile (A->S, A->order[s][0]))!=NULL)\r
8283         {\r
8284           n+=R->nseq;\r
8285           p=vrealloc (p, n*sizeof (char*));\r
8286           for (b=0; b<R->nseq; b++)\r
8287             {\r
8288               p[c++]=R->seq_al[b];\r
8289             }\r
8290         }\r
8291       else\r
8292         {\r
8293           int w;\r
8294           w=A->order[s][4]+1;\r
8295           \r
8296           for (b=0; b<w; b++)\r
8297             p[c++]=A->seq_al[s];\r
8298         }\r
8299     }\r
8300   count=sub_aln2count_mat3 (p,c);\r
8301   vfree (p);\r
8302   if ( free_ls) vfree (ls);\r
8303   return count;\r
8304 }\r
8305 int** sub_aln2count_mat3 (char **al, int ns)\r
8306 {\r
8307   int **count;\r
8308   int used[1000];\r
8309   int a, b;\r
8310   int r;\r
8311   \r
8312   int len;\r
8313   int us;\r
8314   \r
8315   \r
8316   /*count[x][0]=n symbols in column\r
8317     count[x][1]=total_size of line\r
8318     count[x][2]=Gap frequency\r
8319      \r
8320     count[x][n]=symbol n\r
8321     count[x][n+1]=N occurence symbol n;\r
8322     count[x][n+2]=N frequence symbol n*100;\r
8323  \r
8324     special multi-channeling\r
8325     count[x][count[x][1]]=Nseq\r
8326     count[x][count[x][1]+s]=residue col x, sequence s\r
8327   */\r
8328 \r
8329 \r
8330   for (a=0; a< 1000; a++)used[a]=0;\r
8331   len=strlen (al[0]);\r
8332   \r
8333   count=declare_int (len+2,100+ns+2);\r
8334   count[len][0]=END_ARRAY;\r
8335   count[len][1]=ns;\r
8336   count[len][2]=len;\r
8337   \r
8338 \r
8339   \r
8340   for (a=0; a<len; a++)\r
8341     {\r
8342       for (us=ns, b=0; b<ns; b++)\r
8343         {\r
8344           r=tolower (al[b][a]);\r
8345           \r
8346           if (is_gap(r))us--;\r
8347           else if (used[r])\r
8348             {\r
8349               count[a][used[r]*3+1]++;\r
8350             }\r
8351           else\r
8352             {\r
8353               used[r]=++count[a][0];\r
8354               count[a][used[r]*3]=r;\r
8355               count[a][used[r]*3+1]++;\r
8356             }\r
8357         }\r
8358       count[a][1]=count[a][0]*3+2;\r
8359       /*count[a][2]=(A->nseq-us)*100/A->nseq;*/\r
8360       count[a][2]=ns-us;\r
8361       \r
8362       for (b=3; b<count[a][1]; b+=3)\r
8363         {\r
8364           count[a][b+2]=(count[a][b+1]*100)/us;\r
8365           used[count[a][b]]=0;\r
8366         }\r
8367 \r
8368      \r
8369       /*Option for multi channeling*/\r
8370       \r
8371       /*\r
8372       count[a][count[a][1]]=A->nseq;\r
8373       for (b=1; b<=A->nseq; b++)\r
8374         count [a][count[a][1]+b]=(is_gap(A->seq_al[b-1][a]))?0:A->seq_al[b-1][a];\r
8375       */\r
8376     }\r
8377 #ifdef XXXXXX\r
8378   HERE ("Display ");\r
8379   for (a=0; a< 5; a++)\r
8380     {\r
8381       fprintf ( stderr, "\n");\r
8382       for ( b=3; b< count[a][1]; b+=3)\r
8383         {\r
8384           fprintf ( stderr, "[%c %d]", count[a][b], count[a][b+1]);\r
8385         }\r
8386       fprintf ( stderr, "\n");\r
8387       for ( b=0; b<ns; b++)\r
8388         {\r
8389           fprintf ( stderr, "%c", al[b][a]);\r
8390         }\r
8391     }\r
8392   HERE ("End of Display");\r
8393 #endif\r
8394   return count;\r
8395 }\r
8396           \r
8397 int** aln2count_mat ( Alignment *A)\r
8398     { /*\r
8399         function documentation: start\r
8400         \r
8401         int output_freq_mat ( char *outfile, Aligmnent *A)\r
8402 \r
8403         This function counts the number of residues in each column of an alignment (Prot/NA)\r
8404         It outputs these values in the following format\r
8405 \r
8406         This format can be piped into:\r
8407         The routine used for computing the p-value  gmat-inf-gc-v2c\r
8408         \r
8409         function documentation: end\r
8410       */\r
8411       \r
8412     int a, b,x;\r
8413     int **freq_mat;\r
8414     int alp_size;\r
8415 \r
8416     alp_size=sizeof (AA_ALPHABET); \r
8417     freq_mat=declare_int (alp_size+2, A->len_aln);\r
8418       \r
8419 \r
8420     for ( a=0; a<A->len_aln; a++)\r
8421       {\r
8422         for ( b=0; b< A->nseq; b++)\r
8423           {\r
8424             if ( is_gap ( A->seq_al[b][a]))freq_mat[alp_size][a]++;\r
8425             else\r
8426               {\r
8427                 x=tolower(A->seq_al[b][a]);\r
8428                 freq_mat[x-'a'][a]++;\r
8429                 freq_mat[alp_size+1][a]++;\r
8430                 \r
8431               }\r
8432           }\r
8433       }\r
8434     \r
8435     return freq_mat;\r
8436     }\r
8437 char *aln2random_seq (Alignment *A, int pn1, int pn2, int pn3, int gn)\r
8438     {\r
8439 \r
8440       /* \r
8441 \r
8442          \r
8443          Given the frequencies in A ( read as total counts of each Residue in\r
8444          freq[A->nseq][A->len_aln], and pn1, pn2 and pn3:\r
8445           \r
8446                           1-Generate a new amino-acid at each position\r
8447                           2-Insert Gaps, using a HMM.\r
8448 \r
8449          \r
8450          pn3=Weight of the noise induced with sub mat.\r
8451 \r
8452          pn1=% noise type 1 ( Varies with entropi)\r
8453           n1=Ratio noise type 1\r
8454           \r
8455          T =Nseq \r
8456          t1=Noise 1 expressed in Nseq\r
8457          al=alphabet size;\r
8458          ncat=number of non 0 cat for a given position\r
8459          ICi initial count for residue i\r
8460 \r
8461          Ci=freq[seq][AA]\r
8462          t1=T*n1*(1-1/ncat);\r
8463          t2=T*n2;\r
8464          \r
8465          Ci= ICi*(T-(t1+t2))/T +(t1)/al+(t2)/al\r
8466          \r
8467       */\r
8468       \r
8469       int **freq;\r
8470       int **count;\r
8471       float T, tot_t1, tot_t2,tot_t3, n1, n2, n3;\r
8472       float ncat;\r
8473       \r
8474       double gf;\r
8475       double *init_freq;\r
8476       double *blur_freq;\r
8477       double *t1, *t2,*t3;\r
8478       int a, b, c, x;\r
8479       char *seq;\r
8480       int tot;\r
8481       /*Viterbi  Parameters */\r
8482       \r
8483       int p;\r
8484       int AL=0;        /*Allowed Transition*/\r
8485       int F=-100000; /*Forbiden Transition*/\r
8486 \r
8487       int GAP_TRANSITION;\r
8488       int IGAP=0, IAA=1;\r
8489       \r
8490       int state,best_state=0, score, best_score=0;\r
8491       int p_state;\r
8492       int e=0;\r
8493       int **score_tab;\r
8494       int **state_tab;\r
8495       int nstate=2;\r
8496       int **transitions;\r
8497       \r
8498       int max;\r
8499 \r
8500       seq=vcalloc ( A->len_aln+1, sizeof (char));     \r
8501       count=aln2count_mat(A);\r
8502       freq=aln2count_mat(A);\r
8503 \r
8504       T=100;\r
8505 \r
8506       n1=(float)pn1/100;\r
8507       n2=(float)pn2/100;\r
8508       n3=(float)pn3/100;\r
8509       \r
8510       for ( a=0; a< A->len_aln; a++)\r
8511         {\r
8512           for ( b=0; b<26; b++)\r
8513             freq[b][a]=freq[b][a]*((T)/(A->nseq-freq[26][a]));\r
8514           freq[26][a]= (freq[26][a]*T)/A->nseq;\r
8515         }\r
8516 \r
8517       \r
8518       init_freq=vcalloc ( 26, sizeof (double));\r
8519       blur_freq=vcalloc ( 26, sizeof (double));\r
8520       \r
8521       tot_t1=tot_t2=tot_t3=0;\r
8522       \r
8523       t1=vcalloc ( 27, sizeof (double));\r
8524       t2=vcalloc ( 27, sizeof (double));\r
8525       t3=vcalloc ( 27, sizeof (double));\r
8526       for (a=0; a< A->len_aln; a++)\r
8527         {\r
8528 \r
8529         /*Compute Frequencies*/\r
8530           for (tot=0, b=0; b<26; b++)\r
8531                 {\r
8532                   if ( is_aa(b+'A'))\r
8533                     {\r
8534                       init_freq[b]=freq[b][a];\r
8535                       tot+=freq[b][a];\r
8536                     }\r
8537                 }\r
8538         /*Count the number of  different amino acids*/\r
8539         for ( ncat=0, b=0; b<=26; b++)\r
8540           {\r
8541             ncat+=(freq[b][a]!=0)?1:0;      \r
8542           }\r
8543         /*Blurr the distribution using */\r
8544         blur_freq=compute_matrix_p (init_freq,tot);     \r
8545                 \r
8546         \r
8547         /*compute noise 1: biased with blurred content * enthropy--> keeps prosite motifs*/\r
8548         tot_t1=T*n1*(1-1/ncat);\r
8549         for (  b=0; b< 26; b++)if ( is_aa(b+'A')){t1[b]=blur_freq[b]*(1-1/ncat)*n1;}\r
8550         \r
8551         /*Compute noise 2: completely random*/\r
8552         tot_t2=T*n2;\r
8553         for (  b=0; b< 26; b++)if ( is_aa(b+'A')){t2[b]=tot_t2/21;}\r
8554         \r
8555         /*compute noise 3: biased with the sole content(pam250mt)*/\r
8556         tot_t3=T*n3;\r
8557         for (  b=0; b<26; b++)if ( is_aa(b+'A')){t3[b]=blur_freq[b]*n3;}\r
8558         \r
8559         for ( b=0; b<26; b++)\r
8560           {\r
8561             if ( is_aa('A'+b))\r
8562               freq[b][a]=freq[b][a]*(T-(tot_t1+tot_t2+(tot_t3)))/T+t1[b]+t2[b]+t3[b];\r
8563           }\r
8564         \r
8565         /*end of the loop that mutates position a*/\r
8566         }\r
8567      \r
8568         vfree (blur_freq);\r
8569         vfree (init_freq);\r
8570         vfree ( t3);\r
8571         \r
8572       /*1-Generate the amino acids of the new sequence new*/\r
8573       \r
8574       \r
8575       vsrand (0);\r
8576       \r
8577       for ( a=0; a< A->len_aln; a++)\r
8578         {\r
8579 \r
8580           for (T=0,b=0; b<26; b++)T+=freq[b][a];\r
8581           x=rand ()%((int)T);\r
8582           for (c=0,b=0; b<26; b++)\r
8583             {\r
8584              c+=freq[b][a];\r
8585              if ( c>=x)\r
8586                {\r
8587                  seq[a]='A'+b;\r
8588                  c=-1;\r
8589                  break;\r
8590                }\r
8591             }\r
8592           if ( c!=-1)seq[a]='-';\r
8593         }\r
8594       seq[a]='\0';\r
8595       \r
8596 \r
8597       /*2 Generate the gaps in the new sequence*/\r
8598       \r
8599       \r
8600 \r
8601       if ( gn<0);\r
8602       else\r
8603         {\r
8604 \r
8605           transitions=declare_int ( nstate, nstate);\r
8606           score_tab=declare_int ( A->len_aln+2, nstate       );\r
8607           state_tab=declare_int ( A->len_aln+2, nstate       );\r
8608           \r
8609           \r
8610           \r
8611           for (a=0; a<nstate;a++)\r
8612             for (b=0; b<nstate;b++)\r
8613               {transitions[a][b]=F;}\r
8614           \r
8615           GAP_TRANSITION=AL-gn;\r
8616 \r
8617           transitions[IGAP ][IGAP ]=AL;\r
8618           transitions[IAA][IAA]=AL;\r
8619           transitions[IAA ][IGAP]=GAP_TRANSITION;\r
8620           transitions[IGAP][IAA ]=GAP_TRANSITION;\r
8621           \r
8622           \r
8623           for ( p=1; p<=A->len_aln; p++){for (state=0; state< nstate; state++){score_tab[p][state]=F;state_tab[p][state]=-1;} }\r
8624           \r
8625           for (p=1; p<= A->len_aln; p++)\r
8626             {\r
8627               for (max=0,a=0; a<26; a++)max=MAX(max, freq[a][p-1]);\r
8628               max=(max*(A->nseq-count[26][p-1]))/A->nseq;\r
8629               \r
8630               for (state=0; state< nstate; state++)\r
8631                 {\r
8632                   \r
8633                   \r
8634                   gf=freq[26][p-1];\r
8635                   if      ( state==IGAP)  e=gf-50;\r
8636                   else if ( state==IAA )  e=max-50;\r
8637                   for (p_state=0; p_state<nstate; p_state++)\r
8638                     {\r
8639                       score=(score_tab[p-1][p_state]==F)?F:(e+transitions[p_state][state]+score_tab[p-1][p_state]);\r
8640                       if(p_state==0 || score>best_score){ best_score=score;best_state=p_state;}\r
8641                     }\r
8642                   score_tab[p][state]=best_score;\r
8643                   state_tab[p][state]=best_state;\r
8644                 }\r
8645             }\r
8646           \r
8647           for (state=0; state<nstate; state++)\r
8648             {\r
8649               if (state==0 || score_tab[p-1][state]>best_score){best_score=score_tab[p-1][state]; best_state=state;}\r
8650             }\r
8651           \r
8652           for (p=A->len_aln; p>0;)\r
8653             {\r
8654               if ( best_state==IGAP)\r
8655                 {\r
8656                   seq[p-1]='-';\r
8657                 }\r
8658               else if ( best_state==IAA)\r
8659                 {\r
8660                   seq[p-1]=seq[p-1];\r
8661                 }\r
8662               best_state=state_tab[p][best_state];\r
8663               p--;\r
8664             }\r
8665         }\r
8666       \r
8667       free_int (freq, -1);\r
8668       return seq;\r
8669     }\r
8670 \r
8671 /********************************************************************/\r
8672 /*                                                                  */\r
8673 /*                      Weighting functions                         */\r
8674 /*                                                                  */\r
8675 /*                                                                  */\r
8676 /*                                                                  */\r
8677 /********************************************************************/\r
8678 Alignment * master_trimseq( Alignment *A, Sequence *S,char *mode)\r
8679      {\r
8680        Alignment *NA;\r
8681        char *p;\r
8682        int a, b;\r
8683        int use_aln=0, upper_sim=0, min_nseq=0, lower_sim=0;\r
8684        float f_upper_sim, f_lower_sim;\r
8685        char weight_mode[1000];\r
8686        char method[1000];\r
8687        int statistics=0;\r
8688        int trim_direction=TOP;\r
8689        float **sim_weight;\r
8690        int *seq_list;\r
8691        int table=0;\r
8692        \r
8693        \r
8694      \r
8695 \r
8696      /*\r
8697        mode: \r
8698            (trim)_<seq or aln>_%<percentage of tot weight to keep>_n<number of seq to keep>_w<weight mode>\r
8699      */\r
8700      \r
8701 \r
8702      \r
8703      seq_list=vcalloc ( S->nseq, sizeof (int));\r
8704      for ( a=0; a< A->nseq; a++)\r
8705        {\r
8706          seq_list[a]=1;\r
8707        }\r
8708      \r
8709 \r
8710      use_aln=aln_is_aligned(A);\r
8711      \r
8712      if ( mode[0]=='\0')\r
8713        {\r
8714         \r
8715          upper_sim=50;\r
8716          lower_sim=0;\r
8717          min_nseq=0;\r
8718          sprintf (weight_mode, "pwsim");\r
8719          sprintf ( method, "clustering2");\r
8720        }\r
8721      else \r
8722        {\r
8723         \r
8724          upper_sim=lower_sim=min_nseq;\r
8725          sprintf (weight_mode, "pwsim");\r
8726          sprintf ( method, "clustering2");\r
8727        }\r
8728 \r
8729      /*\r
8730       U or % (deprecated) Upper bound for pairwise similarity\r
8731       L or m (depercated) Lower  bound for pairwise similarity\r
8732       n max number of sequences\r
8733       N max number of sequences as a fraction of thet total\r
8734       S print Statistics\r
8735       T print Table of distances\r
8736      */\r
8737 \r
8738      \r
8739 \r
8740      while ( (p=strtok(mode, "_")))\r
8741            {         \r
8742              mode=NULL;\r
8743              if (strm (p, "seq"))use_aln=0;\r
8744              else if ( strm(p,"aln"))use_aln=1;\r
8745              else if  (p[0]=='s')statistics=1;\r
8746              else if  (p[0]=='t')table=1;\r
8747              else if  (p[0]=='U')upper_sim=atoi(p+1);\r
8748              else if  (p[0]=='L')lower_sim=atoi(p+1);\r
8749              else if  (p[0]=='n')min_nseq=atoi(p+1);\r
8750              else if  (p[0]=='N')min_nseq=atoi(p+1)*-1;\r
8751              else if  (p[0]=='B')trim_direction=BOTTOM;\r
8752              else if  (p[0]=='T')trim_direction=TOP;\r
8753              else if  (p[0]=='W')sprintf (weight_mode, "%s", p+1);\r
8754              else if  (p[0]=='M')sprintf (method, "%s", p+1);\r
8755              else if  (p[0]=='K')\r
8756                {\r
8757                  \r
8758                  while ((p=strtok(NULL, ":")))\r
8759                    {\r
8760                      \r
8761                      if ( p[0]=='#')\r
8762                        {\r
8763                          seq_list[atoi(p+1)-1]=2;\r
8764                        }\r
8765                      else if ( (a=name_is_in_list (p, A->name, A->nseq, 100))!=-1)\r
8766 \r
8767                        {\r
8768                          seq_list[a]=2;\r
8769                        } \r
8770                    }\r
8771                }\r
8772            }\r
8773      \r
8774      if ( !upper_sim && !min_nseq && !lower_sim)upper_sim=50;\r
8775      \r
8776      \r
8777 \r
8778      if  (!S)\r
8779        {\r
8780          fprintf ( stderr, "\ntrimseq requires a set of sequences[FATAL:%s]\n", PROGRAM);\r
8781          crash("");\r
8782        }\r
8783      \r
8784      else if ( min_nseq> S->nseq)\r
8785        {\r
8786          min_nseq=S->nseq;\r
8787        }\r
8788      else if ( min_nseq<0)\r
8789        {\r
8790          if ( min_nseq<-100)\r
8791            {\r
8792              add_warning ( stderr, "\nWARNING: trimseq: Nseq(N)  max_val=100%% [Automatic reset]\n");\r
8793              min_nseq=-100;\r
8794            }\r
8795          \r
8796          min_nseq=(int)((float)S->nseq*((float)min_nseq/100)*-1);\r
8797        }\r
8798 \r
8799 \r
8800      NA=seq2subseq3 (A, S,use_aln,lower_sim,upper_sim,min_nseq,trim_direction, weight_mode,&sim_weight, seq_list );\r
8801      \r
8802      if ( table)\r
8803        {\r
8804          fprintf ( stderr, "\nSIMILARITY MATRIX\n");\r
8805          for ( a=0; a< A->nseq-1; a++)\r
8806            for ( b=a+1; b< A->nseq; b++)\r
8807              {\r
8808                fprintf ( stderr, "%15s Vs %15s : %3.2f %% id\n", A->name[a], A->name[b], 100-sim_weight[a][b]);\r
8809              }\r
8810        }\r
8811      if ( statistics)\r
8812        {\r
8813          f_upper_sim=(upper_sim>100)?((float)upper_sim/(float)100):upper_sim;\r
8814          f_lower_sim=(upper_sim>100)?((float)lower_sim/(float)100):lower_sim;\r
8815          \r
8816          fprintf ( stderr, "\nTRIM Informations:\n");\r
8817          fprintf ( stderr, "\tUse...........: %s\n",(use_aln)?"multiple_aln":"pairwise_aln");\r
8818          fprintf ( stderr, "\tcluster_mode..: %s\n"  ,method);\r
8819          fprintf ( stderr, "\tsim_mode......: %s\n"  ,weight_mode);\r
8820          fprintf ( stderr, "\tlower_id_bound: %.2f%%\n"  ,(f_lower_sim==0)?-1:f_lower_sim);\r
8821          fprintf ( stderr, "\tupper_id_bound: %.2f%%\n",(f_upper_sim==0)?-1:f_upper_sim);\r
8822          fprintf ( stderr, "\tnseq_kept.....: %d (out of %d)\n"  ,NA->nseq, S->nseq);\r
8823          fprintf ( stderr, "\treduction.....: %d%% of original set\n"  ,(NA->nseq*100)/S->nseq);\r
8824          fprintf ( stderr, "\tTrim_direction: From %s \n"  ,(trim_direction==BOTTOM)?"Bottom":"Top");\r
8825        }\r
8826 \r
8827      return NA;\r
8828    }\r
8829 \r
8830 Alignment *sim_filter (Alignment *A, char *in_mode, char *seq)\r
8831 {\r
8832   int **sim, **cov;\r
8833   int *list;\r
8834   int *keep;\r
8835   int maxnseq, nseq_ratio, nc;\r
8836   int new_nseq;\r
8837   int a, s, n, k;\r
8838   Alignment *R;\r
8839   char *mode;\r
8840   int outlayers;\r
8841   int direction=1;//remove the higher than\r
8842   int coverage=0; //remove based on coverage\r
8843   static char *field;\r
8844   int maxsim, minsim, maxcov, mincov;\r
8845   \r
8846   if ( !field) field=vcalloc (1000, sizeof (char));\r
8847   \r
8848   mode=vcalloc ( strlen (in_mode)+10, sizeof (char));\r
8849   sprintf ( mode, "_%s_", in_mode);\r
8850   \r
8851   strget_param ( mode, "_I", "100", "%d", &maxsim);\r
8852   strget_param ( mode, "_i", "0", "%d",  &minsim);\r
8853   strget_param ( mode, "_C", "100", "%d",  &maxcov);\r
8854   strget_param ( mode, "_c", "0", "%d",  &mincov);\r
8855   \r
8856  \r
8857   \r
8858     \r
8859   \r
8860   keep=vcalloc ( A->nseq, sizeof (int));\r
8861   list=vcalloc ( A->nseq, sizeof (int));\r
8862  \r
8863  \r
8864   \r
8865 \r
8866   \r
8867   \r
8868   if (!seq)s=0;\r
8869   else s=name_is_in_list (seq, A->name, A->nseq, 100);\r
8870   if (s==-1) \r
8871     {\r
8872     \r
8873       if ( s==-1)printf_exit (EXIT_FAILURE, stderr, "ERROR: %s is not a valid sequence", seq);\r
8874     }\r
8875   else\r
8876     keep[s]=1;\r
8877   \r
8878   //get the distances\r
8879   if ( strstr (mode, "_seq_"))\r
8880     {\r
8881       char **seq;\r
8882       int **M;\r
8883     \r
8884       M=read_matrice ("blosum62mt");\r
8885       seq=declare_char (A->nseq, A->len_aln+1);\r
8886       for (a=0; a<A->nseq; a++)\r
8887         {\r
8888           sprintf ( seq[a], "%s", A->seq_al[a]);\r
8889           ungap (seq[a]);\r
8890         }\r
8891       \r
8892       sim=declare_int (A->nseq, A->nseq);\r
8893       cov=declare_int (A->nseq, A->nseq);\r
8894       \r
8895       for (a=0; a<A->nseq; a++)\r
8896         {\r
8897           if ( s!=a)\r
8898             {\r
8899               sim[s][a]=sim[a][s]=idscore_pairseq(seq[s], seq[a],-12, -1,M,"sim");\r
8900               cov[s][a]=cov[a][s]=idscore_pairseq(seq[s], seq[a],-12, -1,M,"cov");\r
8901               \r
8902             }\r
8903         }\r
8904       free_char (seq, -1);\r
8905       free_int (M,-1);\r
8906     }\r
8907   else \r
8908     {\r
8909       sim=aln2sim_mat (A, "idmat");\r
8910       cov=aln2cov (A);\r
8911     }\r
8912   \r
8913   for (a=0; a< A->nseq; a++)\r
8914     {\r
8915       if (a==s)continue;\r
8916       else \r
8917         {\r
8918           if ( sim[s][a]>maxsim || sim[s][a]<minsim|| cov[s][a]<mincov||cov[s][a]>maxcov)keep[a]=-1;\r
8919           else keep[a]=1;\r
8920         }\r
8921     }\r
8922 \r
8923   for ( n=0, a=0; a< A->nseq; a++)\r
8924     {\r
8925       if ( keep[a]!=-1)\r
8926         {\r
8927           list[n++]=a;\r
8928         }\r
8929     }\r
8930 \r
8931   R=extract_sub_aln (A, n, list);\r
8932   free_int (sim, -1); free_int (cov, -1);vfree (list);\r
8933   \r
8934   return R;\r
8935 }\r
8936         \r
8937 \r
8938 static int find_worst_seq ( int **sim, int n, int *keep, int max, int direction);\r
8939 Alignment *simple_trimseq (Alignment *A, Alignment *K, char *in_mode, char *seq_list)\r
8940 {\r
8941   int **sim;\r
8942   int *list;\r
8943   int *keep;\r
8944   int maxnseq, maxsim, nseq_ratio, nc;\r
8945   int new_nseq;\r
8946   int a,b, s, n, k;\r
8947   Alignment *R;\r
8948   char *mode;\r
8949   int outlayers;\r
8950   int direction=1;//remove the higher than\r
8951   int coverage=0; //remove based on coverage\r
8952   static char *field;\r
8953   int *tot_avg;\r
8954   \r
8955   if ( !field) field=vcalloc (1000, sizeof (char));\r
8956   \r
8957   mode=vcalloc ( strlen (in_mode)+10, sizeof (char));\r
8958   sprintf ( mode, "_%s_", in_mode);\r
8959   \r
8960   strget_param ( mode, "_%%", "0", "%d", &maxsim);\r
8961   strget_param ( mode, "_n", "0", "%d",  &maxnseq);\r
8962   strget_param ( mode, "_N", "0", "%d",  &nseq_ratio);\r
8963   strget_param ( mode, "_F", "0", "%d",  &nc);\r
8964   strget_param ( mode, "_O", "0", "%d",  &outlayers);\r
8965   strget_param ( mode, "_f", "NAME", "%s", field);\r
8966 \r
8967   if ( strstr (mode, "_min"))direction=-1;\r
8968   else direction=1;\r
8969   \r
8970   if ( strstr (mode, "_cov"))coverage=1;\r
8971   else coverage=0;\r
8972   \r
8973  \r
8974   if ( nseq_ratio)\r
8975     {\r
8976       maxnseq=(A->nseq*nseq_ratio)/100;\r
8977       maxsim=0;\r
8978     }\r
8979   else if ( maxnseq)\r
8980     {\r
8981       maxsim=0;\r
8982     }\r
8983   else if ( !maxsim)\r
8984     {\r
8985       maxsim=100;\r
8986     }\r
8987     \r
8988   \r
8989   keep=vcalloc ( A->nseq, sizeof (int));\r
8990   list=vcalloc ( A->nseq, sizeof (int));\r
8991  \r
8992  \r
8993   \r
8994  \r
8995   /*Remove Sequences that do not have at least one residue in the first and last nc columns*/\r
8996   if ( nc)\r
8997     {\r
8998       int left, right, full_n,x, y;\r
8999       int *full_list;\r
9000       \r
9001       Alignment *F;\r
9002       \r
9003       full_list=vcalloc ( A->nseq, sizeof (int));\r
9004       full_n=0;\r
9005       for (x=0; x< A->nseq; x++)\r
9006         {\r
9007           for ( left=0,y=0; y<MIN(A->len_aln,nc); y++)\r
9008             if (!is_gap(A->seq_al[x][y]))left=1;\r
9009           \r
9010           for ( right=0,y=MAX(0,(A->len_aln-nc)); y<A->len_aln; y++)\r
9011             if (!is_gap(A->seq_al[x][y]))right=1;\r
9012           \r
9013           if ( left && right)full_list[full_n++]=x;\r
9014         }\r
9015       F=extract_sub_aln (A, full_n, full_list);\r
9016       free_aln (A);\r
9017       vfree (full_list);\r
9018       A=F;\r
9019     }\r
9020           \r
9021   /*Reorder the sequences according to the tree order: hopefully better phylogenetic coverage after trim*/\r
9022   if (strstr (mode, "_T"))\r
9023     {\r
9024       NT_node **T;\r
9025       Sequence *O;\r
9026 \r
9027       sim=sim_array2dist_array ( sim, MAXID);\r
9028       T=int_dist2nj_tree (sim, A->name, A->nseq, NULL);\r
9029       O=tree2seq (T[3][0], NULL);\r
9030       A=reorder_aln (A, O->name, O->nseq);\r
9031       \r
9032       free_int (sim, -1);\r
9033       free_sequence (O, -1);\r
9034     }\r
9035   \r
9036   if ( coverage==0)\r
9037     {\r
9038       if ( strstr (mode, "seq_"))sim=seq2comp_mat (aln2seq(A), "blosum62mt", "sim");\r
9039       else sim=aln2sim_mat (A, "idmat");\r
9040     }\r
9041   else\r
9042     {\r
9043       int b;\r
9044       if ( strstr (mode, "seq_"))sim=seq2comp_mat (aln2seq(A), "blosum62mt", "cov");\r
9045       else sim=aln2cov (A);\r
9046     \r
9047     }\r
9048 \r
9049 \r
9050   if ( K && K->nseq>0)\r
9051     {\r
9052       for ( a=0; a< K->nseq; a++)\r
9053         if ( (k=name_is_in_list (K->name[a], A->name, A->nseq, MAXNAMES+1))!=-1)\r
9054           {\r
9055 \r
9056             keep[k]=1;\r
9057           }\r
9058     }\r
9059   if ( seq_list)\r
9060     {\r
9061       for ( a=0; a< A->nseq; a++)\r
9062         {\r
9063           if (strstr (field, "NAME") && perl_strstr (A->name[a], seq_list)){keep[a]=1;}\r
9064           else if (strstr (field, "COMMENT") && A->seq_comment && perl_strstr(A->seq_comment[a], seq_list)){keep[a]=1;}\r
9065           else if (strstr (field, "SEQ") && perl_strstr((A->S)->seq[a], seq_list)){keep[a]=1;}\r
9066         }\r
9067       \r
9068             \r
9069     }\r
9070   for ( a=0; a< A->nseq; a++)\r
9071     if ( keep[a]) fprintf ( stderr, "\nFORCED KEEP %s", A->name[a]);\r
9072   \r
9073   new_nseq=A->nseq;\r
9074   \r
9075   \r
9076   while ( (s=find_worst_seq (sim, A->nseq, keep, maxsim, direction))!=-1 && new_nseq>maxnseq)\r
9077     {\r
9078       for ( a=0; a< A->nseq; a++)sim[a][s]=sim[s][a]=-1;\r
9079       keep[s]=-1;\r
9080       new_nseq--;\r
9081     }\r
9082   \r
9083   /*Trim Outlayers*/\r
9084   if (outlayers!=0)\r
9085     {\r
9086      int nn, b;\r
9087       tot_avg=vcalloc ( A->nseq, sizeof (int));\r
9088       \r
9089       for (a=0; a<A->nseq; a++)\r
9090         {\r
9091           if ( keep[a]==-1)tot_avg[a]=-1;\r
9092           else\r
9093             {\r
9094               for (nn=0, b=0; b< A->nseq; b++)\r
9095                 {\r
9096                   if (a==b || keep[b]==-1)continue;\r
9097                   else\r
9098                     {\r
9099                       tot_avg[a]+=sim[a][b];\r
9100                       nn++;\r
9101                     }\r
9102                 }\r
9103               tot_avg[a]=(nn==0)?-1:(tot_avg[a])/nn;\r
9104             }\r
9105         }\r
9106       for ( a=0; a<A->nseq; a++)\r
9107         {\r
9108           if (tot_avg[a]!=-1 && tot_avg[a]<outlayers)\r
9109             {\r
9110               fprintf ( stderr, "\nREMOVED OUTLAYER: %3d %% avg similarity with remaining sequences [Seq %s]", tot_avg[a],A->name[a]);\r
9111               keep[a]=-1;\r
9112             }\r
9113         }\r
9114       vfree ( tot_avg);\r
9115     }\r
9116 \r
9117   for ( n=0, a=0; a< A->nseq; a++)\r
9118     {\r
9119       if ( keep[a]!=-1)\r
9120         {\r
9121           list[n++]=a;\r
9122         }\r
9123     }\r
9124 \r
9125   R=extract_sub_aln (A, n, list);\r
9126   free_int (sim, -1); vfree (list);\r
9127   \r
9128   return R;\r
9129 }\r
9130         \r
9131 int find_worst_seq ( int **sim, int n, int *keep,int max,int direction)\r
9132 {\r
9133   int **sc;\r
9134   int a, b, r=0;\r
9135   int si;\r
9136   \r
9137   sc=declare_int (n, 2);\r
9138   if (direction==-1)max=100-max;\r
9139   \r
9140   for ( a=0; a< n; a++) sc[a][0]=a;\r
9141   for ( a=0; a< n-1; a++)\r
9142     {\r
9143       for ( b=a+1; b<n; b++)\r
9144         {\r
9145           \r
9146           if (sim[a][b]>=0)si=(direction==-1)?100-sim[a][b]:sim[a][b];\r
9147           else si=sim[a][b];\r
9148           if ( si>max)\r
9149                 {\r
9150                   if ( keep[a]!=1)sc[a][1]+=si;\r
9151                   if ( keep[b]!=1)sc[b][1]+=si;\r
9152                 }\r
9153         }\r
9154     }\r
9155   \r
9156   sort_int_inv ( sc, 2, 1, 0, n-1);\r
9157   if ( sc[0][1]>0)r=sc[0][0];\r
9158   else r=-1;\r
9159   \r
9160   free_int (sc, -1);\r
9161   if (r!=-1 && keep && keep[r])return -1;\r
9162   else return r;\r
9163 }\r
9164 \r
9165 int find_worst_seq_old ( int **sim, int n, int *keep,int max,int direction)\r
9166 {\r
9167   int **sc;\r
9168   int a, b, r=0;\r
9169   \r
9170   sc=declare_int (n, 2);\r
9171   \r
9172   for ( a=0; a< n; a++) sc[a][0]=a;\r
9173   for ( a=0; a< n-1; a++)\r
9174     {\r
9175       for ( b=a+1; b<n; b++)\r
9176         {\r
9177           if ( direction==1)\r
9178             {\r
9179               if ( sim[a][b]>max)\r
9180                 {\r
9181                   if ( keep[a]!=1)sc[a][1]+=sim[a][b]; \r
9182                   if ( keep[b]!=1)sc[b][1]+=sim[a][b];\r
9183                 }\r
9184             }\r
9185           else if ( direction == -1)\r
9186             {\r
9187               if ( sim[a][b]<max && sim[a][b]>=0)\r
9188                 {\r
9189                   if ( keep[a]!=1)sc[a][1]+=sim[a][b]; \r
9190                   if ( keep[b]!=1)sc[b][1]+=sim[a][b];\r
9191                 }\r
9192             }\r
9193         }\r
9194     }\r
9195   \r
9196   if ( direction ==1) //remove max\r
9197     {\r
9198       sort_int_inv ( sc, 2, 1, 0, n-1);\r
9199       if ( sc[0][1]>0)r=sc[0][0];\r
9200       else r=-1;\r
9201       \r
9202     }\r
9203   else if ( direction ==-1)//remove min\r
9204     {\r
9205       sort_int_inv ( sc, 2, 1, 0, n-1);\r
9206       if ( sc[0][1]>=0)r=sc[0][0];\r
9207       else r=-1;\r
9208       HERE ("** %d %d\n", r,sc[0][1]); \r
9209     }\r
9210   free_int (sc, -1);\r
9211   if (r!=-1 && keep && keep[r])return -1;\r
9212   else return r;\r
9213 }\r
9214 \r
9215       \r
9216 Alignment * trimseq( Alignment *A, Sequence *S,char *mode)\r
9217    {\r
9218      Alignment *NA;\r
9219      char *p;\r
9220      int a, b;\r
9221      int use_aln=0, upper_sim=0, min_nseq=0, lower_sim=0;\r
9222      char weight_mode[1000];\r
9223      char method[1000];\r
9224      int statistics=0;\r
9225      int trim_direction=TOP;\r
9226      float **sim_weight;\r
9227      int *seq_list;\r
9228      int table=0;\r
9229      int print_name=0;\r
9230      float f_lower_sim, f_upper_sim;\r
9231      \r
9232          \r
9233 \r
9234      /*\r
9235        mode: \r
9236            (trim)_<seq or aln>_%<percentage of tot weight to keep>_n<number of seq to keep>_w<weight mode>\r
9237      */\r
9238      \r
9239 \r
9240      \r
9241      seq_list=vcalloc ( S->nseq, sizeof (int));\r
9242      for ( a=0; a< A->nseq; a++)\r
9243        {\r
9244          seq_list[a]=1;\r
9245        }\r
9246      \r
9247 \r
9248      use_aln=aln_is_aligned(A);\r
9249      \r
9250      \r
9251      if ( mode[0]=='\0')\r
9252        {\r
9253         \r
9254          upper_sim=50;\r
9255          lower_sim=0;\r
9256          min_nseq=0;\r
9257          sprintf (weight_mode, "pwsim_fragment");\r
9258          sprintf ( method, "clustering2");\r
9259        }\r
9260      else \r
9261        {\r
9262         \r
9263          upper_sim=lower_sim=min_nseq;\r
9264          sprintf (weight_mode, "pwsim_fragment");\r
9265          sprintf ( method, "clustering2");\r
9266        }\r
9267 \r
9268      /*\r
9269       U or % (deprecated) Upper bound for pairwise similarity\r
9270       L or m (depercated) Lower  bound for pairwise similarity\r
9271       n max number of sequences\r
9272       N max number of sequences as a fraction of thet total\r
9273       S print Statistics\r
9274       T print Table of distances\r
9275      */\r
9276 \r
9277      \r
9278 \r
9279      while ( (p=strtok(mode, "_")))\r
9280            {         \r
9281              mode=NULL;\r
9282              if (strm (p, "seq"))use_aln=0;\r
9283              else if ( strm(p,"aln"))use_aln=1;\r
9284              else if  (p[0]=='s')statistics=1;\r
9285              else if  (p[0]=='t')table=1;\r
9286              else if  (p[0]=='p')print_name=1;\r
9287              else if  (p[0]=='U')upper_sim=atoi(p+1);\r
9288              else if  (p[0]=='L')lower_sim=atoi(p+1);\r
9289              else if  (p[0]=='n')min_nseq=atoi(p+1);\r
9290              else if  (p[0]=='N')min_nseq=atoi(p+1)*-1;\r
9291              else if  (p[0]=='B')trim_direction=BOTTOM;\r
9292              else if  (p[0]=='T')trim_direction=TOP;\r
9293              else if  (p[0]=='W')sprintf (weight_mode, "%s", p+1);\r
9294              else if  (p[0]=='M')sprintf (method, "%s", p+1);\r
9295              else if  (p[0]=='K')\r
9296                {\r
9297                  \r
9298                  while ((p=strtok(NULL, ":")))\r
9299                    {\r
9300                      \r
9301                      if ( (a=name_is_in_list (p, A->name, A->nseq, 100))!=-1)\r
9302                        {\r
9303                          seq_list[a]=2;\r
9304                        } \r
9305                    }\r
9306                }\r
9307            }\r
9308      \r
9309      if ( !upper_sim && !min_nseq && !lower_sim)upper_sim=50;\r
9310      \r
9311      \r
9312 \r
9313      if  (!S)\r
9314        {\r
9315          fprintf ( stderr, "\ntrimseq requires a set of sequences[FATAL:%s]\n", PROGRAM);\r
9316          crash("");\r
9317        }\r
9318      \r
9319      else if ( min_nseq> S->nseq)\r
9320        {\r
9321          min_nseq=S->nseq;\r
9322        }\r
9323      else if ( min_nseq<0)\r
9324        {\r
9325          if ( min_nseq<-100)\r
9326            {\r
9327              add_warning ( stderr, "\nWARNING: trimseq: Nseq(N)  max_val=100%% [Automatic reset]\n");\r
9328              min_nseq=-100;\r
9329            }\r
9330          \r
9331          min_nseq=(int)((float)S->nseq*((float)min_nseq/100)*-1);\r
9332        }\r
9333 \r
9334 \r
9335      NA=seq2subseq2 (A, S,use_aln,lower_sim,upper_sim,min_nseq,trim_direction, weight_mode,&sim_weight, seq_list );\r
9336      \r
9337      if ( table)\r
9338        {\r
9339          fprintf ( stderr, "\nSIMILARITY MATRIX\n");\r
9340          for ( a=0; a< A->nseq-1; a++)\r
9341            for ( b=a+1; b< A->nseq; b++)\r
9342              {\r
9343                fprintf ( stderr, "%15s Vs %15s : %3.2f %% id\n", A->name[a], A->name[b], 100-sim_weight[a][b]);\r
9344              }\r
9345        }\r
9346      \r
9347      NA=seq_name2removed_seq_name(S, NA,sim_weight);\r
9348 \r
9349      if ( print_name)\r
9350        {\r
9351          fprintf ( stderr, "\nList of sequences with their closest removed neighbors\n");\r
9352          for ( a=0; a< NA->nseq; a++)fprintf ( stderr, "\n%s: %s\n", NA->name[a], NA->seq_comment[a]);\r
9353        }\r
9354      \r
9355      if ( statistics)\r
9356        {\r
9357          f_lower_sim=(lower_sim>100)?(float)lower_sim/100:lower_sim;\r
9358          f_upper_sim=(upper_sim>100)?(float)upper_sim/100:upper_sim;\r
9359 \r
9360          fprintf ( stderr, "\nTRIM seq Informations:\n");\r
9361          fprintf ( stderr, "\tUse...........: %s\n",(use_aln)?"multiple_aln":"pairwise_aln");\r
9362          fprintf ( stderr, "\tcluster_mode..: %s\n"  ,method);\r
9363          fprintf ( stderr, "\tsim_mode......: %s\n"  ,weight_mode);\r
9364          fprintf ( stderr, "\tlower_id_bound: %.2f%%\n"  ,(f_lower_sim==0)?-1:f_lower_sim);\r
9365          fprintf ( stderr, "\tupper_id_bound: %.2f%%\n",(f_upper_sim==0)?-1:f_upper_sim);\r
9366          fprintf ( stderr, "\tnseq_kept.....: %d (out of %d)\n"  ,NA->nseq, S->nseq);\r
9367          fprintf ( stderr, "\treduction.....: %d%% of original set\n"  ,(NA->nseq*100)/S->nseq);\r
9368          fprintf ( stderr, "\tTrim_direction: From %s \n"  ,(trim_direction==BOTTOM)?"Bottom":"Top");\r
9369        }\r
9370 \r
9371      return NA;\r
9372    }\r
9373     \r
9374 Alignment * tc_trimseq( Alignment *A, Sequence *S,char *mode)\r
9375    {\r
9376      Alignment *NA;\r
9377      Sequence  *TS;\r
9378      char *trimfile, *alnfile;\r
9379      int *seq_list;\r
9380      int a, nseq=0, sim=0;\r
9381      char *p;\r
9382      char command[100000];\r
9383      char keep_list[10000];\r
9384      \r
9385      int top, bottom, middle, pmiddle;\r
9386      \r
9387      keep_list[0]='\0';\r
9388     \r
9389      seq_list=vcalloc ( S->nseq, sizeof (int));\r
9390      for ( a=0; a< A->nseq; a++)\r
9391        {\r
9392          seq_list[a]=1;\r
9393        }\r
9394      \r
9395      trimfile=vtmpnam (NULL);\r
9396      alnfile=vtmpnam (NULL);\r
9397      if ( !aln_is_aligned (A))\r
9398        {\r
9399          fprintf ( stderr, "\ntrimTC: computation of an Approximate MSA  [");\r
9400          A=compute_tcoffee_aln_quick ( A, NULL);\r
9401          fprintf ( stderr, "DONE]\n");\r
9402        }\r
9403      output_clustal_aln (alnfile, A);\r
9404      \r
9405     \r
9406      while ( (p=strtok(mode, "#")))\r
9407            {         \r
9408              mode=NULL;\r
9409 \r
9410                      \r
9411              if (p[0]=='%' || p[0]=='S')sim=(p[1]=='%')?atoi(p+2):atoi(p+1);\r
9412              else if  (p[0]=='n' || p[0]=='N')nseq=atoi(p+1);\r
9413              else if  (p[0]=='K')\r
9414                {\r
9415                  if ( (a=name_is_in_list (p+1, A->name, A->nseq, 100))!=-1)\r
9416                    {\r
9417                      seq_list[a]=2;\r
9418                    }  \r
9419                  \r
9420                }\r
9421            }\r
9422      if ( nseq ==0 && sim ==0)\r
9423        {\r
9424          fprintf ( stderr, "\nERROR: trimTC\nIndicate the maximum number of sequences Nnseq\nOR the maximum average similarity of the chosen sequencesSx\nEX: +trimTC S20 OR +trimTC N5"); \r
9425          fprintf ( stderr, "\n[FATAL:%s]", PROGRAM);\r
9426          myexit (EXIT_FAILURE);\r
9427        }\r
9428      \r
9429      for ( a=0; a<A->nseq; a++)if (seq_list[a]==2){strcat ( keep_list, A->name[a]);strcat ( keep_list," ");}\r
9430      \r
9431      if ( sim)\r
9432        {\r
9433          sprintf ( command , "%s -infile %s -trim  -trimfile=%s  -split_score_thres %d -convert -iterate 0 ",get_string_variable("t_coffee"), alnfile, trimfile,sim);\r
9434          if ( keep_list[0]){strcat ( command, " -seq_to_keep ");strcat ( command, keep_list);}\r
9435          my_system ( command);\r
9436          TS=read_sequences (trimfile);\r
9437        }\r
9438      else if ( nseq && A->nseq>nseq)\r
9439        {\r
9440          \r
9441          top=100;bottom=0;\r
9442          pmiddle=0;middle=50;\r
9443          \r
9444          sprintf ( command , "%s -infile %s -trim  -trimfile=%s  -split_score_thres %d -convert -iterate 0",get_string_variable("t_coffee"), alnfile, trimfile,middle);\r
9445          if ( keep_list[0]){strcat ( command, " -seq_to_keep ");strcat ( command, keep_list);}\r
9446          my_system ( command);\r
9447          \r
9448          TS=read_sequences (trimfile);\r
9449          fprintf ( stderr, "\n\tTrimTC: Sim %d Nseq %d\t",middle, TS->nseq);\r
9450          \r
9451          if ( TS->nseq>nseq)top=middle;\r
9452          else if ( TS->nseq<nseq)bottom=middle;\r
9453          pmiddle=middle;\r
9454          middle=(top-bottom)/2+bottom;\r
9455          \r
9456          while (TS->nseq!=nseq && pmiddle!=middle)\r
9457            {\r
9458              \r
9459              sprintf ( command , "%s -infile %s -trim  -trimfile=%s  -split_score_thres %d -convert -iterate 0 ",get_string_variable("t_coffee"), alnfile, trimfile,middle);\r
9460              if ( keep_list[0]){strcat ( command, " -seq_to_keep ");strcat ( command, keep_list);}\r
9461              my_system ( command);\r
9462              free_sequence (TS, -1);\r
9463              TS=read_sequences (trimfile);\r
9464              fprintf ( stderr, "\n\tTrimTC: Sim %d Nseq %d\t", middle, TS->nseq);\r
9465              \r
9466              if ( TS->nseq>nseq)top=middle;\r
9467              else if ( TS->nseq<nseq)bottom=middle;\r
9468              pmiddle=middle;\r
9469              middle=(top-bottom)/2+bottom;\r
9470            }\r
9471        }\r
9472      else\r
9473        {\r
9474          TS=aln2seq (A);\r
9475        }\r
9476      NA=seq2aln (TS, NULL, 1);\r
9477      vremove ( alnfile);\r
9478      fprintf ( stderr, "\n");\r
9479      \r
9480      return NA;\r
9481    }   \r
9482 \r
9483 Alignment* seq2subseq3( Alignment *A, Sequence *S,int use_aln, int int_lower_sim,int int_upper_sim, int min_nseq, int trim_direction, char *weight_mode, float ***sim_weight, int *seq_list)\r
9484 {\r
9485   int a, b;\r
9486   int new_nseq;\r
9487 \r
9488   /*OUTPUT*/\r
9489   char **seq, **name;\r
9490   Sequence *NS;\r
9491   Alignment *NA;\r
9492   float sim, lower_sim, upper_sim;\r
9493   \r
9494   lower_sim=(int_lower_sim>100)?(float)int_lower_sim/100:int_lower_sim;\r
9495   upper_sim=(int_upper_sim>100)?(float)int_upper_sim/100:int_upper_sim;\r
9496 \r
9497   sim_weight[0]=get_weight   ((use_aln)?A:NULL, S, weight_mode);\r
9498   \r
9499   name=declare_char (S->nseq, (MAXNAMES+1));\r
9500   seq= declare_char (S->nseq, S->max_len+1);\r
9501   \r
9502   /*\r
9503     Remove every sequence that is more than upper_sim and less than lower_sim similar to the master sequences\r
9504     the master sequence(s) are those for which seq_list[x]==2\r
9505   */\r
9506 \r
9507 \r
9508   \r
9509 \r
9510   new_nseq=A->nseq;\r
9511   \r
9512 \r
9513   for (a=0; a< A->nseq; a++)\r
9514     {\r
9515       if ( seq_list[a]==2)\r
9516         {\r
9517         \r
9518           for ( b=0; b< A->nseq;b++)\r
9519             {\r
9520               sim=100-sim_weight[0][a][b];\r
9521               if (seq_list[b]==1 && (sim>upper_sim || sim<lower_sim))\r
9522                 {\r
9523                  seq_list[b]=0;\r
9524                  new_nseq--;\r
9525                 }\r
9526             }\r
9527           \r
9528         }\r
9529     }\r
9530   \r
9531   /*Prepare the new sequence List*/\r
9532 \r
9533   for (b=0, a=0; a<S->nseq; a++) \r
9534           {\r
9535             if ( seq_list[a])\r
9536               {\r
9537                 sprintf ( name[b], "%s", S->name[a]);\r
9538                 sprintf ( seq[b] , "%s",(use_aln)?A->seq_al[a]: S->seq[a] );\r
9539                 b++;\r
9540               }\r
9541           }\r
9542   \r
9543   \r
9544   NS=fill_sequence_struc (new_nseq,seq,name);\r
9545   NA=seq2aln(NS,NULL,1);         \r
9546   \r
9547   if ( use_aln && A)\r
9548     {\r
9549       NA=realloc_aln2  ( NA,A->max_n_seq,A->len_aln+1);\r
9550       \r
9551       for (b=0, a=0; a<S->nseq; a++) \r
9552         {\r
9553           if ( seq_list[a])\r
9554             {\r
9555               sprintf ( NA->seq_al[b] , "%s",A->seq_al[a]);\r
9556               b++;\r
9557               }\r
9558         }\r
9559 \r
9560       NA->len_aln=A->len_aln;\r
9561       ungap_aln(NA);\r
9562     }\r
9563   \r
9564 \r
9565   return NA;\r
9566 }\r
9567 Alignment* seq2subseq2( Alignment *A, Sequence *S,int use_aln, int int_lower_sim,int int_upper_sim, int min_nseq, int trim_direction, char *weight_mode, float ***sim_weight, int *seq_list)\r
9568 {\r
9569   int a, b;\r
9570   int new_nseq;\r
9571   int seq_index=0;\r
9572   /*OUTPUT*/\r
9573   char **seq, **name;\r
9574   Sequence *NS;\r
9575   Alignment *NA;\r
9576   float lower_sim, upper_sim;\r
9577   \r
9578   lower_sim=(int_lower_sim>100)?(float)int_lower_sim/100:int_lower_sim;\r
9579   upper_sim=(int_upper_sim>100)?(float)int_upper_sim/100:int_upper_sim;\r
9580 \r
9581  \r
9582   sim_weight[0]=get_weight   ((use_aln)?A:NULL, S, weight_mode);\r
9583   \r
9584   name=declare_char (S->nseq, (MAXNAMES+1));\r
9585   seq= declare_char (S->nseq, S->max_len+1);\r
9586   \r
9587   /*\r
9588     1 REMOVE OUTLAYERS\r
9589     2 REMOVE CLOSELY RELATED SEQUENCES\r
9590     3 IF STILL TOO MANY SEQUENCES:\r
9591       REMOVE THE MOST CLOSELY RELATED ONES\r
9592   */\r
9593 \r
9594 \r
9595   /*1 Remove outlayers*/\r
9596   \r
9597   new_nseq=A->nseq;\r
9598  \r
9599  \r
9600   /*1 Remove outlayers*/\r
9601   while ( lower_sim && (extreme_seq(BOTTOM,A,sim_weight[0],seq_list, &seq_index) <lower_sim) && ((new_nseq)>min_nseq) && seq_index!=-1)\r
9602     {\r
9603   \r
9604       if ( seq_list[seq_index]==1)\r
9605         {\r
9606           seq_list[seq_index]=0;\r
9607           new_nseq--;\r
9608         }\r
9609     }\r
9610    /*2 Remove close relative*/\r
9611   \r
9612  \r
9613   while ( upper_sim && (extreme_seq(TOP, A,sim_weight[0],seq_list, &seq_index)>upper_sim) && ((new_nseq)>min_nseq)&& seq_index!=-1)\r
9614     { \r
9615   \r
9616       if ( seq_list[seq_index]==1)\r
9617         {\r
9618           seq_list[seq_index]=0;\r
9619           new_nseq--;\r
9620         }\r
9621     }\r
9622 \r
9623 \r
9624   /*Remove extra sequences*/\r
9625   \r
9626   while ( min_nseq>0 && new_nseq>min_nseq && seq_index!=-1)\r
9627     {\r
9628      \r
9629       extreme_seq(trim_direction, A,sim_weight[0],seq_list, &seq_index);\r
9630   \r
9631       if ( seq_index==-1)break;\r
9632       if ( seq_list[seq_index]==1)\r
9633         {\r
9634           seq_list[seq_index]=0;\r
9635           new_nseq--;\r
9636         }\r
9637     }\r
9638 \r
9639 \r
9640   /*Prepare the new sequence List*/\r
9641 \r
9642   for (b=0, a=0; a<S->nseq; a++) \r
9643           {\r
9644             if ( seq_list[a])\r
9645               {\r
9646                 sprintf ( name[b], "%s", S->name[a]);\r
9647                 sprintf ( seq[b] , "%s",(use_aln)?A->seq_al[a]: S->seq[a] );\r
9648                 b++;\r
9649               }\r
9650           }\r
9651   \r
9652   \r
9653   NS=fill_sequence_struc (new_nseq,seq,name);\r
9654   NA=seq2aln(NS,NULL,1);         \r
9655   \r
9656   if ( use_aln && A)\r
9657     {\r
9658       NA=realloc_aln2  ( NA,A->max_n_seq,A->len_aln+1);\r
9659       \r
9660       for (b=0, a=0; a<S->nseq; a++) \r
9661         {\r
9662           if ( seq_list[a])\r
9663             {\r
9664               sprintf ( NA->seq_al[b],"%s",A->seq_al[a]);\r
9665               b++;\r
9666               }\r
9667         }\r
9668 \r
9669       NA->len_aln=A->len_aln;\r
9670       ungap_aln(NA);\r
9671     }\r
9672   \r
9673 \r
9674   return NA;\r
9675 }\r
9676 \r
9677 float extreme_seq (int direction, Alignment *A,float **sim_weight,int *seq_list, int *seq_index)\r
9678 {\r
9679   \r
9680   /*find the closest relative of each sequence\r
9681     Return:\r
9682           Direction= BOTTOM: the sequence whose closest relative is the most distant\r
9683           Direction= TOP:    the sequence whose closest relative is the closest\r
9684   weight: different sequences=100\r
9685           similar sequences  =0\r
9686   */\r
9687   int a, b;\r
9688  \r
9689   float top_sim,bottom_sim, best_sim, sim;\r
9690   int   top_seq, bottom_seq;\r
9691   \r
9692   bottom_seq=top_seq=seq_index[0]=-1;\r
9693   top_sim=-1;\r
9694   bottom_sim=101;\r
9695   \r
9696   for (a=0; a< A->nseq; a++)\r
9697     {\r
9698       if (seq_list[a]!=1)continue;\r
9699 \r
9700       for ( best_sim=0, b=0; b< A->nseq; b++)\r
9701         {\r
9702           if ( a==b || !seq_list[b])continue;\r
9703           \r
9704           sim=100-sim_weight[a][b];\r
9705           if (sim>best_sim)\r
9706             {\r
9707               best_sim=sim;\r
9708             }\r
9709         }\r
9710 \r
9711       if ( best_sim>top_sim)\r
9712         {\r
9713           top_seq=a;\r
9714           top_sim=best_sim;\r
9715         }\r
9716      \r
9717       if ( best_sim<bottom_sim)\r
9718         {\r
9719           bottom_seq=a;\r
9720           bottom_sim=best_sim;\r
9721         }\r
9722       \r
9723     }\r
9724   if ( direction==BOTTOM  ){seq_index[0]= bottom_seq; return bottom_sim;}\r
9725   else if ( direction==TOP){seq_index[0]= top_seq; return top_sim;}\r
9726   else\r
9727     {\r
9728       seq_index[0]=-1;\r
9729       return -1;\r
9730     }\r
9731 }\r
9732   \r
9733   \r
9734       \r
9735       \r
9736 Alignment* seq2subseq1( Alignment *A, Sequence *S,int use_aln, int percent,int max_nseq, int ms,char *weight_mode)\r
9737    {\r
9738      float **pw_weight,**sim_weight, **seq_weight;\r
9739      int a,b,c,d;\r
9740      float sum, chosen,last_chosen, last_nchosen,nchosen;\r
9741      int condition1, condition2;\r
9742      Sequence *NS;\r
9743      Alignment *NA;\r
9744      char **name, **seq;\r
9745      float score, best_score;\r
9746      int best_seq=0;\r
9747      int *seq_list, *used_seq_list;\r
9748      \r
9749      /*\r
9750        mode: \r
9751            (trim)_<seq or aln>_%<percentage of tot weight to keep>_n<number of seq to keep>_w<weight mode>\r
9752      */\r
9753      \r
9754      sim_weight=get_weight   ((use_aln)?A:NULL, S, weight_mode);\r
9755      pw_weight=declare_float (S->nseq, S->nseq);\r
9756      seq_weight=declare_float ( S->nseq, 2);\r
9757 \r
9758      \r
9759      for (best_score=0,a=0; a<S->nseq; a++)\r
9760        {\r
9761          for ( b=0; b<S->nseq; b++)\r
9762            {\r
9763              if ( a==b)continue;\r
9764              seq_weight[a][0]+=sim_weight[a][b];\r
9765            }\r
9766          seq_weight[a][0]=seq_weight[a][0]/(S->nseq-1);\r
9767          score=seq_weight[a][0]=100-seq_weight[a][0];\r
9768          \r
9769          if ( score>best_score)\r
9770            {\r
9771              best_seq=a;\r
9772              best_score=score;\r
9773            }\r
9774 \r
9775        }\r
9776       for (a=0; a<S->nseq; a++)\r
9777        {\r
9778          for ( b=0; b<S->nseq; b++)\r
9779            {\r
9780              if ( a==b)continue;\r
9781              pw_weight[a][b]=sim_weight[a][b]*seq_weight[a][0]*seq_weight[b][0]/(100*100);\r
9782              \r
9783            }\r
9784        }\r
9785       \r
9786  \r
9787      seq_list=vcalloc ( S->nseq, sizeof (int));\r
9788      used_seq_list=vcalloc ( S->nseq, sizeof (int));\r
9789 \r
9790     \r
9791 \r
9792      name=declare_char (S->nseq, (MAXNAMES+1));\r
9793      seq= declare_char (S->nseq, S->max_len+1);\r
9794      \r
9795      /*compute the normalization factor*/\r
9796      for (sum=0,d=0; d< S->nseq; d++)\r
9797            {\r
9798              for (score=0,c=0; c<S->nseq; c++)\r
9799                {\r
9800                  if ( c!=d)\r
9801                    score=MAX(score, 100-sim_weight[c][d]);\r
9802                }\r
9803              sum+=score;\r
9804            }\r
9805      sum=sum/S->nseq;\r
9806      /*chose the first sequence */\r
9807      for ( best_score=0,a=0; a< S->nseq; a++)\r
9808        {\r
9809          for (score=0, b=0; b< S->nseq; b++)\r
9810            {\r
9811              score+=100-sim_weight[a][b];\r
9812            }\r
9813          if ( score>best_score)\r
9814            {\r
9815              best_seq=a;\r
9816              best_score=score;\r
9817            }\r
9818          \r
9819        }\r
9820 \r
9821 \r
9822      last_chosen=chosen=((best_score/S->nseq)*100)/sum;\r
9823      nchosen=last_nchosen=1;\r
9824      seq_list[0]=best_seq;\r
9825      used_seq_list[best_seq]=1;\r
9826 \r
9827      sprintf ( name[0],"%s", S->name[seq_list[0]]);\r
9828      sprintf ( seq[0],"%s", S->seq[seq_list[0]]);\r
9829      nchosen=last_nchosen=1;\r
9830      \r
9831 \r
9832      fprintf ( stderr, "\nTRIM:\n");\r
9833      fprintf ( stderr, "\n1-Chosen Sequences\n");\r
9834      /*Assemble the list of sequences*/\r
9835      for (a=1; a< S->nseq; a++)\r
9836        {\r
9837          for (best_score=0,b=0; b< S->nseq; b++)\r
9838            {\r
9839              if (used_seq_list[b]);\r
9840              else\r
9841                {\r
9842                  score=pw_weight[seq_list[0]][b]+1;\r
9843                  for (c=0; c<a; c++)\r
9844                    score=MIN(score,pw_weight[seq_list[c]][b]);\r
9845                    \r
9846                  if ( score>=best_score)\r
9847                    {\r
9848                    best_seq=b;\r
9849                    best_score=score;\r
9850                    }\r
9851                \r
9852                }\r
9853            }\r
9854          seq_list[a]=best_seq;\r
9855          used_seq_list[best_seq]=1;\r
9856          \r
9857          \r
9858 \r
9859          for ( chosen=0,d=0; d< S->nseq; d++)\r
9860            {\r
9861              for (score=0, c=0; c<=a; c++)\r
9862                {\r
9863                  if ( seq_list[c]!=d)\r
9864                    score=MAX(score, 100-sim_weight[seq_list[c]][d]);\r
9865                }\r
9866              chosen+=score;\r
9867              \r
9868            }\r
9869          \r
9870          chosen=((chosen/S->nseq)*100)/sum;\r
9871          nchosen=a+1;\r
9872                  \r
9873          condition1= (int)chosen<=(int)percent || !percent;\r
9874          condition2=(nchosen)<=max_nseq     || !max_nseq;\r
9875          \r
9876          if (condition1 && condition2)\r
9877            {\r
9878              fprintf ( stderr, "\tADD %s (set score: %.2f %%)\n", S->name[seq_list[a]], chosen);\r
9879              sprintf ( name[a],"%s", S->name[seq_list[a]]);\r
9880              sprintf ( seq[a],"%s", S->seq[seq_list[a]]);\r
9881              \r
9882            }\r
9883          else\r
9884            {\r
9885              break;      \r
9886            }\r
9887          last_chosen=chosen;\r
9888          last_nchosen=nchosen;\r
9889        }\r
9890        \r
9891      NS=fill_sequence_struc (last_nchosen,seq,name);\r
9892      NA=seq2aln(NS,NULL,1);      \r
9893      fprintf ( stderr, "\n2-Informations:\n");\r
9894      fprintf ( stderr, "\tUse...........: %s\n",(use_aln)?"multiple_aln":"pairwise_aln");\r
9895      fprintf ( stderr, "\tweight_mode...: %s\n"  ,weight_mode);\r
9896      fprintf ( stderr, "\tpercent_weight: %.2f%% (max=%d%%)\n",last_chosen,percent);\r
9897      fprintf ( stderr, "\tn_seq.........: %d\n"  ,NS->nseq);\r
9898      fprintf ( stderr, "\treduction.....: %d%% of original set\n"  ,(NS->nseq*100)/S->nseq);\r
9899      \r
9900      return NA;\r
9901    }   \r
9902 float ** get_weight ( Alignment *A, Sequence *S, char *mode)\r
9903 {\r
9904  char *aln_name;\r
9905  char *weight_name;\r
9906  char *seq_name;\r
9907  char command[LONG_STRING];\r
9908  char program[LONG_STRING];\r
9909  float **weight;\r
9910  FILE *fp;\r
9911  int c;\r
9912   \r
9913  if ( !mode || !mode[0] || strm (mode, "msa"))\r
9914       {\r
9915         if ( getenv ( "SEQ2MSA_WEIGHT")==NULL)sprintf (program, "%s",SEQ2MSA_WEIGHT);\r
9916         else sprintf ( program, "%s", (getenv ( "SEQ2MSA_WEIGHT")));   \r
9917       }\r
9918  else if ( strm(mode, "pwsim") ||strm(mode, "pwsim_fragment") )\r
9919       {\r
9920         return seq2pwsim (A, S, mode);\r
9921       }\r
9922  else\r
9923      {\r
9924        if (getenv (mode))sprintf ( program, "%s", (getenv (mode)));\r
9925        else fprintf ( stderr, "\nERROR: %s is not a valid mode for weight computation [FATAL:%s]", mode, PROGRAM);\r
9926      }\r
9927 \r
9928  /*MSA weights*/\r
9929  seq_name=vtmpnam(NULL);\r
9930  aln_name=vtmpnam(NULL);\r
9931  weight_name=vtmpnam(NULL);\r
9932  weight=declare_float (S->nseq+1, 2);\r
9933  \r
9934 \r
9935   \r
9936   if (A)\r
9937     {\r
9938       output_clustal_aln (seq_name,A);\r
9939       output_fasta_seq   (aln_name,A);\r
9940       sprintf ( command, "%s %s -i %s -w %s", program, seq_name, aln_name, weight_name);\r
9941     }\r
9942   else\r
9943     {\r
9944       A=seq2aln(S,A,1);\r
9945       output_fasta_seq   (seq_name,A);\r
9946       sprintf ( command, "%s %s -w %s", program, seq_name, weight_name);\r
9947     }\r
9948   \r
9949  \r
9950   my_system ( command);\r
9951   \r
9952   fp=vfopen( weight_name, "r");\r
9953   while ( (c=fgetc(fp))!='$');\r
9954   c=fgetc(fp);\r
9955   c=0;\r
9956   while ( (fscanf (fp, "%*s %f\n",&(weight[c][1])))==1)\r
9957     {weight[c][0]=c;c++;}\r
9958   vfclose (fp);\r
9959   \r
9960   \r
9961   return weight;\r
9962 }\r
9963 \r
9964 float **seq2pwsim (        Alignment *A, Sequence *S, char *mode)\r
9965 {\r
9966   int a, b, c;\r
9967   float d,t;\r
9968   float  **W;\r
9969   Alignment *B;\r
9970   W=declare_float (S->nseq, S->nseq);\r
9971 \r
9972 \r
9973 \r
9974   for (a=0; a< S->nseq; a++)\r
9975         for ( b=a; b<S->nseq; b++)\r
9976           {\r
9977             if ( a==b){d=1;}\r
9978             else if (!A)\r
9979               {\r
9980 \r
9981                 B=align_two_sequences ((S)->seq[a], (S)->seq[b],"pam250mt", -10, -1, "fasta_pair_wise");\r
9982                 for (t=0,d=0,c=0; c<B->len_aln; c++)\r
9983                   {\r
9984                     d+=(B->seq_al[0][c]==B->seq_al[1][c] && !is_gap(B->seq_al[0][c]));\r
9985                     t+=(!is_gap(B->seq_al[0][c]) && !is_gap(B->seq_al[1][c]));\r
9986                   }\r
9987                 t=(strm ( mode, "pwsim_fragment"))?B->len_aln:t;\r
9988                 \r
9989                 d=d/((t==0)?1:t);\r
9990                 free_aln(B);\r
9991               }\r
9992             else\r
9993               {\r
9994                 for (t=0,d=0,c=0; c<A->len_aln; c++)\r
9995                   {\r
9996                     d+=(A->seq_al[a][c]==A->seq_al[b][c] && !is_gap(A->seq_al[a][c]));\r
9997                     t+=(!is_gap(A->seq_al[a][c]) && !is_gap(A->seq_al[b][c]));\r
9998                   }\r
9999                 d=d/((t==0)?1:t);\r
10000               }\r
10001           \r
10002 \r
10003             W[a][b]=W[b][a]=(1-d)*100;\r
10004           }\r
10005  \r
10006   \r
10007   return W;\r
10008 \r
10009 }\r
10010  \r
10011 float **seq2pwsim_fragment (       Alignment *A, Sequence *S, char *mode)\r
10012 {\r
10013 \r
10014   \r
10015   int a, b, c;\r
10016   float d,t;\r
10017   float  **W;\r
10018   Alignment *B;\r
10019   W=declare_float (S->nseq, S->nseq);\r
10020 \r
10021 \r
10022 \r
10023 \r
10024   for (a=0; a< S->nseq; a++)\r
10025         for ( b=a; b<S->nseq; b++)\r
10026           {\r
10027             if ( a==b){d=1;}\r
10028             else if (!A)\r
10029               {\r
10030 \r
10031                 B=align_two_sequences ((S)->seq[a], (S)->seq[b],"pam250mt", -10, -1, "fasta_pair_wise");\r
10032                 for (t=0,d=0,c=0; c<B->len_aln; c++)\r
10033                   {\r
10034                     d+=(B->seq_al[0][c]==B->seq_al[1][c] && !is_gap(B->seq_al[0][c]));\r
10035                     t+=(!is_gap(B->seq_al[0][c]) && !is_gap(B->seq_al[1][c]));\r
10036                   }\r
10037         \r
10038                 d=d/((t==0)?1:t);\r
10039                 free_aln(B);\r
10040               }\r
10041             else\r
10042               {\r
10043                 for (t=0,d=0,c=0; c<A->len_aln; c++)\r
10044                   {\r
10045                     d+=(A->seq_al[a][c]==A->seq_al[b][c] && !is_gap(A->seq_al[a][c]));\r
10046                     t+=(!is_gap(A->seq_al[a][c]) && !is_gap(A->seq_al[b][c]));\r
10047                   }\r
10048                 d=d/((t==0)?1:t);\r
10049               }\r
10050           \r
10051 \r
10052             W[a][b]=W[b][a]=(1-d)*100;\r
10053           }\r
10054  \r
10055   \r
10056   return W;\r
10057 \r
10058 } \r
10059 \r
10060 /********************************************************************/\r
10061 /*                                                                  */\r
10062 /*                      AMINO ACID FUNCTIONS                        */\r
10063 /*                                                                  */\r
10064 /*                                                                  */\r
10065 /*                                                                  */\r
10066 /********************************************************************/\r
10067 //Builds an extended alphabet from a string\r
10068 char** string2alphabet (char *string, int depth, int *falp_size)\r
10069 {\r
10070   int max_s;\r
10071   int a, b,c, l, n;\r
10072   char buf[1000];\r
10073   char **alp;\r
10074   int alp_size;\r
10075   \r
10076   char ***alp2;\r
10077   int *alp2_size;\r
10078   \r
10079   int *array;\r
10080   char **falp;\r
10081   \r
10082   \r
10083   l=strlen (string);\r
10084   array=vcalloc ( 256, sizeof (int));\r
10085   \r
10086 \r
10087   max_s=l+1;\r
10088   falp_size[0]=0;\r
10089   falp=declare_char (l+1, 2);\r
10090   \r
10091   alp=declare_char(l,2);\r
10092   alp_size=0;\r
10093   \r
10094   array=vcalloc ( 256, sizeof (int));\r
10095   for (a=0;a<l; a++)\r
10096     {\r
10097       if (!array[(int)string[a]])\r
10098         {\r
10099           array[(int)string[a]]=1;\r
10100           sprintf (alp[alp_size++], "%c", string[a]);\r
10101           sprintf (falp[falp_size[0]++], "%c", string[a]);\r
10102         }\r
10103     }\r
10104   sprintf ( falp[falp_size[0]++], "*");\r
10105   vfree (array);\r
10106   \r
10107   if ( depth==1)\r
10108     {\r
10109       free_char (alp, -1);\r
10110       return falp;\r
10111     }\r
10112   alp2=vcalloc ( depth, sizeof (char**));\r
10113   alp2_size=vcalloc (depth, sizeof (int));\r
10114   \r
10115   for (a=0; a<depth; a++)\r
10116     {\r
10117       alp2[a]=alp;\r
10118       alp2_size[a]=alp_size;\r
10119     }\r
10120   \r
10121 \r
10122   for (a=2; a<=depth; a++)\r
10123     {\r
10124       char ***result_array;\r
10125       \r
10126       result_array=generate_array_string_list (a, alp2, alp2_size, &n, NULL, NO_OVERLAP);\r
10127       max_s+=n+1;\r
10128       falp=vrealloc (falp, sizeof (char**)*max_s);\r
10129       for (b=0; b<n; b++)\r
10130         {\r
10131           buf[0]='\0';\r
10132           for (c=0; c<a; c++)\r
10133             {\r
10134               strcat (buf, result_array[b][c]);\r
10135             }\r
10136           falp[falp_size[0]]=vcalloc (strlen (buf)+1, sizeof (char));\r
10137           sprintf ( falp[falp_size[0]++], "%s", buf);\r
10138           vfree ( result_array[b]);\r
10139         }\r
10140       vfree (result_array);\r
10141       \r
10142     }\r
10143 \r
10144   falp[falp_size[0]]=vcalloc (2, sizeof (char));\r
10145   sprintf ( falp[falp_size[0]++], "*");\r
10146   free_char (alp, -1);\r
10147   return falp;\r
10148 }\r
10149 \r
10150 char** make_group_aa (int *ngroup, char *mode)\r
10151         {\r
10152 /*mode:         indicates which matrix will be used for the grouping*/\r
10153 /*n_group:      pointer to the number of groups                     */\r
10154 /*return value: an array of strings containing the AA of each group */\r
10155 \r
10156 \r
10157         int **matrix;\r
10158         int a, b,c,is_in;\r
10159         char buf[28];\r
10160         char **group_list;\r
10161         char *matrix_name;\r
10162         int extend=0;\r
10163         matrix_name=vcalloc ( 100, sizeof (char));\r
10164 \r
10165         if (ngroup[0]==-1)extend=1;\r
10166         \r
10167         ngroup[0]=0;\r
10168         group_list=declare_char ( 100, 27);\r
10169         \r
10170         if (extend)\r
10171           {\r
10172             sprintf ( group_list[ngroup[0]++], "gG");\r
10173             sprintf ( group_list[ngroup[0]++], "pP");\r
10174             sprintf ( group_list[ngroup[0]++], "aA");\r
10175             sprintf ( group_list[ngroup[0]++], "cC");\r
10176             sprintf ( group_list[ngroup[0]++], "dD");\r
10177             sprintf ( group_list[ngroup[0]++], "eE");\r
10178             \r
10179             sprintf ( group_list[ngroup[0]++], "fF"); \r
10180             sprintf ( group_list[ngroup[0]++], "hH");\r
10181             sprintf ( group_list[ngroup[0]++], "iI");\r
10182             sprintf ( group_list[ngroup[0]++], "kK");\r
10183             sprintf ( group_list[ngroup[0]++], "lL");\r
10184             sprintf ( group_list[ngroup[0]++], "mM");\r
10185             sprintf ( group_list[ngroup[0]++], "nN");\r
10186             sprintf ( group_list[ngroup[0]++], "qQ");\r
10187             sprintf ( group_list[ngroup[0]++], "rR");\r
10188             \r
10189             sprintf ( group_list[ngroup[0]++], "sS");\r
10190             sprintf ( group_list[ngroup[0]++], "tT");\r
10191             sprintf ( group_list[ngroup[0]++], "vV");\r
10192             sprintf ( group_list[ngroup[0]++], "wW");\r
10193             sprintf ( group_list[ngroup[0]++], "*");\r
10194           }\r
10195         \r
10196         if ( mode && mode[0]=='_'){mode++;sprintf ( matrix_name, "%s", mode);}\r
10197 \r
10198         if (mode==NULL || mode[0]=='\0')sprintf ( matrix_name, "idmat");\r
10199         else if ( strstr (mode, "sim") || strm (mode, "idmat") || mode==NULL)\r
10200           { \r
10201             sprintf ( group_list[ngroup[0]++], "aA");\r
10202             sprintf ( group_list[ngroup[0]++], "bB");\r
10203             sprintf ( group_list[ngroup[0]++], "cC");\r
10204             sprintf ( group_list[ngroup[0]++], "dD");\r
10205             sprintf ( group_list[ngroup[0]++], "eE");\r
10206             sprintf ( group_list[ngroup[0]++], "fF");\r
10207             sprintf ( group_list[ngroup[0]++], "gG");\r
10208             sprintf ( group_list[ngroup[0]++], "hH");\r
10209             sprintf ( group_list[ngroup[0]++], "iI");\r
10210             sprintf ( group_list[ngroup[0]++], "jJ");\r
10211             sprintf ( group_list[ngroup[0]++], "kK");\r
10212             sprintf ( group_list[ngroup[0]++], "lL");\r
10213             sprintf ( group_list[ngroup[0]++], "mM");\r
10214             sprintf ( group_list[ngroup[0]++], "nN");\r
10215             sprintf ( group_list[ngroup[0]++], "oO");\r
10216             sprintf ( group_list[ngroup[0]++], "pP");\r
10217             sprintf ( group_list[ngroup[0]++], "qQ");\r
10218             sprintf ( group_list[ngroup[0]++], "rR");\r
10219             sprintf ( group_list[ngroup[0]++], "sS");\r
10220             sprintf ( group_list[ngroup[0]++], "tT");\r
10221             sprintf ( group_list[ngroup[0]++], "uU");\r
10222             sprintf ( group_list[ngroup[0]++], "vV");\r
10223             sprintf ( group_list[ngroup[0]++], "wW");\r
10224             sprintf ( group_list[ngroup[0]++], "xX");\r
10225             sprintf ( group_list[ngroup[0]++], "yY");\r
10226             sprintf ( group_list[ngroup[0]++], "zZ");\r
10227             vfree (matrix_name);\r
10228             return group_list;\r
10229           }\r
10230         else if ( strm (mode, "simple"))\r
10231              {\r
10232                sprintf ( group_list[ngroup[0]++], "avilmAVILM");\r
10233                  sprintf ( group_list[ngroup[0]++], "dekrDEKR");\r
10234                  sprintf ( group_list[ngroup[0]++], "stcnqhSTCNQH");\r
10235                  sprintf ( group_list[ngroup[0]++], "wfyWFY");\r
10236                  sprintf ( group_list[ngroup[0]++], "gG");\r
10237                  sprintf ( group_list[ngroup[0]++], "pP");\r
10238                  vfree (matrix_name);\r
10239                  return group_list;\r
10240              }\r
10241 \r
10242         else if ( strm (mode, "mafft"))\r
10243              {\r
10244                 \r
10245                \r
10246                sprintf ( group_list[ngroup[0]++],"agjopstAGJOPST");\r
10247                sprintf ( group_list[ngroup[0]++],"ilmvILMV");\r
10248                sprintf ( group_list[ngroup[0]++],"bdenqzBDENQZ");\r
10249                sprintf ( group_list[ngroup[0]++],"hkrHKR");\r
10250                sprintf ( group_list[ngroup[0]++],"fwyFWY");\r
10251                sprintf ( group_list[ngroup[0]++],"cC");\r
10252                vfree (matrix_name);\r
10253                return group_list;\r
10254              }\r
10255         else if ( strm (mode, "clustalw"))\r
10256              {\r
10257                  \r
10258                  sprintf ( group_list[ngroup[0]++],"astaASTA");\r
10259                  sprintf ( group_list[ngroup[0]++],"bneqkBNEQK");\r
10260                  sprintf ( group_list[ngroup[0]++],"cnhqkCNHQK");\r
10261                  sprintf ( group_list[ngroup[0]++],"dndeqDNDEQ");\r
10262                  sprintf ( group_list[ngroup[0]++],"eqhrkEQHRK");\r
10263                  sprintf ( group_list[ngroup[0]++],"fmilvFMILV");\r
10264                  sprintf ( group_list[ngroup[0]++],"gmilfGMILF");\r
10265                  sprintf ( group_list[ngroup[0]++],"hhyHHY");\r
10266                  sprintf ( group_list[ngroup[0]++],"ifywIFYW");\r
10267                  sprintf ( group_list[ngroup[0]++],"jcJC");\r
10268                  sprintf ( group_list[ngroup[0]++],"kpKP");\r
10269                  vfree (matrix_name);\r
10270                  return group_list;\r
10271              }\r
10272         else if ( strm (mode, "polarity"))\r
10273              {\r
10274                  \r
10275                sprintf ( group_list[ngroup[0]++],"eqrsdnkhtEQRSDNKHT");\r
10276                sprintf ( group_list[ngroup[0]++],"pP");\r
10277                sprintf ( group_list[ngroup[0]++],"gG");\r
10278                sprintf ( group_list[ngroup[0]++],"cC");\r
10279                sprintf ( group_list[ngroup[0]++],"fywFYW");\r
10280                sprintf ( group_list[ngroup[0]++],"iavlmIAVLM");\r
10281                vfree (matrix_name);\r
10282                return group_list;\r
10283              }\r
10284         else if ( strm (mode, "vasiliky"))\r
10285              {\r
10286                  ngroup[0]=0;\r
10287                  sprintf ( group_list[ngroup[0]++], "rkRK");\r
10288                  sprintf ( group_list[ngroup[0]++], "deDE");\r
10289                  sprintf ( group_list[ngroup[0]++], "qhQH");\r
10290                  sprintf ( group_list[ngroup[0]++], "vilmVILM");\r
10291                  sprintf ( group_list[ngroup[0]++], "fyFY");\r
10292                  sprintf ( group_list[ngroup[0]++], "sS");\r
10293                  sprintf ( group_list[ngroup[0]++], "wW");\r
10294                  sprintf ( group_list[ngroup[0]++], "aA");\r
10295                  sprintf ( group_list[ngroup[0]++], "cC");\r
10296                  sprintf ( group_list[ngroup[0]++], "gG");\r
10297                  sprintf ( group_list[ngroup[0]++], "nN");\r
10298                  sprintf ( group_list[ngroup[0]++], "pP");\r
10299                  sprintf ( group_list[ngroup[0]++], "tT");\r
10300                  vfree (matrix_name);\r
10301                  return group_list;\r
10302              }\r
10303         else if ( strm (mode, "clustalw_col"))\r
10304              {\r
10305                  sprintf ( group_list[ngroup[0]++], "staSTA");\r
10306                  sprintf ( group_list[ngroup[0]++], "neqkNEQK");\r
10307                  sprintf ( group_list[ngroup[0]++], "nhqkNHQK");\r
10308                  sprintf ( group_list[ngroup[0]++], "ndeqNDEQ");\r
10309                  sprintf ( group_list[ngroup[0]++], "qhrkQHRK");\r
10310                  sprintf ( group_list[ngroup[0]++], "milvMILV");\r
10311                  sprintf ( group_list[ngroup[0]++], "milfMILF");\r
10312                  sprintf ( group_list[ngroup[0]++], "hyHY");\r
10313                  sprintf ( group_list[ngroup[0]++], "fywFYW");\r
10314                  sprintf ( group_list[ngroup[0]++], "gG");\r
10315                  sprintf ( group_list[ngroup[0]++], "pP");\r
10316                  sprintf ( group_list[ngroup[0]++], "cC");\r
10317                  vfree (matrix_name);\r
10318                  \r
10319                  return group_list;\r
10320              }\r
10321         else if ( strm (mode, "clustalw_dot"))\r
10322              {\r
10323                  sprintf ( group_list[ngroup[0]++], "csaCSA");\r
10324                  sprintf ( group_list[ngroup[0]++], "atvATV");\r
10325                  sprintf ( group_list[ngroup[0]++], "sagSAG");\r
10326                  sprintf ( group_list[ngroup[0]++], "stnkSTNK");\r
10327                  sprintf ( group_list[ngroup[0]++], "stpaSTPA");\r
10328                  sprintf ( group_list[ngroup[0]++], "sgndSGND");\r
10329                  sprintf ( group_list[ngroup[0]++], "sndeqkSNDEQK");\r
10330                  sprintf ( group_list[ngroup[0]++], "ndeqhkNDEQHK");\r
10331                  sprintf ( group_list[ngroup[0]++], "neqhrkNEQHRK");\r
10332                  sprintf ( group_list[ngroup[0]++], "fvlimFVLIM");\r
10333                  sprintf ( group_list[ngroup[0]++], "hfyHFY");\r
10334                  vfree (matrix_name);\r
10335                  return group_list;\r
10336              }\r
10337         else if ( strm (mode, "make_all"))\r
10338              {\r
10339                  ngroup[0]=1;\r
10340                  sprintf ( group_list[0], "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz");\r
10341                  vfree (matrix_name);\r
10342                  return group_list;\r
10343              }\r
10344         else sprintf ( matrix_name, "%s", mode);\r
10345         \r
10346         matrix=read_matrice ( matrix_name); \r
10347         \r
10348         for ( a=0;a< 26; a++)\r
10349                 {\r
10350                 if ( matrix[a][a]>0)\r
10351                         {\r
10352                         for ( c=0,b=0;b< 26; b++)\r
10353                                 {\r
10354                                 \r
10355                                 if ( matrix[a][b]>0 && matrix[b][b]>0)\r
10356                                         {\r
10357                                         buf[c++]=b+'A';\r
10358                                         buf[c++]=b+'a';\r
10359                                         }\r
10360                                 }\r
10361                         buf[c]='\0';\r
10362                         for ( is_in=0,b=0; b< ngroup[0]; b++)if ( strcmp (buf, group_list[b])==0)is_in=1;\r
10363                         if (is_in==0)sprintf ( group_list[ngroup[0]++], "%s", buf);\r
10364                                         \r
10365                         }\r
10366                 }\r
10367         free_int (matrix, -1); \r
10368         vfree (matrix_name);\r
10369                  \r
10370         return group_list;\r
10371         }\r
10372 char** make_group_aa_upgma (char*matrix, int max_n)\r
10373         {\r
10374           char **group_list;\r
10375           int **mat;\r
10376           int *used;\r
10377           int a, b, ba, bb, best, set, l, n;\r
10378           l=26;\r
10379           \r
10380           group_list=declare_char (l+1, l+1);\r
10381           for (a=0; a<l; a++)group_list[a][0]='a'+a;\r
10382           mat=read_matrice(matrix);\r
10383           used=vcalloc ( l, sizeof (int));\r
10384           n=l;\r
10385                   \r
10386           while (n>max_n)\r
10387             {\r
10388               for (set=0,a=0; a<l-1; a++)\r
10389                 for (b=a+1; b<l; b++)\r
10390                   {\r
10391                     if (used[a]||used[b])continue;\r
10392                     \r
10393                     if (set==0 || mat[a][b]>best)\r
10394                       {\r
10395                         best=mat[a][b];\r
10396                         ba=a;\r
10397                         bb=b;\r
10398                         set=1;\r
10399                       }\r
10400                   }\r
10401             \r
10402               for (a=0; a<l; a++)\r
10403                 {\r
10404                   mat[ba][a]=mat[a][ba]=(mat [ba][a]+mat[bb][a])/2;\r
10405                   used[bb]=1;\r
10406                 }\r
10407               strcat (group_list[ba], group_list[bb]);\r
10408               vfree (group_list[bb]);\r
10409               group_list[bb]=NULL;\r
10410           \r
10411               n--;\r
10412             }\r
10413         \r
10414           for (n=0,a=0; a<l; a++)\r
10415             {\r
10416               if ( group_list[a])\r
10417                 group_list[n++]=group_list[a];\r
10418             }\r
10419           vfree (used); free_int (mat, -1);\r
10420           return group_list;\r
10421         }\r
10422 \r
10423 int find_group_aa_distribution (char *col, int nseq,int n_group, char **gl,  int *distrib, char *mode )\r
10424         {\r
10425         static int *distribution;\r
10426         static char **lgl;\r
10427         static int ln_group;\r
10428         int a, b, c;\r
10429         int *d;\r
10430         char **gl2;\r
10431         int n_group2;\r
10432         \r
10433         \r
10434         \r
10435         if ( lgl==NULL)\r
10436                 lgl=make_group_aa ( &ln_group, mode);\r
10437                 \r
10438                 if ( gl==NULL)\r
10439                 {\r
10440                 gl2=lgl;\r
10441                 n_group2=ln_group;\r
10442                 }\r
10443         else\r
10444                 {\r
10445                 gl2=gl;\r
10446                 n_group2=n_group;\r
10447                 }\r
10448         \r
10449         if ( distribution==NULL || ln_group<n_group)distribution=vcalloc ( n_group2, sizeof (int));\r
10450         if ( distrib==NULL)d=distribution;\r
10451         else d=distrib;\r
10452         \r
10453         \r
10454         for ( a=0; a< n_group2; a++)d[a]=0;\r
10455         \r
10456         for ( a=0; a< nseq; a++)\r
10457                 {\r
10458                 for ( b=0; b< n_group2; b++)\r
10459                         d[b]+=is_in_set (col[a], gl2[b]);\r
10460                 }\r
10461         c=d[0];\r
10462         for ( a=0; a< n_group2; a++)\r
10463                 c=(d[a]>c)?d[a]:c;\r
10464         return c;\r
10465         }\r
10466 \r
10467 \r
10468 \r
10469 int is_in_same_group_aa ( char r1, char r2, int n_group, char **gl, char *mode)\r
10470         {\r
10471         int a;\r
10472         static char **lgl;\r
10473         static int ln_group;\r
10474         \r
10475         char **gl2;\r
10476         int n_group2;\r
10477         \r
10478         /*use mode=idmat for similarity based on id*/\r
10479 \r
10480         r1=toupper(r1);\r
10481         r2=toupper(r2);\r
10482         if (mode==NULL)return (r1==r2)?1:0;\r
10483         \r
10484         if ( strm (mode, "clean"))\r
10485              {\r
10486              free_char (lgl, -1);\r
10487              lgl=NULL;\r
10488              ln_group=0;\r
10489              return 0;\r
10490              }\r
10491         else if ( strstr (mode, "cov"))\r
10492           {\r
10493             return 1;\r
10494           }\r
10495         \r
10496         if ( lgl==NULL)\r
10497                 {\r
10498                   lgl=make_group_aa ( &ln_group, mode);\r
10499                 }\r
10500                 \r
10501         if ( gl==NULL)\r
10502                 {\r
10503                 gl2=lgl;\r
10504                 n_group2=ln_group;\r
10505                 }\r
10506         else\r
10507                 {\r
10508                 gl2=gl;\r
10509                 n_group2=n_group;\r
10510                 }\r
10511         \r
10512         for ( a=0; a< n_group2; a++)\r
10513                 if ( is_in_set ( r1, gl2[a]) && is_in_set ( r2, gl2[a]))return 1;\r
10514                 return 0;\r
10515         }\r
10516                         \r
10517 \r
10518 Alignment * gene2prot (Alignment *A){return A; }\r
10519 char * test_gene2prot (Constraint_list *CL, int s1)\r
10520        {\r
10521            int a, b,q, nal;\r
10522            int F=-10000000; /*FORBIDEN STATE*/\r
10523            int AL=0;       /*ALLOWED STATE*/\r
10524            int SPLICE_PENALTY=1000;\r
10525            int FRAME_PENALTY=1000;\r
10526            \r
10527 \r
10528            int START,  ORF1,  ORF2, ORF3, s5NC; \r
10529            int s3NC,ORF3_G1, ORF3_T2, ORF3_NC, ORF3_A3, ORF3_T4;\r
10530            int U1_G1,   U1_T2,   U1_NC,   U1_A3,   U1_T4;\r
10531            int U2_G1,   U2_T2,   U2_NC,   U2_A3,   U2_T4;\r
10532            int U1,     U2, U3,  U4, U5, END;\r
10533            \r
10534            int nstate=0;\r
10535            int **transitions;\r
10536            int **v_tab;\r
10537            int **v_tab_p;\r
10538            int **last_coding;\r
10539            int **last_t4;\r
10540            int *potential;\r
10541            int v;\r
10542 \r
10543            int orf1, orf2, orf3, ncp, p, state, pstate, e, best_state_p=0, best_state_v=0, best_pstate_p=0, best_pstate_v;\r
10544            char *seq, *seq2, *seq3;\r
10545            int l;\r
10546            int  *is_coding;\r
10547            int *is_t4;\r
10548            char *codon;\r
10549 \r
10550            static int *entry;\r
10551            int tot=0;\r
10552            \r
10553            seq=vcalloc ( strlen ((CL->S)->seq[s1])+1, sizeof (char));\r
10554            seq2=vcalloc ( strlen ((CL->S)->seq[s1])+1, sizeof (char));\r
10555            seq3=vcalloc ( strlen ((CL->S)->seq[s1])+1, sizeof (char));\r
10556            sprintf ( seq, "%s", (CL->S)->seq[s1]);\r
10557            ungap (seq);\r
10558 \r
10559            l=strlen (seq);\r
10560            for ( a=0; a< l; a++) seq[a]=tolower ( seq[a]);\r
10561            for ( a=0; a< l; a++) seq[a]=(seq[a]=='t')?'u': seq[a];\r
10562            \r
10563 \r
10564            potential=vcalloc (l+1, sizeof (int));\r
10565            CL=index_constraint_list ( CL);\r
10566            for (nal=0, a=0; a<(CL->S)->nseq; a++)\r
10567                for ( b=CL->start_index[s1][a]; b< CL->end_index[s1][a];b++)\r
10568                    {\r
10569                        entry=extract_entry(entry, b, CL);\r
10570                        if ( entry[SEQ1]==s1)potential[entry[R1]-1]+=entry[WE];\r
10571                        else if (  entry[SEQ2]==s1)potential[entry[R2]-1]+=entry[WE];\r
10572                        tot+=entry[WE];\r
10573                        nal++;\r
10574                    }\r
10575 \r
10576 \r
10577            SPLICE_PENALTY=10000;\r
10578            FRAME_PENALTY=1000;\r
10579 \r
10580            \r
10581            nstate=0;\r
10582            START=nstate++;  ORF1=nstate++;  ORF2=nstate++; ORF3=nstate++; s5NC=nstate++; \r
10583            s3NC=nstate++;\r
10584            ORF3_G1=nstate++;U1_G1=nstate++;U2_G1=nstate++; \r
10585            ORF3_T2=nstate++;U1_T2=nstate++;U2_T2=nstate++;\r
10586            ORF3_NC=nstate++;U1_NC=nstate++;U2_NC=nstate++; \r
10587            ORF3_A3=nstate++;U1_A3=nstate++;U2_A3=nstate++; \r
10588            ORF3_T4=nstate++;U1_T4=nstate++;U2_T4=nstate++;\r
10589            \r
10590            \r
10591            U1=nstate++;     U2=nstate++; U3=nstate++;  U4=nstate++; U5=nstate++;  \r
10592            END=nstate++;\r
10593            \r
10594            is_coding=vcalloc ( nstate, sizeof (int));\r
10595            is_coding[ORF1]=is_coding[ORF2]=is_coding[ORF3]=is_coding[U1]=is_coding[U2]=1;\r
10596            is_coding[U3]=is_coding[U4]=is_coding[U5]=1;\r
10597            \r
10598            is_t4=vcalloc ( nstate, sizeof (int));\r
10599            is_t4[ORF3_T4]=is_t4[U1_T4]=is_t4[U2_T4]=1;\r
10600            transitions=declare_int ( nstate, nstate);\r
10601            for (a=0; a< nstate; a++)\r
10602                    for ( b=0; b< nstate; b++)transitions[a][b]=F;\r
10603            \r
10604            transitions[START][ORF1]=AL;\r
10605            transitions[START][s5NC]=AL-FRAME_PENALTY;\r
10606            transitions[s5NC][s5NC]=AL;\r
10607 \r
10608            transitions[s5NC][ORF1]=AL-FRAME_PENALTY;\r
10609 \r
10610            transitions[ORF1][ORF2]=AL;\r
10611            transitions[ORF2][ORF3]=AL;\r
10612            transitions[ORF3][U1]=AL;\r
10613            transitions[ORF3][ORF1]=AL;\r
10614            transitions[ORF3][ORF3_G1]=AL-SPLICE_PENALTY;\r
10615            \r
10616            \r
10617            transitions[ORF3_G1][ORF3_T2]=AL;\r
10618            transitions[ORF3_T2][ORF3_NC]=AL;\r
10619            transitions[ORF3_NC][ORF3_NC]=AL;\r
10620            transitions[ORF3_NC][ORF3_A3]=AL;\r
10621            transitions[ORF3_A3][ORF3_T4]=AL;\r
10622            transitions[ORF3_T4][ORF1]=AL-SPLICE_PENALTY;\r
10623 \r
10624            transitions[U1][U2]=AL;\r
10625            transitions[U1][U1_G1]=AL-SPLICE_PENALTY;\r
10626            transitions[U1_G1][U1_T2]=AL;\r
10627            transitions[U1_T2][U1_NC]=AL;\r
10628            transitions[U1_NC][U1_NC]=AL;\r
10629            transitions[U1_NC][U1_A3]=AL;\r
10630            transitions[U1_A3][U1_T4]=AL;\r
10631            transitions[U1_T4][U3]=AL-SPLICE_PENALTY;\r
10632            transitions[U3][U4]=AL;\r
10633            transitions[U4][ORF1]=AL;\r
10634            \r
10635            transitions[U2][U2_G1]=AL-SPLICE_PENALTY;\r
10636            transitions[U2_G1][U2_T2]=AL;\r
10637            transitions[U2_T2][U2_NC]=AL;\r
10638            transitions[U2_NC][U2_NC]=AL;\r
10639            transitions[U2_NC][U2_A3]=AL;\r
10640            transitions[U2_A3][U2_T4]=AL;\r
10641            transitions[U2_T4][U5]=AL-SPLICE_PENALTY;\r
10642            transitions[U5][ORF1]=AL;\r
10643            \r
10644            transitions[ORF3][s3NC]=AL-FRAME_PENALTY;\r
10645            transitions[ORF3][END]=AL;\r
10646            transitions[s3NC][END]=AL;\r
10647 \r
10648                    \r
10649            v_tab=declare_int ( l+1,nstate);\r
10650            v_tab_p=declare_int ( l+1,nstate);\r
10651            last_coding=declare_int ( l+1,nstate);\r
10652            last_t4=declare_int ( l+1,nstate);\r
10653 \r
10654            for (a=0; a< l; a++) potential[a]-=200;\r
10655 \r
10656            codon=vcalloc ( 4, sizeof (char));\r
10657            best_pstate_p=START;\r
10658            best_pstate_v=0;\r
10659            nal=0;\r
10660            for ( p=1; p<=l; p++)\r
10661                {\r
10662                if  (translate_dna_codon (seq+(p-1), 'x')=='x' || p>(l-2))orf1=F;\r
10663                else orf1=potential[p-1];\r
10664 \r
10665                if  (p<2 || translate_dna_codon (seq+(p-2), 'x')=='x' || p>(l-1))orf2=F;\r
10666                else orf2=potential[p-1];\r
10667 \r
10668                \r
10669                if  (p<3 || translate_dna_codon (seq+(p-3), 'x')=='x' || p>l)orf3=F;\r
10670                else orf3=potential[p-1];\r
10671                \r
10672                if ( best_int (3, 1, &a, orf1, orf2, orf3)!=F)ncp=-best_int (3, 1, &a, orf1, orf2, orf3);\r
10673                else ncp=1000;\r
10674                \r
10675                for ( state=0; state< nstate; state++)\r
10676                    {\r
10677                        \r
10678                        if      ( state==ORF1)e=orf1;\r
10679                        else if ( state==ORF2)e=orf2;\r
10680                        else if ( state==ORF3)e=orf3;\r
10681                        else if ( state>=U1 && state<=U3)\r
10682                            {\r
10683                            e=0;\r
10684                            }\r
10685                        else if ( state==U4)\r
10686                           {\r
10687                               codon[2]=seq[p-1];\r
10688                               codon[1]=seq[last_coding[p-1][U3]-1];\r
10689                               codon[0]=seq[last_coding[p-2][U1_T4]-1];\r
10690                               if ( translate_dna_codon (codon, 'x')=='x')e=F;\r
10691                               else e=0;\r
10692                           }\r
10693                        else if ( state==U5)\r
10694                           {\r
10695                               codon[2]=seq[p-1];\r
10696                               codon[1]=seq[last_coding[p-1][U2_T4]-1];\r
10697                               q=seq[last_coding[p-1][U2_T4]];\r
10698                               codon[0]=seq[last_coding[q-1][U1]-1];\r
10699                               if ( translate_dna_codon (codon, 'x')=='x')e=F;\r
10700                               else e=0;\r
10701                           }\r
10702 \r
10703                        else if (state>=ORF3_G1 && state<=U2_G1)e=(p<l-1 && seq[p-1]=='g' && seq[p]=='u')?ncp:F;\r
10704                        else if ( state>=ORF3_T2 && state<=U2_T2)\r
10705                            {\r
10706                            e=(p>1 && seq[p-2]=='g' && seq[p-1]=='u')?ncp:F;\r
10707                            }\r
10708                        else if ( state>=ORF3_A3 && state<=U2_A3)e=(seq[p-1]=='a')?ncp:F;\r
10709                        else if ( state>=ORF3_T4 && state<=U2_T4)e=(seq[p-1]=='u')?ncp:F;\r
10710                        else e=ncp;\r
10711                        \r
10712                        for ( pstate=0; pstate<nstate; pstate++)\r
10713                            {\r
10714                                if (e==F ||  transitions[pstate][state]==F || v_tab[p-1][pstate]==F)v=F;\r
10715                                else v=e+transitions[pstate][state]+v_tab[p-1][pstate];\r
10716                                     \r
10717                                if ( pstate==0 || v>best_pstate_v)\r
10718                                   {best_pstate_v=v;best_pstate_p=pstate;}\r
10719                            }\r
10720                       v_tab[p][state]=best_pstate_v;\r
10721                       v_tab_p[p][state]=best_pstate_p; \r
10722                       \r
10723                       if (!is_coding[state])last_coding[p][state]=last_coding[p-1][best_pstate_p];\r
10724                       else if (is_coding[state])last_coding[p][state]=p;\r
10725                       \r
10726                       if (!is_t4[state])\r
10727                          {\r
10728                              if (is_coding[state] && last_t4[p-1][best_pstate_p]==0)last_t4[p][state]=p;\r
10729                              else last_t4[p][state]=last_t4[p-1][best_pstate_p];\r
10730                          }\r
10731                       else if (is_t4[state])last_t4[p][state]=p;\r
10732                       \r
10733                       if (state==0 ||best_pstate_v>best_state_v ){best_state_p=state; best_state_v=best_pstate_v;}\r
10734                    }\r
10735                }\r
10736            tot=0;\r
10737            for ( p=l; p>0; p--)\r
10738                    {\r
10739                        if ( best_state_p>=ORF1 &&  best_state_p<=ORF3){seq2[tot++]=tolower (seq[p-1]);}\r
10740                        else if ( best_state_p>=U1 && best_state_p<=U5){seq2[tot++]=tolower (seq[p-1]);}\r
10741                        if (best_state_p==ORF1)seq[p-1]=toupper (seq[p-1]);\r
10742                        else if (best_state_p==ORF2 || best_state_p==ORF3)seq[p-1]=tolower (seq[p-1]);\r
10743                        else if ( best_state_p==ORF3_NC || best_state_p==U1_NC ||  best_state_p==U2_NC) seq[p-1]='.';\r
10744                        else if ( best_state_p==U1 || best_state_p==U2 || best_state_p==U3 || best_state_p==U4 || best_state_p==U5) seq[p-1]=best_state_p-U1+'1';\r
10745                        else seq[p-1]=toupper (seq[p-1]);\r
10746                        best_state_p=v_tab_p[p][best_state_p];\r
10747                    }\r
10748 \r
10749            for ( a=0, b=tot-1; b>=0; b--, a++)\r
10750                seq3[a]=seq2[b];\r
10751            \r
10752            fprintf ( stderr, "\n%s\n", seq);\r
10753            fprintf ( stderr, "\nN coding=%d\n", tot);\r
10754            for ( a=0; a< tot; a+=3)\r
10755                 {\r
10756                 b=translate_dna_codon (seq3+a, 'x');\r
10757                 fprintf ( stderr, "%c",b);\r
10758                 if ( b=='x'){fprintf ( stderr, "\n");myexit (EXIT_SUCCESS);}\r
10759                 }\r
10760             \r
10761             fprintf ( stderr, "\n");      \r
10762             myexit (EXIT_SUCCESS);\r
10763             return 0;\r
10764             \r
10765                \r
10766             \r
10767        }\r
10768 Alignment * dna_aln2_3frame_cdna_aln(Alignment *A,int *ns,int **l_s)\r
10769 {\r
10770   Alignment *B;\r
10771   int a;\r
10772   B=realloc_aln2 (NULL,6,strlen(A->seq_al[l_s[0][0]])+strlen(A->seq_al[l_s[1][0]]));\r
10773   for ( a=0; a< 3; a++)  \r
10774     {    \r
10775       B->seq_al[a]=translate_dna_seq (A->seq_al[l_s[0][0]]+a, 0, 'o',B->seq_al[a]);\r
10776       B->seq_al[a+3]=translate_dna_seq (A->seq_al[l_s[1][0]]+a, 0, 'o',B->seq_al[a+3]);\r
10777     }\r
10778   for ( a=1; a<3; a++)\r
10779     {\r
10780       if ( strlen(B->seq_al[a])<strlen(B->seq_al[0])) B->seq_al[a]=strcat ( B->seq_al[a], "x");\r
10781       if ( strlen(B->seq_al[a+3])<strlen(B->seq_al[3])) B->seq_al[a+3]=strcat ( B->seq_al[a+3], "x");\r
10782     }\r
10783   \r
10784   B->nseq=6;\r
10785   B->len_aln=strlen (B->seq_al[0]);\r
10786   return B;\r
10787 }\r
10788 \r
10789 //JM_ADD\r
10790 //For normal distribution scan\r
10791 #ifndef PI\r
10792 #define PI 3.141592653589793238462643\r
10793 #endif\r
10794 \r
10795 double normal(double x, double mean, double std)\r
10796 {\r
10797         return (1/(std*sqrt(2.0*PI)))*exp((-0.5*(x-mean)*(x-mean))/(std*std));\r
10798 } \r
10799 \r
10800 int ** get_sim_aln_array_normal_distribution ( Alignment *A, char *mode, int *STD, int *CENTER)\r
10801         {\r
10802         int **w;\r
10803         int a, b;\r
10804         \r
10805 \r
10806         w=declare_int ( A->nseq, A->nseq);\r
10807         \r
10808         for ( a=0; a< A->nseq-1; a++)\r
10809           {\r
10810             for ( b=a+1; b< A->nseq; b++)\r
10811               {\r
10812 \r
10813                 w[a][b]=w[b][a]=generic_get_seq_sim_normal_distribution ( A->seq_al[a], A->seq_al[b], (A->cdna_cache)?A->cdna_cache[0]:NULL, mode, STD, CENTER);\r
10814               }\r
10815           }\r
10816         return w;\r
10817         }\r
10818 int generic_get_seq_sim_normal_distribution ( char *seq1, char *seq2, int*cache, char *mode, int *STD, int *CENTER)\r
10819 {\r
10820   return get_seq_sim_distribution ( seq1,seq2,GAP_LIST, mode, STD, CENTER);\r
10821 }\r
10822 \r
10823 int get_seq_sim_distribution ( char *string1, char *string2, char *ignore, char *in_mode, int *STD, int *CENTER)\r
10824         {\r
10825         int len1;\r
10826         int a;\r
10827         int pos0, gap=0;\r
10828         int p1, p2;\r
10829         int r=0,r1=0,r2=0;\r
10830         char *p;\r
10831         char mode[1000];\r
10832 \r
10833         double sim;\r
10834 \r
10835         \r
10836         sprintf ( mode, "%s", in_mode);\r
10837         \r
10838         /*mode: <mat>__<sim_mode>\r
10839           mat: idscore to get the alignment done\r
10840                any legal cw matrix\r
10841           sim_mode: sim1->identities/matches\r
10842                     sim2->identities/min len     \r
10843         */\r
10844 \r
10845         \r
10846         if ( (p=strstr (mode, "_"))!=NULL)\r
10847           {\r
10848             p[0]='\0';\r
10849             p++;\r
10850           }\r
10851 \r
10852             \r
10853         if (strstr (mode, "idscore"))\r
10854           {\r
10855             static int **mat;\r
10856             if (!mat) mat=read_matrice ("blosum62mt");\r
10857             return idscore_pairseq (string1, string2, -12, -1, mat,mode);\r
10858           }\r
10859         \r
10860         len1=strlen (string1);\r
10861         for ( sim=pos0=0,a=0; a< len1; a++)\r
10862                 {\r
10863                   r1=string1[a];\r
10864                   r2=string2[a];\r
10865                   p1=1-is_in_set (r1, ignore);\r
10866                   p2=1-is_in_set (r2, ignore);\r
10867                   if (p1 && p2)\r
10868                         {\r
10869                             pos0++;\r
10870                             if (is_in_same_group_aa(r1,r2,0, NULL, mode))\r
10871                             {                 \r
10872                               sim += normal(a, *CENTER, *STD);\r
10873                             }\r
10874                         }\r
10875                   else if (p1+p2==1)\r
10876                     {\r
10877                       gap++;\r
10878                     }\r
10879                 }\r
10880         \r
10881         if ( p==NULL || strm (p, "sim1") || strm (p, "sim"))\r
10882           {\r
10883             r=(pos0==0)?0:(sim*MAXID);\r
10884           }\r
10885 /*      else if ( strm (p, "sim2"))\r
10886           {\r
10887             r=(pos1==0 || pos2==0)?0:(sim*MAXID)/MIN(pos1,pos2);\r
10888           }\r
10889         else if ( strm (p, "sim3"))\r
10890           {\r
10891             r=(pos1==0 || pos2==0)?0:(sim*MAXID)/MAX(pos1,pos2);\r
10892           }\r
10893         else if ( strm (p, "gap1"))\r
10894           {\r
10895             r=(len1==0)?MAXID:(gap*MAXID)/len1;\r
10896             r=MAXID-r;\r
10897           }\r
10898         else if ( strm (p, "logid"))\r
10899           {\r
10900             r=logid_score (pos0, sim);\r
10901           }*/\r
10902         return r;\r
10903         \r
10904         }       \r
10905 \r
10906 \r
10907 Alignment *aln2clean_pw_aln (Alignment *A, OveralnP *F)// char *mode, int t, int f, int p1,int p2, int p3, char *fsa_mode)\r
10908 {\r
10909   int **C, **T;\r
10910   int a, b, c;\r
10911   Alignment *B;\r
10912   \r
10913   \r
10914   if (F->t==0)F->t=2;\r
10915   \r
10916   C=declare_int ( A->nseq, A->len_aln);\r
10917   T=declare_int ( A->nseq, A->len_aln);\r
10918   B=copy_aln (A, NULL);\r
10919   \r
10920   for (a=0; a< A->nseq;a++)\r
10921     {\r
10922       for (b=0; b<A->nseq; b++)\r
10923         {\r
10924           int *w;\r
10925           w=pw_aln2clean_aln_weight (A->seq_al[a], A->seq_al[b], 1,F);//f,p1, p2, p3, fsa_mode);\r
10926           for (c=0; c<A->len_aln; c++)\r
10927             {\r
10928               if (A->seq_al[a][c]=='-')continue;\r
10929               C[a][c]+=w[c];\r
10930               T[a][c]++;\r
10931             }\r
10932           vfree (w);\r
10933         }\r
10934     }\r
10935   \r
10936   \r
10937   \r
10938   for (a=0; a<A->nseq; a++)\r
10939     {\r
10940       for (b=0; b<A->len_aln; b++)\r
10941         {\r
10942           int c;\r
10943           c=A->seq_al[a][b];\r
10944           if ( c=='-');\r
10945           else if (T[a][b]==0);\r
10946           else\r
10947             {\r
10948               int r;\r
10949               r=(C[a][b]*10)/T[a][b];\r
10950               r=(r==10)?9:r;\r
10951               if (!F->mode || strm (F->mode, "number"))\r
10952                 B->seq_al[a][b]='0'+r;\r
10953               else if ( F->mode && strm (F->mode, "unalign"))\r
10954                 B->seq_al[a][b]='0'+r;\r
10955               else if ( F->mode && strm (F->mode, "lower") )\r
10956                 {\r
10957                   if (r<=F->t)B->seq_al[a][b]=tolower (B->seq_al[a][b]);\r
10958                   else B->seq_al[a][b]=toupper (B->seq_al[a][b]);\r
10959                 }\r
10960             }\r
10961         }\r
10962     }\r
10963 \r
10964   if ( F->mode && strm (F->mode, "unalign"))\r
10965     {\r
10966       A=unalign_aln (A, B, F->t);\r
10967       free_aln (B);\r
10968       B=copy_aln (A, NULL);\r
10969     }\r
10970  \r
10971   free_int (C, -1);\r
10972   free_int (T, -1);\r
10973  \r
10974   return B;\r
10975 }\r
10976         \r
10977 char **pw_aln2clean_pw_aln_fsa1 (char ** aln, OveralnP *F);\r
10978 char **pw_aln2clean_pw_aln_fsa2 (char ** aln, OveralnP *F);\r
10979 \r
10980 int  * pw_aln2clean_aln_weight ( char *seq1, char *seq2, int w, OveralnP *F)\r
10981 {\r
10982   char **aln;\r
10983   int *weight;\r
10984   int l, a;\r
10985     \r
10986   if ( (l=strlen (seq1)) !=strlen (seq2))\r
10987     {\r
10988       HERE ("\n%s\n%s\n", seq1, seq2);\r
10989       printf_exit ( EXIT_FAILURE, stderr, "\nERROR: Comparing unaligned sequences [FATAL:%s]", PROGRAM);\r
10990       \r
10991     }\r
10992 \r
10993   aln=declare_char (2, l+1);\r
10994   sprintf ( aln[0], "%s", seq1);\r
10995   sprintf ( aln[1], "%s", seq2);\r
10996   \r
10997  \r
10998   aln=pw_aln2clean_pw_aln (aln, F);\r
10999   \r
11000   weight=vcalloc (l+1, sizeof (int));\r
11001   for (a=0; a<l; a++)\r
11002     {\r
11003       if ( aln[0][a] || seq1[a]=='x' || seq1[a]=='X' || seq2[a]=='x' || seq2[a]=='X')weight[a]=w;\r
11004     }\r
11005   free_char (aln, -1);\r
11006   \r
11007   return weight;\r
11008 }\r
11009   \r
11010   \r
11011 char **pw_aln2clean_pw_aln (char ** aln, OveralnP *F)\r
11012 {\r
11013   \r
11014   if ( strm (F->model, "fsa2"))return pw_aln2clean_pw_aln_fsa2 (aln,F);\r
11015   else if ( strm (F->model, "fsa1"))return pw_aln2clean_pw_aln_fsa1 (aln,F);\r
11016   else return pw_aln2clean_pw_aln_fsa1 (aln,F);\r
11017 }\r
11018 \r
11019 char **pw_aln2clean_pw_aln_fsa2 (char ** aln, OveralnP *FO)\r
11020 {\r
11021   int a, b, c, d, l, id;\r
11022   int c1, c2, e0, e1,tb, obs;\r
11023   int T0, T1,T2;\r
11024   int **mat, **tran, **p, **t, *s, *ids;\r
11025   int ns, ps, cs;\r
11026   int S, M1, M2, m1, m2,B1, B2,G1,G2, K;\r
11027   int F=-9999999;\r
11028   int MID_EXON_FACTOR=50;\r
11029   int best;\r
11030   static int **smat;    \r
11031   int model_type=1;\r
11032   int *translate;\r
11033 \r
11034   if ( getenv ("MID_EXON_FACTOR"))MID_EXON_FACTOR=atoi (getenv ("MID_EXON_FACTOR"));\r
11035   \r
11036   \r
11037   \r
11038   if (!smat)smat=read_matrice ( "blosum62mt");\r
11039   \r
11040   l=strlen (aln[0]);\r
11041   \r
11042   if ( l!=strlen (aln[1]))\r
11043     {\r
11044       printf_exit ( EXIT_FAILURE, stderr, "\nERROR: unaligned strings");\r
11045     }\r
11046   \r
11047   \r
11048  \r
11049   s=vcalloc (l, sizeof (int));\r
11050   ids=vcalloc (l, sizeof (int));\r
11051   \r
11052   //record the id level of each posotion\r
11053   for (b=0; b<l; b++)\r
11054     {\r
11055       c1=tolower(aln[0][b]);c2=tolower(c2=aln[1][b]);\r
11056       \r
11057       if (c1=='-' || c2=='-' || c1=='X' || c2=='X' || c1!=c2)ids[b]=0;\r
11058       else ids[b]=1;\r
11059     }\r
11060   \r
11061   //record the state of each position: M, m, T, gap\r
11062   for (id=0,b=0,a=0;a<l; a++)\r
11063     {\r
11064       c1=aln[0][a];c2=aln[1][a];\r
11065       if (islower (c1))s[a]=3;\r
11066       else if (c1=='-' || c2=='-' || c1=='X' || c2=='X')s[a]=2;\r
11067       else\r
11068         {\r
11069           int sc;\r
11070           sc=smat[c1-'A'][c2-'A'];\r
11071           if (sc>=2){id++; s[a]=1;}\r
11072           else {s[a]=0;}\r
11073           b++;\r
11074         }\r
11075     }\r
11076   \r
11077   if (b==0) \r
11078     {\r
11079       vfree(s);vfree (ids);\r
11080       return aln;\r
11081     }\r
11082   \r
11083   \r
11084   \r
11085   FO->p1=(FO->p1==0)?5:FO->p1;\r
11086   FO->p2=(FO->p2==0)?15:FO->p2;\r
11087   FO->p3=(FO->p3==0)?0:FO->p3;\r
11088   FO->p4=(FO->p4==0)?100:FO->p4;\r
11089   \r
11090   \r
11091   T1=100*(float)id/(float)b;\r
11092   T2=(FO->f==0)?30:T1*(float)((float)FO->f/(float)100);\r
11093   T2=MAX(T2,20);\r
11094   \r
11095   //0: unaligned\r
11096   //1: aligned\r
11097   //2: gap\r
11098   //3: exon boundary\r
11099   \r
11100   ns=0;\r
11101   S=ns++;\r
11102   M1=ns++;//1 matched  aligned \r
11103   m1=ns++;//2 mmatched aligned\r
11104   M2=ns++;//3 matched  unaligned\r
11105   m2=ns++;//4 mmatched unaligned\r
11106   B1=ns++;//5 transition aligned\r
11107   B2=ns++;//6 transition unaligned\r
11108   \r
11109   mat=declare_int (ns, 4);\r
11110   tran=declare_int (ns, ns);\r
11111   p=declare_int (l+1, ns);\r
11112   t=declare_int (l+1, ns);\r
11113       \r
11114   //emission Values\r
11115   mat[M1][0]=F; //non id\r
11116   mat[M1][1]=T1;//id\r
11117   mat[M1][2]=0; //gap\r
11118   mat[M1][3]=F; //transition\r
11119   \r
11120   mat[M2][0]=F;\r
11121   mat[M2][1]=T2;\r
11122   mat[M2][2]=0;\r
11123   mat[M2][3]=F;\r
11124   \r
11125   mat[m1][0]=100-T1;\r
11126   mat[m1][1]=F;\r
11127   mat[m1][2]=0;\r
11128   mat[m1][3]=F;\r
11129   \r
11130   mat[m2][0]=100-T2;\r
11131   mat[m2][1]=F;\r
11132   mat[m2][2]=0;\r
11133   mat[m1][3]=F;\r
11134   \r
11135   mat[B1][0]=F;\r
11136   mat[B1][1]=F;\r
11137   mat[B1][2]=F;\r
11138   mat[B1][3]=0;\r
11139   \r
11140   mat[B2][0]=F;\r
11141   mat[B2][1]=F;\r
11142   mat[B2][2]=F;\r
11143   mat[B2][3]=0;\r
11144   \r
11145   //transition values\r
11146   tran[S][m1]=0;\r
11147   tran[S][m2]=0;\r
11148   tran[S][M1]=0;\r
11149   tran[S][M2]=0;\r
11150   tran[S][B1]=0;\r
11151   tran[S][B2]=0;\r
11152   \r
11153   \r
11154   tran[M1][m1]= 0;\r
11155   tran[M1][m2]=-FO->p4;\r
11156   tran[M1][M1]=+FO->p2;\r
11157   tran[M1][M2]= F;\r
11158   tran[M1][S ]= F;\r
11159   tran[M1][B1]= 0;\r
11160   tran[M1][B2]=-FO->p1;\r
11161       \r
11162   tran[M2][m1]= F;\r
11163   tran[M2][m2]=+FO->p3;\r
11164   tran[M2][M1]= F;\r
11165   tran[M2][M2]= 0;\r
11166   tran[M2][S] = F;\r
11167   tran[M2][B1]= F;\r
11168   tran[M2][B2]= 0;\r
11169   \r
11170   \r
11171   tran[m1][m1]= 0;\r
11172   tran[m1][m2]= F;\r
11173   tran[m1][M1]= 0;\r
11174   tran[m1][M2]= F;\r
11175   tran[m1][S] = F;\r
11176   tran[m1][B1]= 0;\r
11177   tran[m1][B2]=-FO->p1;\r
11178   \r
11179   tran[m2][m1]=  F;\r
11180   tran[m2][m2]=  0;\r
11181   tran[m2][M1]= -FO->p4;\r
11182   tran[m2][M2]= +FO->p3;\r
11183   tran[m2][S] =  F;\r
11184   tran[m2][B1]=  F;\r
11185   tran[m2][B2]=  0;\r
11186   \r
11187   tran[B1][m1]=  0;\r
11188   tran[B1][m2]=  F;\r
11189   tran[B1][M1]=  0;\r
11190   tran[B1][M2]=  F;\r
11191   tran[B1][S]=   F;\r
11192   tran[B1][B1]=  F;\r
11193   tran[B1][B2]=  F;\r
11194   \r
11195   tran[B2][m1]= -FO->p1;\r
11196   tran[B2][m2]=  0;\r
11197   tran[B2][M1]= -FO->p1;\r
11198   tran[B2][M2]=  0;\r
11199   tran[B2][S]=   F;\r
11200   tran[B2][B1]=  F;\r
11201   tran[B2][B2]=  F;\r
11202   \r
11203   translate=vcalloc (ns, sizeof (int));\r
11204   translate[M1]=1;\r
11205   translate[m1]=1;\r
11206   translate[M2]=0;\r
11207   translate[m2]=0;\r
11208   translate[B1]=1;\r
11209   translate[B2]=0;\r
11210   \r
11211   for (a=1;a<=l; a++)\r
11212     {\r
11213       obs=s[a-1];\r
11214       \r
11215       for (cs=0; cs<ns; cs++)\r
11216         {\r
11217           for (ps=0; ps<ns; ps++)\r
11218             {\r
11219               c=p[a-1][ps]+mat[cs][obs]+tran[ps][cs];\r
11220               if (ps==0 || c>=best){t[a][cs]=ps;best=p[a][cs]=c;}\r
11221             }\r
11222           \r
11223         }\r
11224     }\r
11225   \r
11226   \r
11227   for (a=0; a<ns; a++)\r
11228     {\r
11229       if (a==0 || p[l][a]>=best){tb=a;best=p[l][a];}\r
11230     }\r
11231   \r
11232   for (a=l; a>0; a--)\r
11233     {\r
11234       int v;\r
11235       int p2;\r
11236            \r
11237       p2=a-1;\r
11238       aln[0][p2]=aln[1][p2]=translate[tb];\r
11239       tb=t[a][tb];\r
11240       \r
11241     }\r
11242   \r
11243   free_int (p, -1);\r
11244   vfree(s);\r
11245   free_int (t, -1);\r
11246   free_int (mat, -1);\r
11247   free_int (tran, -1);\r
11248   vfree (translate);\r
11249   return aln;\r
11250 }\r
11251 char **pw_aln2clean_pw_aln_fsa1 (char ** aln, OveralnP *FO)\r
11252 {\r
11253   int a, b, c, d, l, id;\r
11254   int c1, c2, e0, e1,tb, obs;\r
11255   int T0, T1,T2;\r
11256   int **mat, **tran, **p, **t, **s;\r
11257   int ns, ps, cs;\r
11258   int S, M1, M2, m1, m2, K;\r
11259   int F=-9999999;\r
11260   int best;\r
11261   static int **smat;    \r
11262   int *translate;\r
11263 \r
11264   \r
11265   if (!smat)smat=read_matrice ( "blosum62mt");\r
11266   \r
11267   l=strlen (aln[0]);\r
11268   \r
11269   if ( l!=strlen (aln[1]))\r
11270     {\r
11271       printf_exit ( EXIT_FAILURE, stderr, "\nERROR: unaligned strings");\r
11272     }\r
11273   \r
11274  \r
11275   s=declare_int (l+1, 2);\r
11276   for (id=0,b=0,a=0;a<l; a++)\r
11277     {\r
11278       c1=aln[0][a];c2=aln[1][a];\r
11279       \r
11280       if ( c1=='-' || c2=='-' || c1=='x' || c1=='X' || c2=='x' || c2=='X')continue;\r
11281       else \r
11282         {\r
11283           int sc;\r
11284           sc=smat[c1-'A'][c2-'A'];\r
11285           if (sc>=2){id++; s[b][0]=1;}\r
11286           else {s[b][0]=0;}\r
11287           s[b][1]=a;\r
11288           b++;\r
11289           \r
11290         }\r
11291     }\r
11292   if (b==0) \r
11293     {\r
11294       free_int (s, -1);\r
11295       return aln;\r
11296     }\r
11297   FO->f=(FO->f==0)?30:FO->f;\r
11298   FO->p1=(FO->p1==0)?90:FO->p1;\r
11299   FO->p2=(FO->p2==0)?15:FO->p2;\r
11300   FO->p3=(FO->p3==0)?0:FO->p3;\r
11301 \r
11302   l=b;//length of the ungapped aln\r
11303   T1=100*(float)id/(float)b;\r
11304   T2=FO->f;//T1*f;\r
11305  \r
11306   \r
11307   \r
11308   //0: unaligned\r
11309   //1: aligned\r
11310   \r
11311   \r
11312   ns=0;\r
11313   S=ns++;\r
11314   M1=ns++;//1 matched  aligned \r
11315   m1=ns++;//2 mmatched aligned\r
11316   M2=ns++;//3 matched  unaligned\r
11317   m2=ns++;//4 mmatched unaligned\r
11318   \r
11319   mat=declare_int (ns, 2);\r
11320   tran=declare_int (ns, ns);\r
11321   p=declare_int (l+1, ns);\r
11322   t=declare_int (l+1, ns);\r
11323   \r
11324   \r
11325   mat[M1][0]=F;\r
11326   mat[M1][1]=T1;\r
11327   \r
11328   mat[M2][0]=F;\r
11329   mat[M2][1]=T2;\r
11330   \r
11331   mat[m1][0]=100-T1;\r
11332   mat[m1][1]=F;\r
11333   \r
11334   mat[m2][0]=100-T2;\r
11335   mat[m2][1]=F;\r
11336   \r
11337   \r
11338   tran[S][m1]=0;\r
11339   tran[S][m2]=0;\r
11340   tran[S][M1]=0;\r
11341   tran[S][M2]=0;\r
11342   \r
11343   \r
11344   tran[M1][m1]= 0;\r
11345   tran[M1][m2]=-FO->p1;// -P;\r
11346   tran[M1][M1]=+FO->p2;\r
11347   tran[M1][M2]= F;\r
11348   tran[M1][S] = F;\r
11349   \r
11350   tran[M2][m1]= F;\r
11351   tran[M2][m2]=+FO->p3;\r
11352   tran[M2][M1]= F;\r
11353   tran[M2][M2]= 0;\r
11354   tran[M2][S]=  F;\r
11355   \r
11356   tran[m1][m1]= 0;\r
11357   tran[m1][m2]= F;\r
11358   tran[m1][M1]= 0;\r
11359   tran[m1][M2]= F;\r
11360   tran[m1][S]=  F;\r
11361       \r
11362   tran[m2][m1]= F;\r
11363   tran[m2][m2]= 0;\r
11364   tran[m2][M1]=-FO->p1;\r
11365   tran[m2][M2]=+FO->p3;\r
11366   tran[m2][S]=  F;\r
11367   \r
11368   translate=vcalloc (ns, sizeof (int));\r
11369   translate[M1]=1;\r
11370   translate[m1]=1;\r
11371   translate[M2]=0;\r
11372   translate[m2]=0;\r
11373   translate[S]=1;\r
11374   \r
11375   \r
11376   for (a=1;a<=l; a++)\r
11377     {\r
11378       obs=s[a-1][0];\r
11379       \r
11380       for (cs=0; cs<ns; cs++)\r
11381         {\r
11382           for (ps=0; ps<ns; ps++)\r
11383             {\r
11384               c=p[a-1][ps]+mat[cs][obs]+tran[ps][cs];\r
11385               if (ps==0 || c>=best){t[a][cs]=ps;best=p[a][cs]=c;}\r
11386             }\r
11387           \r
11388         }\r
11389     }\r
11390   \r
11391   \r
11392   for (a=0; a<ns; a++)\r
11393     {\r
11394       if (a==0 || p[l][a]>=best){tb=a;best=p[l][a];}\r
11395     }\r
11396   for (a=l; a>0; a--)\r
11397     {\r
11398       int p2=s[a-1][1];\r
11399       aln[0][p2]=aln[1][p2]=translate[tb];\r
11400       \r
11401       tb=t[a][tb];\r
11402     }\r
11403   \r
11404   \r
11405   free_int (p, -1);\r
11406   free_int (s, -1);\r
11407   free_int (t, -1);\r
11408   free_int (mat, -1);\r
11409   free_int (tran, -1);\r
11410   vfree (translate);\r
11411   return aln;\r
11412 }\r
11413 float* analyze_overaln ( Alignment *iA, Alignment *iB, char *mode, int filter, int f, int p1,int p2, int p3)\r
11414 {\r
11415   Alignment *C, *D;\r
11416   Alignment *A, *B;\r
11417   OveralnP *F;\r
11418 \r
11419   F=vcalloc (1, sizeof (OveralnP));\r
11420   F->p1=p1;\r
11421   F->p2=p2;\r
11422   F->p3=p3;\r
11423   F->f=f;\r
11424   F->t=filter;\r
11425   sprintf (F->mode, "%s", mode);\r
11426     \r
11427   \r
11428   float *r;\r
11429   A=copy_aln (iA, NULL);\r
11430   B=copy_aln (iB, NULL);\r
11431   \r
11432   C=aln2gap_cache (A,0);\r
11433   A=filter_aln_upper_lower (A, C, 0, 0);\r
11434   D=aln2clean_pw_aln (B, F);\r
11435   r=aln2pred (A,D,mode);\r
11436   free_aln (C);\r
11437   free_aln (D);\r
11438   free_aln (A);\r
11439   free_aln (B);\r
11440   return r;\r
11441 }\r
11442 float* aln2pred ( Alignment *A, Alignment*B, char *mode)\r
11443 {\r
11444   int a, b, c, d, i, l, salp, s, n;\r
11445   static char **list, *buf1, *buf2, *alp, *alp_lu;\r
11446   static int ***r;\r
11447   int T, N;\r
11448   int fp, fn, tn, tp;\r
11449   int tfp, tfn, ttn, ttp;\r
11450   float sp, sn, sen2, best, result;\r
11451   int print=1;\r
11452   float *fresult;\r
11453 \r
11454   fresult=vcalloc ( 3, sizeof (float));\r
11455   \r
11456   if ( mode && strstr (mode, "case"))\r
11457     {\r
11458       A=aln2case_aln (A,"u","l");\r
11459       B=aln2case_aln (B,"u","l");\r
11460     }\r
11461   \r
11462   if (mode && strstr (mode, "printaln"))\r
11463     {\r
11464       Sequence *S;\r
11465       Alignment *C;\r
11466       S=aln2seq (A);\r
11467       C=copy_aln (B, NULL);\r
11468       for (a=0; a<B->nseq; a++)\r
11469         {\r
11470           i=name_is_in_list (C->name[a], S->name, S->nseq, 100);\r
11471           if ( i==-1)\r
11472             for (b=0; b<C->len_aln; b++) C->seq_al[a][b]='-';\r
11473           else\r
11474             for (d=0,b=0; b<C->len_aln; b++)\r
11475               {\r
11476                 if ( !is_gap (C->seq_al[a][b]))\r
11477                   {\r
11478                     if (C->seq_al[a][b]==S->seq[i][d])C->seq_al[a][b]=toupper(C->seq_al[a][b]);\r
11479                     d++;\r
11480                   }\r
11481               }\r
11482         }\r
11483       print_aln (C);\r
11484     }\r
11485   \r
11486   vfree (alp);vfree (alp_lu);\r
11487   alp=vcalloc ( 256, sizeof (char));\r
11488   alp_lu=vcalloc ( 256, sizeof (char));\r
11489 \r
11490   for (c=0; c<2; c++)\r
11491     {\r
11492       Alignment *AL;\r
11493       AL=(c==0)?A:B;\r
11494       for (salp=0,a=0; a<AL->nseq; a++)\r
11495         {\r
11496           for (b=0; b<AL->len_aln; b++)\r
11497             {\r
11498               c=AL->seq_al[a][b];\r
11499               if (!is_gap(c) && !alp[c])\r
11500                 {\r
11501                   salp++;\r
11502                   alp_lu[salp]=c;\r
11503                   alp[c]=salp;\r
11504                 }\r
11505             }\r
11506         }\r
11507     }\r
11508   \r
11509   vfree (buf1); vfree(buf2);\r
11510   buf1=vcalloc ( A->len_aln+1, sizeof (char));\r
11511   buf2=vcalloc ( B->len_aln+1, sizeof (char));\r
11512   \r
11513   free_arrayN ((void **)r, 3);\r
11514   r=declare_arrayN(3, sizeof (int),A->nseq,salp+1,salp+1);\r
11515   free_char ( list, -1);\r
11516   list=declare_char ( A->nseq, 100);\r
11517   for (n=0,a=0; a< A->nseq; a++)\r
11518     {\r
11519       for ( b=0; b<B->nseq; b++)\r
11520         {\r
11521           if ( strm (A->name[a], B->name[b]))\r
11522             {\r
11523               sprintf ( buf1, "%s", A->seq_al[a]);\r
11524               sprintf ( buf2, "%s", B->seq_al[b]);\r
11525               ungap (buf1); ungap (buf2);\r
11526               if ((l=strlen (buf1))!=strlen (buf2))continue;\r
11527               else\r
11528                 {\r
11529                   sprintf ( list[n], "%s", A->name[a]);\r
11530                   for (c=0; c<l; c++)\r
11531                     {\r
11532                       int c1, c2;\r
11533                       c1=buf1[c];\r
11534                       c2=buf2[c];\r
11535                       r[n][alp[c1]][alp[c2]]++;\r
11536                     }\r
11537                   n++;\r
11538                 }\r
11539             }\r
11540         }\r
11541     }\r
11542   \r
11543 \r
11544   \r
11545   for ( s=1; s<=salp; s++)\r
11546     {\r
11547       char type[4];\r
11548       sprintf (type, "_%c_", alp_lu[s]);\r
11549       ttp=ttn=tfp=tfn=0;\r
11550       for (a=0; a<n; a++)\r
11551         {\r
11552           tp=tn=fp=fn=0;\r
11553           for (b=1; b<=salp; b++)\r
11554             {\r
11555               for (c=1; c<=salp; c++)\r
11556                     {\r
11557                       if ( b==s && c==s)     tp+=r[a][b][c];\r
11558                       else if ( b==s && c!=s)fn+=r[a][b][c];\r
11559                       else if ( b!=s && c==s)fp+=r[a][b][c];\r
11560                       else if ( b!=s && b!=s)tn+=r[a][b][c];\r
11561                     }\r
11562               \r
11563             }\r
11564           \r
11565           ttp+=tp;\r
11566           ttn+=tn;\r
11567           tfp+=fp;\r
11568           tfn+=fn;\r
11569           rates2sensitivity (tp, tn, fp, fn, &sp, &sn, &sen2, &best);\r
11570           if ( mode && strstr (mode, "printstat"))fprintf ( stdout, ">%s S=%c sp=%6.2f sn=%6.2f sen2=%6.2f best=%6.2f\n", list[a],alp_lu[s],sp, sn, sen2, best);\r
11571         }\r
11572       \r
11573       rates2sensitivity (ttp, ttn, tfp, tfn, &sp, &sn, &sen2, &best);\r
11574       if (mode && strstr (mode, "printstat"))fprintf ( stdout, ">TOT S=%c sp=%6.2f sn=%6.2f re=%6.2f best=%6.2f\n", alp_lu[s],sp, sn, sen2, best);\r
11575       \r
11576       if ( mode && strstr (mode, type))\r
11577         {\r
11578           fresult[0]=sn;\r
11579           fresult[1]=sp;\r
11580           fresult[2]=sen2;\r
11581         }\r
11582     }\r
11583   return fresult;\r
11584 }\r
11585 \r
11586 Alignment * mark_exon_boundaries  (Alignment *A, Alignment *E)\r
11587 {\r
11588   char *buf, *buf2;\r
11589   int a, b, c, i, l;\r
11590   \r
11591   buf2=vcalloc ( E->len_aln+1, sizeof (char));\r
11592   buf =vcalloc ( E->len_aln+1, sizeof (char));\r
11593   \r
11594   for (a=0; a< A->nseq; a++)\r
11595     {\r
11596       i=name_is_in_list (A->name[a], E->name, E->nseq, 100);\r
11597       if ( i==-1) continue;\r
11598       sprintf (buf, "%s", E->seq_al[i]);\r
11599       ungap (buf);\r
11600       l=strlen (buf);\r
11601       //clean buf2\r
11602       for (c=0, b=0; b<l; b++)if (buf[b]!='o' && buf[b]!='b' && buf[b]!='j')buf2[c++]=toupper(buf[b]);\r
11603       buf2[c]='\0';\r
11604       \r
11605       //lowercase the boundaries of buf2;\r
11606       for ( c=0,b=0; b<l; b++)\r
11607         {\r
11608           //ENSEMBL: o: 0, b:1 j:2\r
11609           if (buf[b]=='b' || buf[b]=='o' && c>=1)buf2[c-1]=tolower(buf2[c-1]);\r
11610           else if (buf[b]=='j' &&c<l)buf2[c+1]=tolower(buf2[c+1]);\r
11611           else c++;\r
11612         }\r
11613       \r
11614       for (c=0,b=0; b<A->len_aln; b++)\r
11615         {\r
11616           if (!is_gap(A->seq_al[a][b]))\r
11617             {\r
11618               A->seq_al[a][b]=buf2[c++];\r
11619             }\r
11620         }\r
11621     }\r
11622   vfree (buf);\r
11623   vfree (buf2);\r
11624   return A;\r
11625 }\r
11626 \r
11627 \r
11628 \r
11629 \r
11630 \r
11631 \r
11632 \r
11633 \r
11634 \r
11635 \r
11636 \r
11637 \r
11638 \r
11639 \r
11640 \r
11641 \r
11642 \r
11643 \r
11644 \r
11645 \r
11646 \r
11647 \r
11648 \r
11649 \r
11650 \r
11651 \r
11652 \r
11653 \r
11654 \r
11655 \r
11656 \r
11657 \r
11658 \r
11659 \r
11660 \r
11661 \r
11662 \r
11663 \r
11664 \r
11665 \r
11666 \r
11667 \r
11668 \r
11669 \r
11670 \r
11671 \r
11672 \r
11673 \r
11674 \r
11675 \r
11676 \r
11677 \r
11678 \r
11679 \r
11680 \r
11681 \r
11682 \r
11683 \r
11684 \r
11685 \r
11686 \r
11687 \r
11688 \r
11689 \r
11690 \r
11691 \r
11692 \r
11693 \r
11694 \r
11695 \r
11696 \r
11697 \r
11698 \r
11699 \r
11700 \r
11701 \r
11702 \r
11703 \r
11704 \r
11705 \r
11706 \r
11707 \r
11708 \r
11709 \r
11710 \r
11711 \r
11712 \r
11713 \r
11714 \r
11715 \r
11716 \r
11717 \r
11718 \r
11719 \r
11720 \r
11721 \r
11722 \r
11723 \r
11724 \r
11725 \r
11726 \r
11727 \r
11728 \r
11729 \r
11730 \r
11731 \r
11732 \r
11733 \r
11734 \r
11735 \r
11736 \r
11737 \r
11738 \r
11739 \r
11740 \r
11741 \r
11742 \r
11743 \r
11744 \r
11745 \r
11746 \r
11747 \r
11748 \r
11749 \r
11750 \r
11751 \r
11752 \r
11753 \r
11754 \r
11755 \r
11756 \r
11757 \r
11758 \r
11759 \r
11760 \r
11761 \r
11762 \r
11763 \r
11764 \r
11765 \r
11766 \r
11767 \r
11768 \r
11769 \r
11770 \r
11771 \r
11772 \r
11773 \r
11774 \r
11775 \r
11776 \r
11777 \r
11778 \r
11779 \r
11780 \r
11781 \r
11782 \r
11783 \r
11784 \r
11785 \r
11786 \r
11787 \r
11788 \r
11789 \r
11790 \r
11791 \r
11792 \r
11793 \r
11794 \r
11795 \r
11796 \r
11797 \r
11798 \r
11799 \r
11800 \r
11801 \r
11802 \r
11803 \r
11804 \r
11805 \r
11806 \r
11807 \r
11808 \r
11809 \r
11810 \r
11811 \r
11812 \r
11813 \r
11814 \r
11815 \r
11816 \r
11817 \r
11818 \r
11819 \r
11820 \r
11821 \r
11822 \r
11823 \r
11824 \r
11825 \r
11826 \r
11827 \r
11828 \r
11829 \r
11830 \r
11831 \r
11832 \r
11833 \r
11834 \r
11835 \r
11836 \r
11837 \r
11838 \r
11839 \r
11840 \r
11841 \r
11842 \r
11843 \r
11844 \r
11845 \r
11846 \r
11847 \r
11848 \r
11849 \r
11850 \r
11851 \r
11852 \r
11853 \r
11854 \r
11855 \r
11856 \r
11857 \r
11858 \r
11859 \r
11860 \r
11861 \r
11862 \r
11863 \r
11864 \r
11865 \r
11866 \r
11867 \r
11868 \r
11869 \r
11870 \r
11871 \r
11872 \r
11873 \r
11874 \r
11875 \r
11876 \r
11877 \r
11878 \r
11879 \r
11880 \r
11881 \r
11882 \r
11883 \r
11884 \r
11885 \r
11886 \r
11887 \r
11888 \r
11889 \r
11890 \r
11891 \r
11892 \r
11893 \r
11894 \r
11895 \r
11896 \r
11897 \r
11898 \r
11899 \r
11900 \r
11901 \r
11902 \r
11903 \r
11904 \r
11905 \r
11906 \r
11907 \r
11908 \r
11909 \r
11910 \r
11911 \r
11912 \r
11913 \r
11914 \r
11915 \r
11916 \r
11917 \r
11918 \r
11919 \r
11920 \r
11921 \r
11922 \r
11923 \r
11924 \r
11925 \r
11926 \r
11927 \r
11928 \r
11929 \r
11930 \r
11931 \r
11932 \r
11933 \r
11934 \r
11935 \r
11936 \r
11937 \r
11938 \r
11939 \r
11940 \r
11941 \r
11942 \r
11943 \r
11944 \r
11945 \r
11946 \r
11947 \r
11948 \r
11949 \r
11950 \r
11951 \r
11952 \r
11953 \r
11954 \r
11955 \r
11956 \r
11957 \r
11958 \r
11959 \r
11960 \r
11961 \r
11962 \r
11963 \r
11964 \r
11965 \r
11966 \r
11967 \r
11968 \r
11969 \r
11970 \r
11971 \r
11972 \r
11973 \r
11974 \r
11975 \r
11976 \r
11977 \r
11978 \r
11979 \r
11980 \r
11981 \r
11982 \r
11983 \r
11984 \r
11985 \r
11986 \r
11987 \r
11988 \r
11989 \r
11990 \r
11991 \r
11992 \r
11993 \r
11994 \r
11995 \r
11996 \r
11997 \r
11998 \r
11999 \r
12000 \r
12001 \r
12002 \r
12003 \r
12004 \r
12005 \r
12006 \r
12007 \r
12008 \r
12009 \r
12010 \r
12011 \r
12012 \r
12013 \r
12014 \r
12015 \r
12016 \r
12017 \r
12018 \r
12019 \r
12020 \r
12021 \r
12022 \r
12023 \r
12024 \r
12025 \r
12026 \r
12027 \r
12028 \r
12029 \r
12030 \r
12031 \r
12032 \r
12033 \r
12034 \r
12035 \r
12036 \r
12037 \r
12038 \r
12039 \r
12040 \r
12041 \r
12042 \r
12043 \r
12044 \r
12045 \r
12046 \r
12047 \r
12048 \r
12049 \r
12050 \r
12051 \r
12052 \r
12053 \r
12054 \r
12055 \r
12056 \r
12057 \r
12058 \r
12059 \r
12060 \r
12061 \r
12062 \r
12063 \r
12064 \r
12065 \r
12066 \r
12067 \r
12068 \r
12069 \r
12070 \r
12071 \r
12072 \r
12073 \r
12074 \r
12075 \r
12076 \r
12077 \r
12078 \r
12079 \r
12080 \r
12081 \r
12082 \r
12083 \r
12084 \r
12085 \r
12086 \r
12087 \r
12088 \r
12089 \r
12090 \r
12091 \r
12092 \r
12093 \r
12094 \r
12095 \r
12096 \r
12097 \r
12098 \r
12099 \r
12100 \r
12101 \r
12102 \r
12103 \r
12104 \r
12105 \r
12106 \r
12107 \r
12108 \r
12109 \r
12110 \r
12111 \r
12112 \r
12113 \r
12114 \r
12115 \r
12116 \r
12117 \r
12118 \r
12119 \r
12120 \r
12121 \r
12122 \r
12123 \r
12124 \r
12125 \r
12126 \r
12127 \r
12128 \r
12129 \r
12130 \r
12131 \r
12132 \r
12133 \r
12134 \r
12135 \r
12136 \r
12137 \r
12138 \r
12139 \r
12140 \r
12141 \r
12142 \r
12143 \r
12144 \r
12145 \r
12146 \r
12147 \r
12148 \r
12149 \r
12150 \r
12151 \r
12152 \r
12153 \r
12154 \r
12155 \r
12156 \r
12157 \r
12158 \r
12159 \r
12160 \r
12161 \r
12162 \r
12163 \r
12164 \r
12165 \r
12166 \r
12167 \r
12168 \r
12169 \r
12170 \r
12171 \r
12172 \r
12173 \r
12174 \r
12175 \r
12176 \r
12177 \r
12178 \r
12179 \r
12180 \r
12181 \r
12182 \r
12183 \r
12184 \r
12185 \r
12186 \r
12187 \r
12188 \r
12189 \r
12190 \r
12191 \r
12192 \r
12193 \r
12194 \r
12195 \r
12196 \r
12197 \r
12198 \r
12199 \r
12200 \r
12201 \r
12202 \r
12203 \r
12204 \r
12205 \r
12206 \r
12207 \r
12208 \r
12209 \r
12210 \r
12211 \r
12212 \r
12213 \r
12214 \r
12215 \r
12216 \r
12217 \r
12218 \r
12219 \r
12220 \r
12221 \r
12222 \r
12223 \r
12224 \r
12225 \r
12226 \r
12227 \r
12228 \r
12229 \r
12230 \r
12231 \r
12232 \r
12233 \r
12234 \r
12235 \r
12236 \r
12237 \r
12238 \r
12239 \r
12240 \r
12241 \r
12242 \r
12243 \r
12244 \r
12245 \r
12246 \r
12247 \r
12248 \r
12249 \r
12250 \r
12251 \r
12252 \r
12253 \r
12254 \r
12255 \r
12256 \r
12257 \r
12258 \r
12259 \r
12260 \r
12261 \r
12262 \r
12263 \r
12264 \r
12265 \r
12266 \r
12267 \r
12268 \r
12269 \r
12270 \r
12271 \r
12272 \r
12273 \r
12274 \r
12275 \r
12276 \r
12277 \r
12278 \r
12279 \r
12280 \r
12281 \r
12282 \r
12283 \r
12284 \r
12285 \r
12286 \r
12287 \r
12288 \r
12289 \r
12290 \r
12291 \r
12292 \r
12293 \r
12294 \r
12295 \r
12296 \r
12297 \r
12298 \r
12299 \r
12300 \r
12301 \r
12302 \r
12303 \r
12304 \r
12305 \r
12306 \r
12307 \r
12308 \r
12309 \r
12310 \r
12311 \r
12312 \r
12313 \r
12314 \r
12315 \r
12316 \r
12317 \r
12318 \r
12319 \r
12320 \r
12321 \r
12322 \r
12323 \r
12324 \r
12325 \r
12326 \r
12327 \r
12328 \r
12329 \r
12330 \r
12331 \r
12332 \r
12333 \r
12334 \r
12335 \r
12336 \r
12337 \r
12338 \r
12339 \r
12340 \r
12341 \r
12342 \r
12343 \r
12344 \r
12345 \r
12346 \r
12347 \r
12348 \r
12349 \r
12350 \r
12351 \r
12352 \r
12353 \r
12354 \r
12355 \r
12356 \r
12357 \r
12358 \r
12359 \r
12360 \r
12361 \r
12362 \r
12363 \r
12364 \r
12365 \r
12366 \r
12367 \r
12368 \r
12369 \r
12370 \r
12371 \r
12372 \r
12373 \r
12374 \r
12375 \r
12376 \r
12377 \r
12378 \r
12379 \r
12380 \r
12381 \r
12382 \r
12383 \r
12384 \r
12385 \r
12386 \r
12387 \r
12388 \r
12389 \r
12390 \r
12391 \r
12392 \r
12393 \r
12394 \r
12395 \r
12396 \r
12397 \r
12398 \r
12399 \r
12400 \r
12401 \r
12402 \r
12403 \r
12404 \r
12405 \r
12406 \r
12407 \r
12408 \r
12409 \r
12410 \r
12411 \r
12412 \r
12413 \r
12414 \r
12415 \r
12416 \r
12417 \r
12418 \r
12419 \r
12420 \r
12421 \r
12422 \r
12423 \r
12424 \r
12425 \r
12426 \r
12427 \r
12428 \r
12429 \r
12430 \r
12431 \r
12432 \r
12433 \r
12434 \r
12435 \r
12436 \r
12437 \r
12438 \r
12439 \r
12440 \r
12441 \r
12442 \r
12443 \r
12444 \r
12445 \r
12446 \r
12447 \r
12448 \r
12449 \r
12450 \r
12451 \r
12452 \r
12453 \r
12454 \r
12455 \r
12456 \r
12457 \r
12458 \r
12459 \r
12460 \r
12461 \r
12462 \r
12463 \r
12464 \r
12465 \r
12466 \r
12467 \r
12468 \r
12469 \r
12470 \r
12471 \r
12472 \r
12473 \r
12474 \r
12475 \r
12476 \r
12477 \r
12478 \r
12479 \r
12480 \r
12481 \r
12482 \r
12483 \r
12484 \r
12485 \r
12486 \r
12487 \r
12488 \r
12489 \r
12490 \r
12491 \r
12492 \r
12493 \r
12494 \r
12495 \r
12496 \r
12497 \r
12498 \r
12499 \r
12500 \r
12501 \r
12502 \r
12503 \r
12504 \r
12505 \r
12506 \r
12507 \r
12508 \r
12509 \r
12510 \r
12511 \r
12512 \r
12513 \r
12514 \r
12515 \r
12516 \r
12517 \r
12518 \r
12519 \r
12520 \r
12521 \r
12522 \r
12523 \r
12524 \r
12525 \r
12526 \r
12527 \r
12528 \r
12529 \r
12530 \r
12531 \r
12532 \r
12533 \r
12534 \r
12535 \r
12536 \r
12537 \r
12538 \r
12539 \r
12540 \r
12541 \r
12542 \r
12543 \r
12544 \r
12545 \r
12546 \r
12547 \r
12548 \r
12549 \r
12550 \r
12551 \r
12552 \r
12553 \r
12554 \r
12555 \r
12556 \r
12557 \r
12558 \r
12559 \r
12560 \r
12561 \r
12562 \r
12563 \r
12564 \r
12565 \r
12566 \r
12567 \r
12568 \r
12569 \r
12570 \r
12571 \r
12572 \r
12573 \r
12574 \r
12575 \r
12576 \r
12577 \r
12578 \r
12579 \r
12580 \r
12581 \r
12582 \r
12583 \r
12584 \r
12585 \r
12586 \r
12587 \r
12588 \r
12589 \r
12590 \r
12591 \r
12592 \r
12593 \r
12594 \r
12595 \r
12596 \r
12597 \r
12598 \r
12599 \r
12600 \r
12601 \r
12602 \r
12603 \r
12604 \r
12605 \r
12606 \r
12607 \r
12608 \r
12609 \r
12610 \r
12611 \r
12612 \r
12613 \r
12614 \r
12615 \r
12616 \r
12617 \r
12618 \r
12619 \r
12620 \r
12621 \r
12622 \r
12623 \r
12624 \r
12625 \r
12626 \r
12627 \r
12628 \r
12629 \r
12630 \r
12631 \r
12632 \r
12633 \r
12634 \r
12635 \r
12636 \r
12637 \r
12638 \r
12639 \r
12640 \r
12641 \r
12642 \r
12643 \r
12644 \r
12645 \r
12646 \r
12647 \r
12648 \r
12649 \r
12650 \r
12651 \r
12652 \r
12653 \r
12654 \r
12655 \r
12656 \r
12657 \r
12658 \r
12659 \r
12660 \r
12661 \r
12662 \r
12663 \r
12664 \r
12665 \r
12666 \r
12667 \r
12668 \r
12669 \r
12670 \r
12671 \r
12672 \r
12673 \r
12674 \r
12675 \r
12676 \r
12677 \r
12678 \r
12679 \r
12680 \r
12681 \r
12682 \r
12683 \r
12684 \r
12685 \r
12686 \r
12687 \r
12688 \r
12689 \r
12690 \r
12691 \r
12692 \r
12693 \r
12694 \r
12695 \r
12696 \r
12697 \r
12698 \r
12699 \r
12700 \r
12701 \r
12702 \r
12703 \r
12704 \r
12705 \r
12706 \r
12707 \r
12708 \r
12709 \r
12710 \r
12711 \r
12712 \r
12713 \r
12714 \r
12715 \r
12716 \r
12717 \r
12718 \r
12719 \r
12720 \r
12721 \r
12722 \r
12723 \r
12724 \r
12725 \r
12726 \r
12727 \r
12728 \r
12729 \r
12730 \r
12731 \r
12732 \r
12733 \r
12734 \r
12735 \r
12736 \r
12737 \r
12738 \r
12739 \r
12740 \r
12741 \r
12742 \r
12743 \r
12744 \r
12745 \r
12746 \r
12747 \r
12748 \r
12749 \r
12750 \r
12751 \r
12752 \r
12753 \r
12754 \r
12755 \r
12756 \r
12757 \r
12758 \r
12759 \r
12760 \r
12761 \r
12762 \r
12763 \r
12764 \r
12765 \r
12766 \r
12767 \r
12768 \r
12769 \r
12770 \r
12771 \r
12772 \r
12773 \r
12774 \r
12775 \r
12776 \r
12777 \r
12778 \r
12779 \r
12780 \r
12781 \r
12782 \r
12783 \r
12784 \r
12785 \r
12786 \r
12787 \r
12788 \r
12789 \r
12790 \r
12791 \r
12792 \r
12793 \r
12794 \r
12795 \r
12796 \r
12797 \r
12798 \r
12799 \r
12800 \r
12801 \r
12802 \r
12803 \r
12804 \r
12805 \r
12806 \r
12807 \r
12808 \r
12809 \r
12810 \r
12811 \r
12812 \r
12813 \r
12814 \r
12815 \r
12816 \r
12817 \r
12818 \r
12819 \r
12820 \r
12821 \r
12822 \r
12823 \r
12824 \r
12825 \r
12826 \r
12827 \r
12828 \r
12829 \r
12830 \r
12831 \r
12832 \r
12833 \r
12834 \r
12835 \r
12836 \r
12837 \r
12838 \r
12839 \r
12840 \r
12841 \r
12842 \r
12843 \r
12844 \r
12845 \r
12846 \r
12847 \r
12848 \r
12849 \r
12850 \r
12851 \r
12852 \r
12853 \r
12854 \r
12855 \r
12856 \r
12857 \r
12858 \r
12859 \r
12860 \r
12861 \r
12862 \r
12863 \r
12864 \r
12865 \r
12866 \r
12867 \r
12868 \r
12869 \r
12870 \r
12871 \r
12872 \r
12873 \r
12874 \r
12875 \r
12876 \r
12877 \r
12878 \r
12879 \r
12880 \r
12881 \r
12882 \r
12883 \r
12884 \r
12885 \r
12886 \r
12887 \r
12888 \r
12889 \r
12890 \r
12891 \r
12892 \r
12893 \r
12894 \r
12895 \r
12896 \r
12897 \r
12898 \r
12899 \r
12900 \r
12901 \r
12902 \r
12903 \r
12904 \r
12905 \r
12906 \r
12907 \r
12908 \r
12909 \r
12910 \r
12911 \r
12912 \r
12913 \r
12914 \r
12915 \r
12916 \r
12917 \r
12918 \r
12919 \r
12920 \r
12921 \r
12922 \r
12923 \r
12924 \r
12925 \r
12926 \r
12927 \r
12928 \r
12929 \r
12930 \r
12931 \r
12932 \r
12933 \r
12934 \r
12935 \r
12936 \r
12937 \r
12938 \r
12939 \r
12940 \r
12941 \r
12942 \r
12943 \r
12944 \r
12945 \r
12946 \r
12947 \r
12948 \r
12949 \r
12950 \r
12951 \r
12952 \r
12953 \r
12954 \r
12955 \r
12956 \r
12957 \r
12958 \r
12959 \r
12960 \r
12961 \r
12962 \r
12963 \r
12964 \r
12965 \r
12966 \r
12967 \r
12968 \r
12969 \r
12970 \r
12971 \r
12972 \r
12973 \r
12974 \r
12975 \r
12976 \r
12977 \r
12978 \r
12979 \r
12980 \r
12981 \r
12982 \r
12983 \r
12984 \r
12985 \r
12986 \r
12987 \r
12988 \r
12989 \r
12990 \r
12991 \r
12992 \r
12993 \r
12994 \r
12995 \r
12996 \r
12997 \r
12998 \r
12999 \r
13000 \r
13001 \r
13002 \r
13003 \r
13004 \r
13005 \r
13006 \r
13007 \r
13008 \r
13009 \r
13010 \r
13011 \r
13012 \r
13013 \r
13014 \r
13015 \r
13016 \r
13017 \r
13018 \r
13019 \r
13020 \r
13021 \r
13022 \r
13023 \r
13024 \r
13025 \r
13026 \r
13027 \r
13028 \r
13029 \r
13030 \r
13031 \r
13032 \r
13033 \r
13034 \r
13035 \r
13036 \r
13037 \r
13038 \r
13039 \r
13040 \r
13041 \r
13042 \r
13043 \r
13044 \r
13045 \r
13046 \r
13047 \r
13048 \r
13049 \r
13050 \r
13051 \r
13052 \r
13053 \r
13054 \r
13055 \r
13056 \r
13057 \r
13058 \r
13059 \r
13060 \r
13061 \r
13062 \r
13063 \r
13064 \r
13065 \r
13066 \r
13067 \r
13068 \r
13069 \r
13070 \r
13071 \r
13072 \r
13073 \r
13074 \r
13075 \r
13076 \r
13077 \r
13078 \r
13079 \r
13080 \r
13081 \r
13082 \r
13083 \r
13084 \r
13085 \r
13086 \r
13087 \r
13088 \r
13089 \r
13090 \r
13091 \r
13092 \r
13093 \r
13094 \r
13095 \r
13096 \r
13097 \r
13098 \r
13099 \r
13100 \r
13101 \r
13102 \r
13103 \r
13104 \r
13105 \r
13106 \r
13107 \r
13108 \r
13109 \r
13110 \r
13111 \r
13112 \r
13113 \r
13114 \r
13115 \r
13116 \r
13117 \r
13118 \r
13119 \r
13120 \r
13121 \r
13122 \r
13123 \r
13124 \r
13125 \r
13126 \r
13127 \r
13128 \r
13129 \r
13130 \r
13131 \r
13132 \r
13133 \r
13134 \r
13135 \r
13136 \r
13137 \r
13138 \r
13139 \r
13140 \r
13141 \r
13142 \r
13143 \r
13144 \r
13145 \r
13146 \r
13147 \r
13148 \r
13149 \r
13150 \r
13151 \r
13152 \r
13153 \r
13154 \r
13155 \r
13156 \r
13157 \r
13158 \r
13159 \r
13160 \r
13161 \r
13162 \r
13163 \r
13164 \r
13165 \r
13166 \r
13167 \r
13168 \r
13169 \r
13170 \r
13171 \r
13172 \r
13173 \r
13174 \r
13175 \r
13176 \r
13177 \r
13178 \r
13179 \r
13180 \r
13181 \r
13182 \r
13183 \r
13184 \r
13185 \r
13186 \r
13187 \r
13188 \r
13189 \r
13190 \r
13191 \r
13192 \r
13193 \r
13194 \r
13195 \r
13196 \r
13197 \r
13198 \r
13199 \r
13200 \r
13201 \r
13202 \r
13203 \r
13204 \r
13205 \r
13206 \r
13207 \r
13208 \r
13209 \r
13210 \r
13211 \r
13212 \r
13213 \r
13214 \r
13215 \r
13216 \r
13217 \r
13218 \r
13219 \r
13220 \r
13221 \r
13222 \r
13223 \r
13224 \r
13225 \r
13226 \r
13227 \r
13228 \r
13229 \r
13230 \r
13231 \r
13232 \r
13233 \r
13234 \r
13235 \r
13236 \r
13237 \r
13238 \r
13239 \r
13240 \r
13241 \r
13242 \r
13243 \r
13244 \r
13245 \r
13246 \r
13247 \r
13248 \r
13249 \r
13250 \r
13251 \r
13252 \r
13253 \r
13254 \r
13255 \r
13256 \r
13257 \r
13258 \r
13259 \r
13260 \r
13261 \r
13262 \r
13263 \r
13264 \r
13265 \r
13266 \r
13267 \r
13268 \r
13269 \r
13270 \r
13271 \r
13272 \r
13273 \r
13274 \r
13275 \r
13276 \r
13277 \r
13278 \r
13279 \r
13280 \r
13281 \r
13282 \r
13283 \r
13284 \r
13285 \r
13286 \r
13287 \r
13288 \r
13289 \r
13290 \r
13291 \r
13292 \r
13293 \r
13294 \r
13295 \r
13296 \r
13297 \r
13298 \r
13299 \r
13300 \r
13301 \r
13302 \r
13303 \r
13304 \r
13305 \r
13306 \r
13307 \r
13308 \r
13309 \r
13310 \r
13311 \r
13312 \r
13313 \r
13314 \r
13315 \r
13316 \r
13317 \r
13318 \r
13319 \r
13320 \r
13321 \r
13322 \r
13323 \r
13324 \r
13325 \r
13326 \r
13327 \r
13328 \r
13329 \r
13330 \r
13331 \r
13332 \r
13333 \r
13334 \r
13335 \r
13336 \r
13337 \r
13338 \r
13339 \r
13340 \r
13341 \r
13342 \r
13343 \r
13344 \r
13345 \r
13346 \r
13347 \r
13348 \r
13349 \r
13350 \r
13351 \r
13352 \r
13353 \r
13354 \r
13355 \r
13356 \r
13357 \r
13358 \r
13359 \r
13360 \r
13361 \r
13362 \r
13363 \r
13364 \r
13365 \r
13366 \r
13367 \r
13368 \r
13369 \r
13370 \r
13371 \r
13372 \r
13373 \r
13374 \r
13375 \r
13376 \r
13377 \r
13378 \r
13379 \r
13380 \r
13381 \r
13382 \r
13383 \r
13384 \r
13385 \r
13386 \r
13387 \r
13388 \r
13389 \r
13390 \r
13391 \r
13392 \r
13393 \r
13394 \r
13395 \r
13396 \r
13397 \r
13398 \r
13399 \r
13400 \r
13401 \r
13402 \r
13403 \r
13404 \r
13405 \r
13406 \r
13407 \r
13408 \r
13409 \r
13410 \r
13411 \r
13412 \r
13413 \r
13414 \r
13415 \r
13416 \r
13417 \r
13418 \r
13419 \r
13420 \r
13421 \r
13422 \r
13423 \r
13424 \r
13425 \r
13426 \r
13427 \r
13428 \r
13429 \r
13430 \r
13431 \r
13432 \r
13433 \r
13434 \r
13435 \r
13436 \r
13437 \r
13438 \r
13439 \r
13440 \r
13441 \r
13442 \r
13443 \r
13444 \r
13445 \r
13446 \r
13447 \r
13448 \r
13449 \r
13450 \r
13451 \r
13452 \r
13453 \r
13454 \r
13455 \r
13456 \r
13457 \r
13458 \r
13459 \r
13460 \r
13461 \r
13462 \r
13463 \r
13464 \r
13465 \r
13466 \r
13467 \r
13468 \r
13469 \r
13470 \r
13471 \r
13472 \r
13473 \r
13474 \r
13475 \r
13476 \r
13477 \r
13478 \r
13479 \r
13480 \r
13481 \r
13482 \r
13483 \r
13484 \r
13485 \r
13486 \r
13487 \r
13488 \r
13489 \r
13490 \r
13491 \r
13492 \r
13493 \r
13494 \r
13495 \r
13496 \r
13497 \r
13498 \r
13499 \r
13500 \r
13501 \r
13502 \r
13503 \r
13504 \r
13505 \r
13506 \r
13507 \r
13508 \r
13509 \r
13510 \r
13511 \r
13512 \r
13513 \r
13514 \r
13515 \r
13516 \r
13517 \r
13518 \r
13519 \r
13520 \r
13521 \r
13522 \r
13523 \r
13524 \r
13525 \r
13526 \r
13527 \r
13528 \r
13529 \r
13530 \r
13531 \r
13532 \r
13533 \r
13534 \r
13535 \r
13536 \r
13537 \r
13538 \r
13539 \r
13540 \r
13541 \r
13542 \r
13543 \r
13544 \r
13545 \r
13546 \r
13547 \r
13548 \r
13549 \r
13550 \r
13551 \r
13552 \r
13553 \r
13554 \r
13555 \r
13556 \r
13557 \r
13558 \r
13559 \r
13560 \r
13561 \r
13562 \r
13563 \r
13564 \r
13565 \r
13566 \r
13567 \r
13568 \r
13569 \r
13570 \r
13571 \r
13572 \r
13573 \r
13574 \r
13575 \r
13576 \r
13577 \r
13578 \r
13579 \r
13580 \r
13581 \r
13582 \r
13583 \r
13584 \r
13585 \r
13586 \r
13587 \r
13588 \r
13589 \r
13590 \r
13591 \r
13592 \r
13593 \r
13594 \r
13595 \r
13596 \r
13597 \r
13598 \r
13599 \r
13600 \r
13601 \r
13602 \r
13603 \r
13604 \r
13605 \r
13606 \r
13607 \r
13608 \r
13609 \r
13610 \r
13611 \r
13612 \r
13613 \r
13614 \r
13615 \r
13616 \r
13617 \r
13618 \r
13619 \r
13620 \r
13621 \r
13622 \r
13623 \r
13624 \r
13625 \r
13626 \r
13627 \r
13628 \r
13629 \r
13630 \r
13631 \r
13632 \r
13633 \r
13634 \r
13635 \r
13636 \r
13637 \r
13638 \r
13639 \r
13640 \r
13641 \r
13642 \r
13643 \r
13644 \r
13645 \r
13646 \r
13647 \r
13648 \r
13649 \r
13650 \r
13651 \r
13652 \r
13653 \r
13654 \r
13655 \r
13656 \r
13657 \r
13658 \r
13659 \r
13660 \r
13661 \r
13662 \r
13663 \r
13664 \r
13665 \r
13666 \r
13667 \r
13668 \r
13669 \r
13670 \r
13671 \r
13672 \r
13673 \r
13674 \r
13675 \r
13676 \r
13677 \r
13678 \r
13679 \r
13680 \r
13681 \r
13682 \r
13683 \r
13684 \r
13685 \r
13686 \r
13687 \r
13688 \r
13689 \r
13690 \r
13691 \r
13692 \r
13693 \r
13694 \r
13695 \r
13696 \r
13697 \r
13698 \r
13699 \r
13700 \r
13701 \r
13702 \r
13703 \r
13704 \r
13705 \r
13706 \r
13707 \r
13708 \r
13709 \r
13710 \r
13711 \r
13712 \r
13713 \r
13714 \r
13715 \r
13716 \r
13717 \r
13718 \r
13719 \r
13720 \r
13721 \r
13722 \r
13723 \r
13724 \r
13725 \r
13726 \r
13727 \r
13728 \r
13729 \r
13730 \r
13731 \r
13732 \r
13733 \r
13734 \r
13735 \r
13736 \r
13737 \r
13738 \r
13739 \r
13740 \r
13741 \r
13742 \r
13743 \r
13744 \r
13745 \r
13746 \r
13747 \r
13748 \r
13749 \r
13750 \r
13751 \r
13752 \r
13753 \r
13754 \r
13755 \r
13756 \r
13757 \r
13758 \r
13759 \r
13760 \r
13761 \r
13762 \r
13763 \r
13764 \r
13765 \r
13766 \r
13767 \r
13768 \r
13769 \r
13770 \r
13771 \r
13772 \r
13773 \r
13774 \r
13775 \r
13776 \r
13777 \r
13778 \r
13779 \r
13780 \r
13781 \r
13782 \r
13783 \r
13784 \r
13785 \r
13786 \r
13787 \r
13788 \r
13789 \r
13790 \r
13791 \r
13792 \r
13793 \r
13794 \r
13795 \r
13796 \r
13797 \r
13798 \r
13799 \r
13800 \r
13801 \r
13802 \r
13803 \r
13804 \r
13805 \r
13806 \r
13807 \r
13808 \r
13809 \r
13810 \r
13811 \r
13812 \r
13813 \r
13814 \r
13815 \r
13816 \r
13817 \r
13818 \r
13819 \r
13820 \r
13821 \r
13822 \r
13823 \r
13824 \r
13825 \r
13826 \r
13827 \r
13828 \r
13829 \r
13830 \r
13831 \r
13832 \r
13833 \r
13834 \r
13835 \r
13836 \r
13837 \r
13838 \r
13839 \r
13840 \r
13841 \r
13842 \r
13843 \r
13844 \r
13845 \r
13846 \r
13847 \r
13848 \r
13849 \r
13850 \r
13851 \r
13852 \r
13853 \r
13854 \r
13855 \r
13856 \r
13857 \r
13858 \r
13859 \r
13860 \r
13861 \r
13862 \r
13863 \r
13864 \r
13865 \r
13866 \r
13867 \r
13868 \r
13869 \r
13870 \r
13871 \r
13872 \r
13873 \r
13874 \r
13875 \r
13876 \r
13877 \r
13878 \r
13879 \r
13880 \r
13881 \r
13882 \r
13883 \r
13884 \r
13885 \r
13886 \r
13887 \r
13888 \r
13889 \r
13890 \r
13891 \r
13892 \r
13893 \r
13894 \r
13895 \r
13896 \r
13897 \r
13898 \r
13899 \r
13900 \r
13901 \r
13902 \r
13903 \r
13904 \r
13905 \r
13906 \r
13907 \r
13908 \r
13909 \r
13910 \r
13911 \r
13912 \r
13913 \r
13914 \r
13915 \r
13916 \r
13917 \r
13918 \r
13919 \r
13920 \r
13921 \r
13922 \r
13923 \r
13924 \r
13925 \r
13926 \r
13927 \r
13928 \r
13929 \r
13930 \r
13931 \r
13932 \r
13933 \r
13934 \r
13935 \r
13936 \r
13937 \r
13938 \r
13939 \r
13940 \r
13941 \r
13942 \r
13943 \r
13944 \r
13945 \r
13946 \r
13947 \r
13948 \r
13949 \r
13950 \r
13951 \r
13952 \r
13953 \r
13954 \r
13955 \r
13956 \r
13957 \r
13958 \r
13959 \r
13960 \r
13961 \r
13962 \r
13963 \r
13964 \r
13965 \r
13966 \r
13967 \r
13968 \r
13969 \r
13970 \r
13971 \r
13972 \r
13973 \r
13974 \r
13975 \r
13976 \r
13977 \r
13978 \r
13979 \r
13980 \r
13981 \r
13982 \r
13983 \r
13984 \r
13985 \r
13986 \r
13987 \r
13988 \r
13989 \r
13990 \r
13991 \r
13992 \r
13993 \r
13994 \r
13995 \r
13996 \r
13997 \r
13998 \r
13999 \r
14000 \r
14001 \r
14002 \r
14003 \r
14004 \r
14005 \r
14006 \r
14007 \r
14008 \r
14009 \r
14010 \r
14011 \r
14012 \r
14013 \r
14014 \r
14015 \r
14016 \r
14017 \r
14018 \r
14019 \r
14020 \r
14021 \r
14022 \r
14023 \r
14024 \r
14025 \r
14026 \r
14027 \r
14028 \r
14029 \r
14030 \r
14031 \r
14032 \r
14033 \r
14034 \r
14035 \r
14036 \r
14037 \r
14038 \r
14039 \r
14040 \r
14041 \r
14042 \r
14043 \r
14044 \r
14045 \r
14046 \r
14047 \r
14048 \r
14049 \r
14050 \r
14051 \r
14052 \r
14053 \r
14054 \r
14055 \r
14056 \r
14057 \r
14058 \r
14059 \r
14060 \r
14061 \r
14062 \r
14063 \r
14064 \r
14065 \r
14066 \r
14067 \r
14068 \r
14069 \r
14070 \r
14071 \r
14072 \r
14073 \r
14074 \r
14075 \r
14076 \r
14077 \r
14078 \r
14079 \r
14080 \r
14081 \r
14082 \r
14083 \r
14084 \r
14085 \r
14086 \r
14087 \r
14088 \r
14089 \r
14090 \r
14091 \r
14092 \r
14093 \r
14094 \r
14095 \r
14096 \r
14097 \r
14098 \r
14099 \r
14100 \r
14101 \r
14102 \r
14103 \r
14104 \r
14105 \r
14106 \r
14107 \r
14108 \r
14109 \r
14110 \r
14111 \r
14112 \r
14113 \r
14114 \r
14115 \r
14116 \r
14117 \r
14118 \r
14119 \r
14120 \r
14121 \r
14122 \r
14123 \r
14124 \r
14125 \r
14126 \r
14127 \r
14128 \r
14129 \r
14130 \r
14131 \r
14132 \r
14133 \r
14134 \r
14135 \r
14136 \r
14137 \r
14138 \r
14139 \r
14140 \r
14141 \r
14142 \r
14143 \r
14144 \r
14145 \r
14146 \r
14147 \r
14148 \r
14149 \r
14150 \r
14151 \r
14152 \r
14153 \r
14154 \r
14155 \r
14156 \r
14157 \r
14158 \r
14159 \r
14160 \r
14161 \r
14162 \r
14163 \r
14164 \r
14165 \r
14166 \r
14167 \r
14168 \r
14169 \r
14170 \r
14171 \r
14172 \r
14173 \r
14174 \r
14175 \r
14176 \r
14177 \r
14178 \r
14179 \r
14180 \r
14181 \r
14182 \r
14183 \r
14184 \r
14185 \r
14186 \r
14187 \r
14188 \r
14189 \r
14190 \r
14191 \r
14192 \r
14193 \r
14194 \r
14195 \r
14196 \r
14197 \r
14198 \r
14199 \r
14200 \r
14201 \r
14202 \r
14203 \r
14204 \r
14205 \r
14206 \r
14207 \r
14208 \r
14209 \r
14210 \r
14211 \r
14212 \r
14213 \r
14214 \r
14215 \r
14216 \r
14217 \r
14218 \r
14219 \r
14220 \r
14221 \r
14222 \r
14223 \r
14224 \r
14225 \r
14226 \r
14227 \r
14228 \r
14229 \r
14230 \r
14231 \r
14232 \r
14233 \r
14234 \r
14235 \r
14236 \r
14237 \r
14238 \r
14239 \r
14240 \r
14241 \r
14242 \r
14243 \r
14244 \r
14245 \r
14246 \r
14247 \r
14248 \r
14249 \r
14250 \r
14251 \r
14252 \r
14253 \r
14254 \r
14255 \r
14256 \r
14257 \r
14258 \r
14259 \r
14260 \r
14261 \r
14262 \r
14263 \r
14264 \r
14265 \r
14266 \r
14267 \r
14268 \r
14269 \r
14270 \r
14271 \r
14272 \r
14273 \r
14274 \r
14275 \r
14276 \r
14277 \r
14278 \r
14279 \r
14280 \r
14281 \r
14282 \r
14283 \r
14284 \r
14285 \r
14286 \r
14287 \r
14288 \r
14289 \r
14290 \r
14291 \r
14292 \r
14293 \r
14294 \r
14295 \r
14296 \r
14297 \r
14298 \r
14299 \r
14300 \r
14301 \r
14302 \r
14303 \r
14304 \r
14305 \r
14306 \r
14307 \r
14308 \r
14309 \r
14310 \r
14311 \r
14312 \r
14313 \r
14314 \r
14315 \r
14316 \r
14317 \r
14318 \r
14319 \r
14320 \r
14321 \r
14322 \r
14323 \r
14324 \r
14325 \r
14326 \r
14327 \r
14328 \r
14329 \r
14330 \r
14331 \r
14332 \r
14333 \r
14334 \r
14335 \r
14336 \r
14337 \r
14338 \r
14339 \r
14340 \r
14341 \r
14342 \r
14343 \r
14344 \r
14345 \r
14346 \r
14347 \r
14348 \r
14349 \r
14350 \r
14351 \r
14352 \r
14353 \r
14354 \r
14355 \r
14356 \r
14357 \r
14358 \r
14359 \r
14360 \r
14361 \r
14362 \r
14363 \r
14364 \r
14365 \r
14366 \r
14367 \r
14368 \r
14369 \r
14370 \r
14371 \r
14372 \r
14373 \r
14374 \r
14375 \r
14376 \r
14377 \r
14378 \r
14379 \r
14380 \r
14381 \r
14382 \r
14383 \r
14384 \r
14385 \r
14386 \r
14387 \r
14388 \r
14389 \r
14390 \r
14391 \r
14392 \r
14393 \r
14394 \r
14395 \r
14396 \r
14397 \r
14398 \r
14399 \r
14400 \r
14401 \r
14402 \r
14403 \r
14404 \r
14405 \r
14406 \r
14407 \r
14408 \r
14409 \r
14410 \r
14411 \r
14412 \r
14413 \r
14414 \r
14415 \r
14416 \r
14417 \r
14418 \r
14419 \r
14420 \r
14421 \r
14422 \r
14423 \r
14424 \r
14425 \r
14426 \r
14427 \r
14428 \r
14429 \r
14430 \r
14431 \r
14432 \r
14433 \r
14434 \r
14435 \r
14436 \r
14437 \r
14438 \r
14439 \r
14440 \r
14441 \r
14442 \r
14443 \r
14444 \r
14445 \r
14446 \r
14447 \r
14448 \r
14449 \r
14450 \r
14451 \r
14452 \r
14453 \r
14454 \r
14455 \r
14456 \r
14457 \r
14458 \r
14459 \r
14460 \r
14461 \r
14462 \r
14463 \r
14464 \r
14465 \r
14466 \r
14467 \r
14468 \r
14469 \r
14470 \r
14471 \r
14472 \r
14473 \r
14474 \r
14475 \r
14476 \r
14477 \r
14478 \r
14479 \r
14480 \r
14481 \r
14482 \r
14483 \r
14484 \r
14485 \r
14486 \r
14487 \r
14488 \r
14489 \r
14490 \r
14491 \r
14492 \r
14493 \r
14494 \r
14495 \r
14496 \r
14497 \r
14498 \r
14499 \r
14500 \r
14501 \r
14502 \r
14503 \r
14504 \r
14505 \r
14506 \r
14507 \r
14508 \r
14509 \r
14510 \r
14511 \r
14512 \r
14513 \r
14514 \r
14515 \r
14516 \r
14517 \r
14518 \r
14519 \r
14520 \r
14521 \r
14522 \r
14523 \r
14524 \r
14525 \r
14526 \r
14527 \r
14528 \r
14529 \r
14530 \r
14531 \r
14532 \r
14533 \r
14534 \r
14535 \r
14536 \r
14537 \r
14538 \r
14539 \r
14540 \r
14541 \r
14542 \r
14543 \r
14544 \r
14545 \r
14546 \r
14547 \r
14548 \r
14549 \r
14550 \r
14551 \r
14552 \r
14553 \r
14554 \r
14555 \r
14556 \r
14557 \r
14558 \r
14559 \r
14560 \r
14561 \r
14562 \r
14563 \r
14564 \r
14565 \r
14566 \r
14567 \r
14568 \r
14569 \r
14570 \r
14571 \r
14572 \r
14573 \r
14574 \r
14575 \r
14576 \r
14577 \r
14578 \r
14579 \r
14580 \r
14581 \r
14582 \r
14583 \r
14584 \r
14585 \r
14586 \r
14587 \r
14588 \r
14589 \r
14590 \r
14591 \r
14592 \r
14593 \r
14594 \r
14595 \r
14596 \r
14597 \r
14598 \r
14599 \r
14600 \r
14601 \r
14602 \r
14603 \r
14604 \r
14605 \r
14606 \r
14607 \r
14608 \r
14609 \r
14610 \r
14611 \r
14612 \r
14613 \r
14614 \r
14615 \r
14616 \r
14617 \r
14618 \r
14619 \r
14620 \r
14621 \r
14622 \r
14623 \r
14624 \r
14625 \r
14626 \r
14627 \r
14628 \r
14629 \r
14630 \r
14631 \r
14632 \r
14633 \r
14634 \r
14635 \r
14636 \r
14637 \r
14638 \r
14639 \r
14640 \r
14641 \r
14642 \r
14643 \r
14644 \r
14645 \r
14646 \r
14647 \r
14648 \r
14649 \r
14650 \r
14651 \r
14652 \r
14653 \r
14654 \r
14655 \r
14656 \r
14657 \r
14658 \r
14659 \r
14660 \r
14661 \r
14662 \r
14663 \r
14664 \r
14665 \r
14666 \r
14667 \r
14668 \r
14669 \r
14670 \r
14671 \r
14672 \r
14673 \r
14674 \r
14675 \r
14676 \r
14677 \r
14678 \r
14679 \r
14680 \r
14681 \r
14682 \r
14683 \r
14684 \r
14685 \r
14686 \r
14687 \r
14688 \r
14689 \r
14690 \r
14691 \r
14692 \r
14693 \r
14694 \r
14695 \r
14696 \r
14697 \r
14698 \r
14699 \r
14700 \r
14701 \r
14702 \r
14703 \r
14704 \r
14705 \r
14706 \r
14707 \r
14708 \r
14709 \r
14710 \r
14711 \r
14712 \r
14713 \r
14714 \r
14715 \r
14716 \r
14717 \r
14718 \r
14719 \r
14720 \r
14721 \r
14722 \r
14723 \r
14724 \r
14725 \r
14726 \r
14727 \r
14728 \r
14729 \r
14730 \r
14731 \r
14732 \r
14733 \r
14734 \r
14735 \r
14736 \r
14737 \r
14738 \r
14739 \r
14740 \r
14741 \r
14742 \r
14743 \r
14744 \r
14745 \r
14746 \r
14747 \r
14748 \r
14749 \r
14750 \r
14751 \r
14752 \r
14753 \r
14754 \r
14755 \r
14756 \r
14757 \r
14758 \r
14759 \r
14760 \r
14761 \r
14762 \r
14763 \r
14764 \r
14765 \r
14766 \r
14767 \r
14768 \r
14769 \r
14770 \r
14771 \r
14772 \r
14773 \r
14774 \r
14775 \r
14776 \r
14777 \r
14778 \r
14779 \r
14780 \r
14781 \r
14782 \r
14783 \r
14784 \r
14785 \r
14786 \r
14787 \r
14788 \r
14789 \r
14790 \r
14791 \r
14792 \r
14793 \r
14794 \r
14795 \r
14796 \r
14797 \r
14798 \r
14799 \r
14800 \r
14801 \r
14802 \r
14803 \r
14804 \r
14805 \r
14806 \r
14807 \r
14808 \r
14809 \r
14810 \r
14811 \r
14812 \r
14813 \r
14814 \r
14815 \r
14816 \r
14817 \r
14818 \r
14819 \r
14820 \r
14821 \r
14822 \r
14823 \r
14824 \r
14825 \r
14826 \r
14827 \r
14828 \r
14829 \r
14830 \r
14831 \r
14832 \r
14833 \r
14834 \r
14835 \r
14836 \r
14837 \r
14838 \r
14839 \r
14840 \r
14841 \r
14842 \r
14843 \r
14844 \r
14845 \r
14846 \r
14847 \r
14848 \r
14849 \r
14850 \r
14851 \r
14852 \r
14853 \r
14854 \r
14855 \r
14856 \r
14857 \r
14858 \r
14859 \r
14860 \r
14861 \r
14862 \r
14863 \r
14864 \r
14865 \r
14866 \r
14867 \r
14868 \r
14869 \r
14870 \r
14871 \r
14872 \r
14873 \r
14874 \r
14875 \r
14876 \r
14877 \r
14878 \r
14879 \r
14880 \r
14881 \r
14882 \r
14883 \r
14884 \r
14885 \r
14886 \r
14887 \r
14888 \r
14889 \r
14890 \r
14891 \r
14892 \r
14893 \r
14894 \r
14895 \r
14896 \r
14897 \r
14898 \r
14899 \r
14900 \r
14901 \r
14902 \r
14903 \r
14904 \r
14905 \r
14906 \r
14907 \r
14908 \r
14909 \r
14910 \r
14911 \r
14912 \r
14913 \r
14914 \r
14915 \r
14916 \r
14917 \r
14918 \r
14919 \r
14920 \r
14921 \r
14922 \r
14923 \r
14924 \r
14925 \r
14926 \r
14927 \r
14928 \r
14929 \r
14930 \r
14931 \r
14932 \r
14933 \r
14934 \r
14935 \r
14936 \r
14937 \r
14938 \r
14939 \r
14940 \r
14941 \r
14942 \r
14943 \r
14944 \r
14945 \r
14946 \r
14947 \r
14948 \r
14949 \r
14950 \r
14951 \r
14952 \r
14953 \r
14954 \r
14955 \r
14956 \r
14957 \r
14958 \r
14959 \r
14960 \r
14961 \r
14962 \r
14963 \r
14964 \r
14965 \r
14966 \r
14967 \r
14968 \r
14969 \r
14970 \r
14971 \r
14972 \r
14973 \r
14974 \r
14975 \r
14976 \r
14977 \r
14978 \r
14979 \r
14980 \r
14981 \r
14982 \r
14983 \r
14984 \r
14985 \r
14986 \r
14987 \r
14988 \r
14989 \r
14990 \r
14991 \r
14992 \r
14993 \r
14994 \r
14995 \r
14996 \r
14997 \r
14998 \r
14999 \r
15000 \r
15001 \r
15002 \r
15003 \r
15004 \r
15005 \r
15006 \r
15007 \r
15008 \r
15009 \r
15010 \r
15011 \r
15012 \r
15013 \r
15014 \r
15015 \r
15016 \r
15017 \r
15018 \r
15019 \r
15020 \r
15021 \r
15022 \r
15023 \r
15024 \r
15025 \r
15026 \r
15027 \r
15028 \r
15029 \r
15030 \r
15031 \r
15032 \r
15033 \r
15034 \r
15035 \r
15036 \r
15037 \r
15038 \r
15039 \r
15040 \r
15041 \r
15042 \r
15043 \r
15044 \r
15045 \r
15046 \r
15047 \r
15048 \r
15049 \r
15050 \r
15051 \r
15052 \r
15053 \r
15054 \r
15055 \r
15056 \r
15057 \r
15058 \r
15059 \r
15060 \r
15061 \r
15062 \r
15063 \r
15064 \r
15065 \r
15066 \r
15067 \r
15068 \r
15069 \r
15070 \r
15071 \r
15072 \r
15073 \r
15074 \r
15075 \r
15076 \r
15077 \r
15078 \r
15079 \r
15080 \r
15081 \r
15082 \r
15083 \r
15084 \r
15085 \r
15086 \r
15087 \r
15088 \r
15089 \r
15090 \r
15091 \r
15092 \r
15093 \r
15094 \r
15095 \r
15096 \r
15097 \r
15098 \r
15099 \r
15100 \r
15101 \r
15102 \r
15103 \r
15104 \r
15105 \r
15106 \r
15107 \r
15108 \r
15109 \r
15110 \r
15111 \r
15112 \r
15113 \r
15114 \r
15115 \r
15116 \r
15117 \r
15118 \r
15119 \r
15120 \r
15121 \r
15122 \r
15123 \r
15124 \r
15125 \r
15126 \r
15127 \r
15128 \r
15129 \r
15130 \r
15131 \r
15132 \r
15133 \r
15134 \r
15135 \r
15136 \r
15137 \r
15138 \r
15139 \r
15140 \r
15141 \r
15142 \r
15143 \r
15144 \r
15145 \r
15146 \r
15147 \r
15148 \r
15149 \r
15150 \r
15151 \r
15152 \r
15153 \r
15154 \r
15155 \r
15156 \r
15157 \r
15158 \r
15159 \r
15160 \r
15161 \r
15162 \r
15163 \r
15164 \r
15165 \r
15166 \r
15167 \r
15168 \r
15169 \r
15170 \r
15171 \r
15172 \r
15173 \r
15174 \r
15175 \r
15176 \r
15177 \r
15178 \r
15179 \r
15180 \r
15181 \r
15182 \r
15183 \r
15184 \r
15185 \r
15186 \r
15187 \r
15188 \r
15189 \r
15190 \r
15191 \r
15192 \r
15193 \r
15194 \r
15195 \r
15196 \r
15197 \r
15198 \r
15199 \r
15200 \r
15201 \r
15202 \r
15203 \r
15204 \r
15205 \r
15206 \r
15207 \r
15208 \r
15209 \r
15210 \r
15211 \r
15212 \r
15213 \r
15214 \r
15215 \r
15216 \r
15217 \r
15218 \r
15219 \r
15220 \r
15221 \r
15222 \r
15223 \r
15224 \r
15225 \r
15226 \r
15227 \r
15228 \r
15229 \r
15230 \r
15231 \r
15232 \r
15233 \r
15234 \r
15235 \r
15236 \r
15237 \r
15238 \r
15239 \r
15240 \r
15241 \r
15242 \r
15243 \r
15244 \r
15245 \r
15246 \r
15247 \r
15248 \r
15249 \r
15250 \r
15251 \r
15252 \r
15253 \r
15254 \r
15255 \r
15256 \r
15257 \r
15258 \r
15259 \r
15260 \r
15261 \r
15262 \r
15263 \r
15264 \r
15265 \r
15266 \r
15267 \r
15268 \r
15269 \r
15270 \r
15271 \r
15272 \r
15273 \r
15274 \r
15275 \r
15276 \r
15277 \r
15278 \r
15279 \r
15280 \r
15281 \r
15282 \r
15283 \r
15284 \r
15285 \r
15286 \r
15287 \r
15288 \r
15289 \r
15290 \r
15291 \r
15292 \r
15293 \r
15294 \r
15295 \r
15296 \r
15297 \r
15298 \r
15299 \r
15300 \r
15301 \r
15302 \r
15303 \r
15304 \r
15305 \r
15306 \r
15307 \r
15308 \r
15309 \r
15310 \r
15311 \r
15312 \r
15313 \r
15314 \r
15315 \r
15316 \r
15317 \r
15318 \r
15319 \r
15320 \r
15321 \r
15322 \r
15323 \r
15324 \r
15325 \r
15326 \r
15327 \r
15328 \r
15329 \r
15330 \r
15331 \r
15332 \r
15333 \r
15334 \r
15335 \r
15336 \r
15337 \r
15338 \r
15339 \r
15340 \r
15341 \r
15342 \r
15343 \r
15344 \r
15345 \r
15346 \r
15347 \r
15348 \r
15349 \r
15350 \r
15351 \r
15352 \r
15353 \r
15354 \r
15355 \r
15356 \r
15357 \r
15358 \r
15359 \r
15360 \r
15361 \r
15362 \r
15363 \r
15364 \r
15365 \r
15366 \r
15367 \r
15368 \r
15369 \r
15370 \r
15371 \r
15372 \r
15373 \r
15374 \r
15375 \r
15376 \r
15377 \r
15378 \r
15379 \r
15380 \r
15381 \r
15382 \r
15383 \r
15384 \r
15385 \r
15386 \r
15387 \r
15388 \r
15389 \r
15390 \r
15391 \r
15392 \r
15393 \r
15394 \r
15395 \r
15396 \r
15397 \r
15398 \r
15399 \r
15400 \r
15401 \r
15402 \r
15403 \r
15404 \r
15405 \r
15406 \r
15407 \r
15408 \r
15409 \r
15410 \r
15411 \r
15412 \r
15413 \r
15414 \r
15415 \r
15416 \r
15417 \r
15418 \r
15419 \r
15420 \r
15421 \r
15422 \r
15423 \r
15424 \r
15425 \r
15426 \r
15427 \r
15428 \r
15429 \r
15430 \r
15431 \r
15432 \r
15433 \r
15434 \r
15435 \r
15436 \r
15437 \r
15438 \r
15439 \r
15440 \r
15441 \r
15442 \r
15443 \r
15444 \r
15445 \r
15446 \r
15447 \r
15448 \r
15449 \r
15450 \r
15451 \r
15452 \r
15453 \r
15454 \r
15455 \r
15456 \r
15457 \r
15458 \r
15459 \r
15460 \r
15461 \r
15462 \r
15463 \r
15464 \r
15465 \r
15466 \r
15467 \r
15468 \r
15469 \r
15470 \r
15471 \r
15472 \r
15473 \r
15474 \r
15475 \r
15476 \r
15477 \r
15478 \r
15479 \r
15480 \r
15481 \r
15482 \r
15483 \r
15484 \r
15485 \r
15486 \r
15487 \r
15488 \r
15489 \r
15490 \r
15491 \r
15492 \r
15493 \r
15494 \r
15495 \r
15496 \r
15497 \r
15498 \r
15499 \r
15500 \r
15501 \r
15502 \r
15503 \r
15504 \r
15505 \r
15506 \r
15507 \r
15508 \r
15509 \r
15510 \r
15511 \r
15512 \r
15513 \r
15514 \r
15515 \r
15516 \r
15517 \r
15518 \r
15519 \r
15520 \r
15521 \r
15522 \r
15523 \r
15524 \r
15525 \r
15526 \r
15527 \r
15528 \r
15529 \r
15530 \r
15531 \r
15532 \r
15533 \r
15534 \r
15535 \r
15536 \r
15537 \r
15538 \r
15539 \r
15540 \r
15541 \r
15542 \r
15543 \r
15544 \r
15545 \r
15546 \r
15547 \r
15548 \r
15549 \r
15550 \r
15551 \r
15552 \r
15553 \r
15554 \r
15555 \r
15556 \r
15557 \r
15558 \r
15559 \r
15560 \r
15561 \r
15562 \r
15563 \r
15564 \r
15565 \r
15566 \r
15567 \r
15568 \r
15569 \r
15570 \r
15571 \r
15572 \r
15573 \r
15574 \r
15575 \r
15576 \r
15577 \r
15578 \r
15579 \r
15580 \r
15581 \r
15582 \r
15583 \r
15584 \r
15585 \r
15586 \r
15587 \r
15588 \r
15589 \r
15590 \r
15591 \r
15592 \r
15593 \r
15594 \r
15595 \r
15596 \r
15597 \r
15598 \r
15599 \r
15600 \r
15601 \r
15602 \r
15603 \r
15604 \r
15605 \r
15606 \r
15607 \r
15608 \r
15609 \r
15610 \r
15611 \r
15612 \r
15613 \r
15614 \r
15615 \r
15616 \r
15617 \r
15618 \r
15619 \r
15620 \r
15621 \r
15622 \r
15623 \r
15624 \r
15625 \r
15626 \r
15627 \r
15628 \r
15629 \r
15630 \r
15631 \r
15632 \r
15633 \r
15634 \r
15635 \r
15636 \r
15637 \r
15638 \r
15639 \r
15640 \r
15641 \r
15642 \r
15643 \r
15644 \r
15645 \r
15646 \r
15647 \r
15648 \r
15649 \r
15650 \r
15651 \r
15652 \r
15653 \r
15654 \r
15655 \r
15656 \r
15657 \r
15658 \r
15659 \r
15660 \r
15661 \r
15662 \r
15663 \r
15664 \r
15665 \r
15666 \r
15667 \r
15668 \r
15669 \r
15670 \r
15671 \r
15672 \r
15673 \r
15674 \r
15675 \r
15676 \r
15677 \r
15678 \r
15679 \r
15680 \r
15681 \r
15682 \r
15683 \r
15684 \r
15685 \r
15686 \r
15687 \r
15688 \r
15689 \r
15690 \r
15691 \r
15692 \r
15693 \r
15694 \r
15695 \r
15696 \r
15697 \r
15698 \r
15699 \r
15700 \r
15701 \r
15702 \r
15703 \r
15704 \r
15705 \r
15706 \r
15707 \r
15708 \r
15709 \r
15710 \r
15711 \r
15712 \r
15713 \r
15714 \r
15715 \r
15716 \r
15717 \r
15718 \r
15719 \r
15720 \r
15721 \r
15722 \r
15723 \r
15724 \r
15725 \r
15726 \r
15727 \r
15728 \r
15729 \r
15730 \r
15731 \r
15732 \r
15733 \r
15734 \r
15735 \r
15736 \r
15737 \r
15738 \r
15739 \r
15740 \r
15741 \r
15742 \r
15743 \r
15744 \r
15745 \r
15746 \r
15747 \r
15748 \r
15749 \r
15750 \r
15751 \r
15752 \r
15753 \r
15754 \r
15755 \r
15756 \r
15757 \r
15758 \r
15759 \r
15760 \r
15761 \r
15762 \r
15763 \r
15764 \r
15765 \r
15766 \r
15767 \r
15768 \r
15769 \r
15770 \r
15771 \r
15772 \r
15773 \r
15774 \r
15775 \r
15776 \r
15777 \r
15778 \r
15779 \r
15780 \r
15781 \r
15782 \r
15783 \r
15784 \r
15785 \r
15786 \r
15787 \r
15788 \r
15789 \r
15790 \r
15791 \r
15792 \r
15793 \r
15794 \r
15795 \r
15796 \r
15797 \r
15798 \r
15799 \r
15800 \r
15801 \r
15802 \r
15803 \r
15804 \r
15805 \r
15806 \r
15807 \r
15808 \r
15809 \r
15810 \r
15811 \r
15812 \r
15813 \r
15814 \r
15815 \r
15816 \r
15817 \r
15818 \r
15819 \r
15820 \r
15821 \r
15822 \r
15823 \r
15824 \r
15825 \r
15826 \r
15827 \r
15828 \r
15829 \r
15830 \r
15831 \r
15832 \r
15833 \r
15834 \r
15835 \r
15836 \r
15837 \r
15838 \r
15839 \r
15840 \r
15841 \r
15842 \r
15843 \r
15844 \r
15845 \r
15846 \r
15847 \r
15848 \r
15849 \r
15850 \r
15851 \r
15852 \r
15853 \r
15854 \r
15855 \r
15856 \r
15857 \r
15858 \r
15859 \r
15860 \r
15861 \r
15862 \r
15863 \r
15864 \r
15865 \r
15866 \r
15867 \r
15868 \r
15869 \r
15870 \r
15871 \r
15872 \r
15873 \r
15874 \r
15875 \r
15876 \r
15877 \r
15878 \r
15879 \r
15880 \r
15881 \r
15882 \r
15883 \r
15884 \r
15885 \r
15886 \r
15887 \r
15888 \r
15889 \r
15890 \r
15891 \r
15892 \r
15893 \r
15894 \r
15895 \r
15896 \r
15897 \r
15898 \r
15899 \r
15900 \r
15901 \r
15902 \r
15903 \r
15904 \r
15905 \r
15906 \r
15907 \r
15908 \r
15909 \r
15910 \r
15911 \r
15912 \r
15913 \r
15914 \r
15915 \r
15916 \r
15917 \r
15918 \r
15919 \r
15920 \r
15921 \r
15922 \r
15923 \r
15924 \r
15925 \r
15926 \r
15927 \r
15928 \r
15929 \r
15930 \r
15931 \r
15932 \r
15933 \r
15934 \r
15935 \r
15936 \r
15937 \r
15938 \r
15939 \r
15940 \r
15941 \r
15942 \r
15943 \r
15944 \r
15945 \r
15946 \r
15947 \r
15948 \r
15949 \r
15950 \r
15951 \r
15952 \r
15953 \r
15954 \r
15955 \r
15956 \r
15957 \r
15958 \r
15959 \r
15960 \r
15961 \r
15962 \r
15963 \r
15964 \r
15965 \r
15966 \r
15967 \r
15968 \r
15969 \r
15970 \r
15971 \r
15972 \r
15973 \r
15974 \r
15975 \r
15976 \r
15977 \r
15978 \r
15979 \r
15980 \r
15981 \r
15982 \r
15983 \r
15984 \r
15985 \r
15986 \r
15987 \r
15988 \r
15989 \r
15990 \r
15991 \r
15992 \r
15993 \r
15994 \r
15995 \r
15996 \r
15997 \r
15998 \r
15999 \r
16000 \r
16001 \r
16002 \r
16003 \r
16004 \r
16005 \r
16006 \r
16007 \r
16008 \r
16009 \r
16010 \r
16011 \r
16012 \r
16013 \r
16014 \r
16015 \r
16016 \r
16017 \r
16018 \r
16019 \r
16020 \r
16021 \r
16022 \r
16023 \r
16024 \r
16025 \r
16026 \r
16027 \r
16028 \r
16029 \r
16030 \r
16031 \r
16032 \r
16033 \r
16034 \r
16035 \r
16036 \r
16037 \r
16038 \r
16039 \r
16040 \r
16041 \r
16042 \r
16043 \r
16044 \r
16045 \r
16046 \r
16047 \r
16048 \r
16049 \r
16050 \r
16051 \r
16052 \r
16053 \r
16054 \r
16055 \r
16056 \r
16057 \r
16058 \r
16059 \r
16060 \r
16061 \r
16062 \r
16063 \r
16064 \r
16065 \r
16066 \r
16067 \r
16068 \r
16069 \r
16070 \r
16071 \r
16072 \r
16073 \r
16074 \r
16075 \r
16076 \r
16077 \r
16078 \r
16079 \r
16080 \r
16081 \r
16082 \r
16083 \r
16084 \r
16085 \r
16086 \r
16087 \r
16088 \r
16089 \r
16090 \r
16091 \r
16092 \r
16093 \r
16094 \r
16095 \r
16096 \r
16097 \r
16098 \r
16099 \r
16100 \r
16101 \r
16102 \r
16103 \r
16104 \r
16105 \r
16106 \r
16107 \r
16108 \r
16109 \r
16110 \r
16111 \r
16112 \r
16113 \r
16114 \r
16115 \r
16116 \r
16117 \r
16118 \r
16119 \r
16120 \r
16121 \r
16122 \r
16123 \r
16124 \r
16125 \r
16126 \r
16127 \r
16128 \r
16129 \r
16130 \r
16131 \r
16132 \r
16133 \r
16134 \r
16135 \r
16136 \r
16137 \r
16138 \r
16139 \r
16140 \r
16141 \r
16142 \r
16143 \r
16144 \r
16145 \r
16146 \r
16147 \r
16148 \r
16149 \r
16150 \r
16151 \r
16152 \r
16153 \r
16154 \r
16155 \r
16156 \r
16157 \r
16158 \r
16159 \r
16160 \r
16161 \r
16162 \r
16163 \r
16164 \r
16165 \r
16166 \r
16167 \r
16168 \r
16169 \r
16170 \r
16171 \r
16172 \r
16173 \r
16174 \r
16175 \r
16176 \r
16177 \r
16178 \r
16179 \r
16180 \r
16181 \r
16182 \r
16183 \r
16184 \r
16185 \r
16186 \r
16187 \r
16188 \r
16189 \r
16190 \r
16191 \r
16192 \r
16193 \r
16194 \r
16195 \r
16196 \r
16197 \r
16198 \r
16199 \r
16200 \r
16201 \r
16202 \r
16203 \r
16204 \r
16205 \r
16206 \r
16207 \r
16208 \r
16209 \r
16210 \r
16211 \r
16212 \r
16213 \r
16214 \r
16215 \r
16216 \r
16217 \r
16218 \r
16219 \r
16220 \r
16221 \r
16222 \r
16223 \r
16224 \r
16225 \r
16226 \r
16227 \r
16228 \r
16229 \r
16230 \r
16231 \r
16232 \r
16233 \r
16234 \r
16235 \r
16236 \r
16237 \r
16238 \r
16239 \r
16240 \r
16241 \r
16242 \r
16243 \r
16244 \r
16245 \r
16246 \r
16247 \r
16248 \r
16249 \r
16250 \r
16251 \r
16252 \r
16253 \r
16254 \r
16255 \r
16256 \r
16257 \r
16258 \r
16259 \r
16260 \r
16261 \r
16262 \r
16263 \r
16264 \r
16265 \r
16266 \r
16267 \r
16268 \r
16269 \r
16270 \r
16271 \r
16272 \r
16273 \r
16274 \r
16275 \r
16276 \r
16277 \r
16278 \r
16279 \r
16280 \r
16281 \r
16282 \r
16283 \r
16284 \r
16285 \r
16286 \r
16287 \r
16288 \r
16289 \r
16290 \r
16291 \r
16292 \r
16293 \r
16294 \r
16295 \r
16296 \r
16297 \r
16298 \r
16299 \r
16300 \r
16301 \r
16302 \r
16303 \r
16304 \r
16305 \r
16306 \r
16307 \r
16308 \r
16309 \r
16310 \r
16311 \r
16312 \r
16313 \r
16314 \r
16315 \r
16316 \r
16317 \r
16318 \r
16319 \r
16320 \r
16321 \r
16322 \r
16323 \r
16324 \r
16325 \r
16326 \r
16327 \r
16328 \r
16329 \r
16330 \r
16331 \r
16332 \r
16333 \r
16334 \r
16335 \r
16336 \r
16337 \r
16338 \r
16339 \r
16340 \r
16341 \r
16342 \r
16343 \r
16344 \r
16345 \r
16346 \r
16347 \r
16348 \r
16349 \r
16350 \r
16351 \r
16352 \r
16353 \r
16354 \r
16355 \r
16356 \r
16357 \r
16358 \r
16359 \r
16360 \r
16361 \r
16362 \r
16363 \r
16364 \r
16365 \r
16366 \r
16367 \r
16368 \r
16369 \r
16370 \r
16371 \r
16372 \r
16373 \r
16374 \r
16375 \r
16376 \r
16377 \r
16378 \r
16379 \r
16380 \r
16381 \r
16382 \r
16383 \r
16384 \r
16385 \r
16386 \r
16387 \r
16388 \r
16389 \r
16390 \r
16391 \r
16392 \r
16393 \r
16394 \r
16395 \r
16396 \r
16397 \r
16398 \r
16399 \r
16400 \r
16401 \r
16402 \r
16403 \r
16404 \r
16405 \r
16406 \r
16407 \r
16408 \r
16409 \r
16410 \r
16411 \r
16412 \r
16413 \r
16414 \r
16415 \r
16416 \r
16417 \r
16418 \r
16419 \r
16420 \r
16421 \r
16422 \r
16423 \r
16424 \r
16425 \r
16426 \r
16427 \r
16428 \r
16429 \r
16430 \r
16431 \r
16432 \r
16433 \r
16434 \r
16435 \r
16436 \r
16437 \r
16438 \r
16439 \r
16440 \r
16441 \r
16442 \r
16443 \r
16444 \r
16445 \r
16446 \r
16447 \r
16448 \r
16449 \r
16450 \r
16451 \r
16452 \r
16453 \r
16454 \r
16455 \r
16456 \r
16457 \r
16458 \r
16459 \r
16460 \r
16461 \r
16462 \r
16463 \r
16464 \r
16465 \r
16466 \r
16467 \r
16468 \r
16469 \r
16470 \r
16471 \r
16472 \r
16473 \r
16474 \r
16475 \r
16476 \r
16477 \r
16478 \r
16479 \r
16480 \r
16481 \r
16482 \r
16483 \r
16484 \r
16485 \r
16486 \r
16487 \r
16488 \r
16489 \r
16490 \r
16491 \r
16492 \r
16493 \r
16494 \r
16495 \r
16496 \r
16497 \r
16498 \r
16499 \r
16500 \r
16501 \r
16502 \r
16503 \r
16504 \r
16505 \r
16506 \r
16507 \r
16508 \r
16509 \r
16510 \r
16511 \r
16512 \r
16513 \r
16514 \r
16515 \r
16516 \r
16517 \r
16518 \r
16519 \r
16520 \r
16521 \r
16522 \r
16523 \r
16524 \r
16525 \r
16526 \r
16527 \r
16528 \r
16529 \r
16530 \r
16531 \r
16532 \r
16533 \r
16534 \r
16535 \r
16536 \r
16537 \r
16538 \r
16539 \r
16540 \r
16541 \r
16542 \r
16543 \r
16544 \r
16545 \r
16546 \r
16547 \r
16548 \r
16549 \r
16550 \r
16551 \r
16552 \r
16553 \r
16554 \r
16555 \r
16556 \r
16557 \r
16558 \r
16559 \r
16560 \r
16561 \r
16562 \r
16563 \r
16564 \r
16565 \r
16566 \r
16567 \r
16568 \r
16569 \r
16570 \r
16571 \r
16572 \r
16573 \r
16574 \r
16575 \r
16576 \r
16577 \r
16578 \r
16579 \r
16580 \r
16581 \r
16582 \r
16583 \r
16584 \r
16585 \r
16586 \r
16587 \r
16588 \r
16589 \r
16590 \r
16591 \r
16592 \r
16593 \r
16594 \r
16595 \r
16596 \r
16597 \r
16598 \r
16599 \r
16600 \r
16601 \r
16602 \r
16603 \r
16604 \r
16605 \r
16606 \r
16607 \r
16608 \r
16609 \r
16610 \r
16611 \r
16612 \r
16613 \r
16614 \r
16615 \r
16616 \r
16617 \r
16618 \r
16619 \r
16620 \r
16621 \r
16622 \r
16623 \r
16624 \r
16625 \r
16626 \r
16627 \r
16628 \r
16629 \r
16630 \r
16631 \r
16632 \r
16633 \r
16634 \r
16635 \r
16636 \r
16637 \r
16638 \r
16639 \r
16640 \r
16641 \r
16642 \r
16643 \r
16644 \r
16645 \r
16646 \r
16647 \r
16648 \r
16649 \r
16650 \r
16651 \r
16652 \r
16653 \r
16654 \r
16655 \r
16656 \r
16657 \r
16658 \r
16659 \r
16660 \r
16661 \r
16662 \r
16663 \r
16664 \r
16665 \r
16666 \r
16667 \r
16668 \r
16669 \r
16670 \r
16671 \r
16672 \r
16673 \r
16674 \r
16675 \r
16676 \r
16677 \r
16678 \r
16679 \r
16680 \r
16681 \r
16682 \r
16683 \r
16684 \r
16685 \r
16686 \r
16687 \r
16688 \r
16689 \r
16690 \r
16691 \r
16692 \r
16693 \r
16694 \r
16695 \r
16696 \r
16697 \r
16698 \r
16699 \r
16700 \r
16701 \r
16702 \r
16703 \r
16704 \r
16705 \r
16706 \r
16707 \r
16708 \r
16709 \r
16710 \r
16711 \r
16712 \r
16713 \r
16714 \r
16715 \r
16716 \r
16717 \r
16718 \r
16719 \r
16720 \r
16721 \r
16722 \r
16723 \r
16724 \r
16725 \r
16726 \r
16727 \r
16728 \r
16729 \r
16730 \r
16731 \r
16732 \r
16733 \r
16734 \r
16735 \r
16736 \r
16737 \r
16738 \r
16739 \r
16740 \r
16741 \r
16742 \r
16743 \r
16744 \r
16745 \r
16746 \r
16747 \r
16748 \r
16749 \r
16750 \r
16751 \r
16752 \r
16753 \r
16754 \r
16755 \r
16756 \r
16757 \r
16758 \r
16759 \r
16760 \r
16761 \r
16762 \r
16763 \r
16764 \r
16765 \r
16766 \r
16767 \r
16768 \r
16769 \r
16770 \r
16771 \r
16772 \r
16773 \r
16774 \r
16775 \r
16776 \r
16777 \r
16778 \r
16779 \r
16780 \r
16781 \r
16782 \r
16783 \r
16784 \r
16785 \r
16786 \r
16787 \r
16788 \r
16789 \r
16790 \r
16791 \r
16792 \r
16793 \r
16794 \r
16795 \r
16796 \r
16797 \r
16798 \r
16799 \r
16800 \r
16801 \r
16802 \r
16803 \r
16804 \r
16805 \r
16806 \r
16807 \r
16808 \r
16809 \r
16810 \r
16811 \r
16812 \r
16813 \r
16814 \r
16815 \r
16816 \r
16817 \r
16818 \r
16819 \r
16820 \r
16821 \r
16822 \r
16823 \r
16824 \r
16825 \r
16826 \r
16827 \r
16828 \r
16829 \r
16830 \r
16831 \r
16832 \r
16833 \r
16834 \r
16835 \r
16836 \r
16837 \r
16838 \r
16839 \r
16840 \r
16841 \r
16842 \r
16843 \r
16844 \r
16845 \r
16846 \r
16847 \r
16848 \r
16849 \r
16850 \r
16851 \r
16852 \r
16853 \r
16854 \r
16855 \r
16856 \r
16857 \r
16858 \r
16859 \r
16860 \r
16861 \r
16862 \r
16863 \r
16864 \r
16865 \r
16866 \r
16867 \r
16868 \r
16869 \r
16870 \r
16871 \r
16872 \r
16873 \r
16874 \r
16875 \r
16876 \r
16877 \r
16878 \r
16879 \r
16880 \r
16881 \r
16882 \r
16883 \r
16884 \r
16885 \r
16886 \r
16887 \r
16888 \r
16889 \r
16890 \r
16891 \r
16892 \r
16893 \r
16894 \r
16895 \r
16896 \r
16897 \r
16898 \r
16899 \r
16900 \r
16901 \r
16902 \r
16903 \r
16904 \r
16905 \r
16906 \r
16907 \r
16908 \r
16909 \r
16910 \r
16911 \r
16912 \r
16913 \r
16914 \r
16915 \r
16916 \r
16917 \r
16918 \r
16919 \r
16920 \r
16921 \r
16922 \r
16923 \r
16924 \r
16925 \r
16926 \r
16927 \r
16928 \r
16929 \r
16930 \r
16931 \r
16932 \r
16933 \r
16934 \r
16935 \r
16936 \r
16937 \r
16938 \r
16939 \r
16940 \r
16941 \r
16942 \r
16943 \r
16944 \r
16945 \r
16946 \r
16947 \r
16948 \r
16949 \r
16950 \r
16951 \r
16952 \r
16953 \r
16954 \r
16955 \r
16956 \r
16957 \r
16958 \r
16959 \r
16960 \r
16961 \r
16962 \r
16963 \r
16964 \r
16965 \r
16966 \r
16967 \r
16968 \r
16969 \r
16970 \r
16971 \r
16972 \r
16973 \r
16974 \r
16975 \r
16976 \r
16977 \r
16978 \r
16979 \r
16980 \r
16981 \r
16982 \r
16983 \r
16984 \r
16985 \r
16986 \r
16987 \r
16988 \r
16989 \r
16990 \r
16991 \r
16992 \r
16993 \r
16994 \r
16995 \r
16996 \r
16997 \r
16998 \r
16999 \r
17000 \r
17001 \r
17002 \r
17003 \r
17004 \r
17005 \r
17006 \r
17007 \r
17008 \r
17009 \r
17010 \r
17011 \r
17012 \r
17013 \r
17014 \r
17015 \r
17016 \r
17017 \r
17018 \r
17019 \r
17020 \r
17021 \r
17022 \r
17023 \r
17024 \r
17025 \r
17026 \r
17027 \r
17028 \r
17029 \r
17030 \r
17031 \r
17032 \r
17033 \r
17034 \r
17035 \r
17036 \r
17037 \r
17038 \r
17039 \r
17040 \r
17041 \r
17042 \r
17043 \r
17044 \r
17045 \r
17046 \r
17047 \r
17048 \r
17049 \r
17050 \r
17051 \r
17052 \r
17053 \r
17054 \r
17055 \r
17056 \r
17057 \r
17058 \r
17059 \r
17060 \r
17061 \r
17062 \r
17063 \r
17064 \r
17065 \r
17066 \r
17067 \r
17068 \r
17069 \r
17070 \r
17071 \r
17072 \r
17073 \r
17074 \r
17075 \r
17076 \r
17077 \r
17078 \r
17079 \r
17080 \r
17081 \r
17082 \r
17083 \r
17084 \r
17085 \r
17086 \r
17087 \r
17088 \r
17089 \r
17090 \r
17091 \r
17092 \r
17093 \r
17094 \r
17095 \r
17096 \r
17097 \r
17098 \r
17099 \r
17100 \r
17101 \r
17102 \r
17103 \r
17104 \r
17105 \r
17106 \r
17107 \r
17108 \r
17109 \r
17110 \r
17111 \r
17112 \r
17113 \r
17114 \r
17115 \r
17116 \r
17117 \r
17118 \r
17119 \r
17120 \r
17121 \r
17122 \r
17123 \r
17124 \r
17125 \r
17126 \r
17127 \r
17128 \r
17129 \r
17130 \r
17131 \r
17132 \r
17133 \r
17134 \r
17135 \r
17136 \r
17137 \r
17138 \r
17139 \r
17140 \r
17141 \r
17142 \r
17143 \r
17144 \r
17145 \r
17146 \r
17147 \r
17148 \r
17149 \r
17150 \r
17151 \r
17152 \r
17153 \r
17154 \r
17155 \r
17156 \r
17157 \r
17158 \r
17159 \r
17160 \r
17161 \r
17162 \r
17163 \r
17164 \r
17165 \r
17166 \r
17167 \r
17168 \r
17169 \r
17170 \r
17171 \r
17172 \r
17173 \r
17174 \r
17175 \r
17176 \r
17177 \r
17178 \r
17179 \r
17180 \r
17181 \r
17182 \r
17183 \r
17184 \r
17185 \r
17186 \r
17187 \r
17188 \r
17189 \r
17190 \r
17191 \r
17192 \r
17193 \r
17194 \r
17195 \r
17196 \r
17197 \r
17198 \r
17199 \r
17200 \r
17201 \r
17202 \r
17203 \r
17204 \r
17205 \r
17206 \r
17207 \r
17208 \r
17209 \r
17210 \r
17211 \r
17212 \r
17213 \r
17214 \r
17215 \r
17216 \r
17217 \r
17218 \r
17219 \r
17220 \r
17221 \r
17222 \r
17223 \r
17224 \r
17225 \r
17226 \r
17227 \r
17228 \r
17229 \r
17230 \r
17231 \r
17232 \r
17233 \r
17234 \r
17235 \r
17236 \r
17237 \r
17238 \r
17239 \r
17240 \r
17241 \r
17242 \r
17243 \r
17244 \r
17245 \r
17246 \r
17247 \r
17248 \r
17249 \r
17250 \r
17251 \r
17252 \r
17253 \r
17254 \r
17255 \r
17256 \r
17257 \r
17258 \r
17259 \r
17260 \r
17261 \r
17262 \r
17263 \r
17264 \r
17265 \r
17266 \r
17267 \r
17268 \r
17269 \r
17270 \r
17271 \r
17272 \r
17273 \r
17274 \r
17275 \r
17276 \r
17277 \r
17278 \r
17279 \r
17280 \r
17281 \r
17282 \r
17283 \r
17284 \r
17285 \r
17286 \r
17287 \r
17288 \r
17289 \r
17290 \r
17291 \r
17292 \r
17293 \r
17294 \r
17295 \r
17296 \r
17297 \r
17298 \r
17299 \r
17300 \r
17301 \r
17302 \r
17303 \r
17304 \r
17305 \r
17306 \r
17307 \r
17308 \r
17309 \r
17310 \r
17311 \r
17312 \r
17313 \r
17314 \r
17315 \r
17316 \r
17317 \r
17318 \r
17319 \r
17320 \r
17321 \r
17322 \r
17323 \r
17324 \r
17325 \r
17326 \r
17327 \r
17328 \r
17329 \r
17330 \r
17331 \r
17332 \r
17333 \r
17334 \r
17335 \r
17336 \r
17337 \r
17338 \r
17339 \r
17340 \r
17341 \r
17342 \r
17343 \r
17344 \r
17345 \r
17346 \r
17347 \r
17348 \r
17349 \r
17350 \r
17351 \r
17352 \r
17353 \r
17354 \r
17355 \r
17356 \r
17357 \r
17358 \r
17359 \r
17360 \r
17361 \r
17362 \r
17363 \r
17364 \r
17365 \r
17366 \r
17367 \r
17368 \r
17369 \r
17370 \r
17371 \r
17372 \r
17373 \r
17374 \r
17375 \r
17376 \r
17377 \r
17378 \r
17379 \r
17380 \r
17381 \r
17382 \r
17383 \r
17384 \r
17385 \r
17386 \r
17387 \r
17388 \r
17389 \r
17390 \r
17391 \r
17392 \r
17393 \r
17394 \r
17395 \r
17396 \r
17397 \r
17398 \r
17399 \r
17400 \r
17401 \r
17402 \r
17403 \r
17404 \r
17405 \r
17406 \r
17407 \r
17408 \r
17409 \r
17410 \r
17411 \r
17412 \r
17413 \r
17414 \r
17415 \r
17416 \r
17417 \r
17418 \r
17419 \r
17420 \r
17421 \r
17422 \r
17423 \r
17424 \r
17425 \r
17426 \r
17427 \r
17428 \r
17429 \r
17430 \r
17431 \r
17432 \r
17433 \r
17434 \r
17435 \r
17436 \r
17437 \r
17438 \r
17439 \r
17440 \r
17441 \r
17442 \r
17443 \r
17444 \r
17445 \r
17446 \r
17447 \r
17448 \r
17449 \r
17450 \r
17451 \r
17452 \r
17453 \r
17454 \r
17455 \r
17456 \r
17457 \r
17458 \r
17459 \r
17460 \r
17461 \r
17462 \r
17463 \r
17464 \r
17465 \r
17466 \r
17467 \r
17468 \r
17469 \r
17470 \r
17471 \r
17472 \r
17473 \r
17474 \r
17475 \r
17476 \r
17477 \r
17478 \r
17479 \r
17480 \r
17481 \r
17482 \r
17483 \r
17484 \r
17485 \r
17486 \r
17487 \r
17488 \r
17489 \r
17490 \r
17491 \r
17492 \r
17493 \r
17494 \r
17495 \r
17496 \r
17497 \r
17498 \r
17499 \r
17500 \r
17501 \r
17502 \r
17503 \r
17504 \r
17505 \r
17506 \r
17507 \r
17508 \r
17509 /*********************************COPYRIGHT NOTICE**********************************/
17510 /*© Centro de Regulacio Genomica */
17511 /*and */
17512 /*Cedric Notredame */
17513 /*Tue Oct 27 10:12:26 WEST 2009. */
17514 /*All rights reserved.*/
17515 /*This file is part of T-COFFEE.*/
17516 /**/
17517 /*    T-COFFEE is free software; you can redistribute it and/or modify*/
17518 /*    it under the terms of the GNU General Public License as published by*/
17519 /*    the Free Software Foundation; either version 2 of the License, or*/
17520 /*    (at your option) any later version.*/
17521 /**/
17522 /*    T-COFFEE is distributed in the hope that it will be useful,*/
17523 /*    but WITHOUT ANY WARRANTY; without even the implied warranty of*/
17524 /*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the*/
17525 /*    GNU General Public License for more details.*/
17526 /**/
17527 /*    You should have received a copy of the GNU General Public License*/
17528 /*    along with Foobar; if not, write to the Free Software*/
17529 /*    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA*/
17530 /*...............................................                                                                                      |*/
17531 /*  If you need some more information*/
17532 /*  cedric.notredame@europe.com*/
17533 /*...............................................                                                                                                                                     |*/
17534 /**/
17535 /**/
17536 /*      */
17537 /*********************************COPYRIGHT NOTICE**********************************/