website/archive/binaries/mac/src/tcoffee/t_coffee_source/t_coffee.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <math.h>
   4 #include <stdarg.h>
   5 #include <signal.h>
   6 #include <string.h>
   7
   8 #include "io_lib_header.h"
   9 #include "util_lib_header.h"
  10 #include "dp_lib_header.h"
  11 #include "define_header.h"
  12 #include "t_coffee.h"
  13 static void test();
  14 static char * get_seq_type_from_cl (int argc, char **argv);
  15 static char *get_defaults(char *buf, char *type);
  16 static char *get_evaluate_defaults(char *buf, char *type);
  17 static char *get_genome_defaults(char *buf, char *type);
  18 static char *get_dali_defaults(char *buf, char *type);
  19 static char *get_mcoffee_defaults(char *buf, char *type);
  20 static char *get_fmcoffee_defaults(char *buf, char *type);
  21 static char *get_t_coffee_defaults(char *buf, char *type);
  22
  23 static char *get_dmcoffee_defaults(char *buf, char *type);
  24 static char *get_rcoffee_consan_defaults(char *buf, char *type);
  25 static char *get_rmcoffee_defaults(char *buf, char *type);//Original R-Coffee Paper
  26 static char *get_rcoffee_defaults(char *buf, char *type);//Original R-Coffee Paper
  27 static char *get_rmcoffee_defaults_old(char *buf, char *type);//Original R-Coffee Paper
  28 static char *get_rcoffee_defaults_old(char *buf, char *type);//Original R-Coffee Paper
  29 static char *get_best4RNA_defaults(char *buf, char *type);
  30
  31 static char *get_very_fast_defaults(char *buf, char *type);
  32 static char *get_precomputed_defaults(char *buf, char *type);
  33 static char *get_3dcoffee_defaults(char *buf, char *type);
  34 static char *get_expresso_defaults(char *buf, char *type);
  35
  36 static char *get_accurate_defaults(char *buf, char *type);
  37 static char *get_accurate4PROTEIN_defaults(char *buf, char *type);
  38 static char *get_accurate4DNA_defaults(char *buf, char *type);
  39 static char *get_accurate4RNA_defaults(char *buf, char *type);
  40
  41 static char *get_procoffee_defaults(char *buf, char *type);
  42 static char *get_blastr_defaults(char *buf, char *type);
  43 static char *get_psicoffee_defaults(char *buf, char *type);
  44 static char *get_dna_defaults(char *buf, char *type);
  45 static char *get_cdna_defaults(char *buf, char *type);
  46 static char *get_repeat_defaults(char *buf, char *type);
  47 static char *get_low_memory_defaults( char *buf, char *type);
  48
  49 static char *get_genepredx_defaults(char *buf, char *type);
  50 static char *get_genepredpx_defaults(char *buf, char *type);
  51
  52 static int set_methods_limits (char **method_limits,int n_methods_limit,char **list_file, int n_list, int *maxnseq, int *maxlen);
  53 static FILE *t_coffee_tip (FILE *fp,char *mode);
  54
  55 static int run_other_pg(int argc, char *argv[]);
  56
  57 static Sequence* prepare_master (char *seq,Sequence *S,Constraint_list *CL, char *dmode);
  58
  59 #define is_a_seq_file(file) (!is_matrix(file) && !is_matrix(file+1) && !is_method (file) && !is_method (file+1) &&(check_file_exists(file) || check_file_exists(file+1)))
  60 static int NO_METHODS_IN_CL;
  61 int batch_main ( int argc, char **argv);
  62 int main (int argc, char *argv[])
  63 {
  64   int r, a;
  65
  66   if (argc>=2 && strcmp (argv[1], "-batch")==0)
  67     {
  68       char **list;
  69       list=file2lines (argv[2]);
  70       for (a=1; a<atoi (list[0]); a++)
  71         {
  72           char **com;
  73           com=string2list (list[a]);
  74           r=batch_main (atoi (com[0])-1, com+1);
  75           free_char (com, -1);
  76         }
  77     }
  78   else
  79     {
  80       r=batch_main (argc, argv);
  81     }
  82   myexit (r);
  83 }
  84 int batch_main ( int argc, char **argv)
  85         {
  86
  87         int a, b, c, t;
  88         char *f;
  89
  90         Sequence *S;
  91         char **new_order;
  92         char **initial_order;
  93
  94         Fname *F=NULL;
  95         Constraint_list *CL;
  96         Alignment  *A=NULL, *EA=NULL;
  97         Alignment  **aln_list;
  98
  99         FILE *OUT;
 100
 101
 102         NT_node **T=NULL;
 103         int tot_node;
 104         char *pc;
 105 /*Parameters*/
 106
 107         int check_configuration;
 108         int update;
 109         int garbage;
 110         int quiet;
 111         char *parameters;
 112         char *t_coffee_defaults;
 113         int t_coffee_defaults_flag;
 114
 115         FILE *le=NULL;
 116         char *se_name;
 117         char *run_name;
 118
 119         char *mem_mode;
 120
 121         int do_extend;
 122         char *extend_mode;
 123         int max_n_pair;
 124         int  nseq_for_quadruplet;
 125         char **seq_name_for_quadruplet;
 126
 127         int do_compact;
 128         int **do_list;
 129         int n_do;
 130
 131         char *compact_mode;
 132         int do_clean;
 133         char *clean_mode;
 134         int do_self;
 135         int do_normalise;
 136
 137
 138
 139         int n_list;
 140         char **list_file;
 141
 142         char **setenv_list;
 143         int n_setenv;
 144
 145
 146         char **template_file_list;
 147         int n_template_file;
 148
 149         char **template_mode_list;
 150         int n_template_mode;
 151
 152
 153
 154         int remove_template_file;
 155
 156         char **profile_template_file_list;
 157         int n_profile_template_file;
 158
 159         int n_pdb;
 160         char **pdb_list;
 161         int pdb_start, pdb_end;
 162         char *pdb_name;
 163
 164         char *out_lib;
 165         char *out_lib_mode;
 166         int shrink_lib;
 167         int relax_lib;
 168         int filter_lib;
 169         int processed_lib;
 170
 171         int lib_only;
 172         char *outseqweight;
 173
 174
 175
 176         char *seq_source;
 177
 178         int cosmetic_penalty,gop,f_gop, gep,f_gep, nomatch;
 179
 180         char *tree_file;
 181         char *ph_tree_file;
 182
 183         char *use_tree;
 184         char *tree_mode;
 185         char *distance_matrix_mode;
 186         char *distance_matrix_sim_mode;
 187
 188         int quicktree;
 189         char *out_aln;
 190         char **tot_out_aln;
 191         int maximise;
 192         char **out_aln_format;
 193         int  n_out_aln_format;
 194         char *infile;
 195         char *matrix;
 196         char *dp_mode;
 197         char *profile_mode;
 198         char *profile_comparison;
 199
 200
 201         int tg_mode;
 202         int   ktup;
 203         int   fasta_step;
 204         int   diag_threshold;
 205         int   diag_mode;
 206         char *sim_matrix;
 207
 208         char *type;
 209         int check_type;
 210         int type_only;
 211         char *transform;
 212         int   extend_seq;
 213         char *outorder;
 214         char  *inorder;
 215         char *output_res_num;
 216         char *residue_case;
 217         int extra_cpu;
 218
 219
 220         char *weight;
 221         int sample_dp=0;
 222
 223         char *seq_weight;
 224         int do_align;
 225         char *evaluate_mode;
 226         char *method_evaluate_mode;
 227         int get_type;
 228         /*Post_processing*/
 229         int clean_aln;
 230         int clean_threshold;
 231         int clean_iteration;
 232         char *clean_evaluate_mode;
 233         /*Profile Alignment*/
 234
 235         int n_seq_list;
 236         char **seq_list;
 237
 238         char **method_list;
 239         int n_method_list;
 240
 241
 242         char **method_limits;
 243         int n_method_limits;
 244
 245         char **aln_file_list;
 246         int n_aln_file_list;
 247
 248         char **lib_file_list;
 249         int n_lib_file_list;
 250
 251         char **profile_list;
 252         int n_profile_list;
 253
 254         char *profile1;
 255         char *profile2;
 256
 257         /*Domain Parameters*/
 258         int do_domain;
 259         int domain_start;
 260         int domain_len;
 261         int domain_scale;
 262         int domain_interactive;
 263         /* extended matrix analysis*/
 264         int do_extended_matrix;
 265         /*Action Parameters*/
 266         int do_evaluate;
 267         int do_genepred;
 268         int do_convert;
 269         int do_version;
 270         /*Genepred_score*/
 271         char *genepred_score;
 272
 273         int maxnseq;
 274         int maxlen;
 275         /*Thread parameters*/
 276         int prot_min_sim;
 277         int prot_max_sim;
 278         int prot_min_cov;
 279         int pdb_min_sim;
 280         int pdb_max_sim;
 281         int pdb_min_cov;
 282         char *pdb_type;
 283
 284
 285         char *prot_blast_server;
 286         char *pdb_blast_server;
 287
 288
 289         char *pdb_db;
 290         char *prot_db;
 291         NT_node *SNL;
 292
 293         /*
 294         char *dna_db;
 295         char *dna_blast_server;
 296         int dna_min_sim;
 297         int dna_max_sim;
 298         int dna_min_cov;
 299         */
 300
 301
 302         /*Method log*/
 303         char * method_log;
 304
 305         char **struc_to_use;
 306         int n_struc_to_use;
 307
 308         /*Cache*/
 309         char * cache;
 310
 311         /*align_pdb*/
 312         char *align_pdb_param_file;
 313         char *align_pdb_hasch_mode;
 314
 315         /*msa_mode*/
 316         char *use_seqan;
 317         char *msa_mode;
 318         char *master_mode;
 319         Sequence *MASTER_SEQ=NULL;
 320         Sequence *TEMP_SEQ=NULL;
 321
 322         int blast_maxnseq;
 323
 324         int lalign_n_top;
 325         int iterate;
 326         /*split*/
 327         int split;
 328         int split_nseq_thres;
 329         int split_score_thres;
 330         char split_name[1000];
 331         char split_format[1000];
 332         Alignment *SPLIT_ALN;
 333
 334         int check_pdb_status;
 335         /*trim*/
 336         int trim;
 337         Sequence *trim_subS=NULL;
 338         Sequence *trim_S=NULL;
 339         Sequence *SEQ_TO_KEEP=NULL;
 340         char *trimfile;
 341         char trim_format[1000];
 342         int clean_seq_name;
 343         int n_seq_to_keep;
 344         char **seq_to_keep;
 345         char **special_mode_list;
 346         int n_special_mode;
 347         char **special_mode_list1;
 348         int n_special_mode1;
 349         char **special_mode_list2;
 350         int n_special_mode2;
 351         /*dpa*/
 352         int dpa;
 353         char *dpa_master_aln;
 354         int dpa_min_score1;
 355         int dpa_min_score2;
 356         int dpa_maxnseq;
 357         int dpa_keep_tmpfile;
 358         int dpa_debug;
 359         /*error report*/
 360         char *full_log;
 361
 362         /*Multithread*/
 363         char *multi_core;
 364         int   n_core;
 365
 366         char *lib_list;
 367         char *prune_lib_mode;
 368
 369         int no_error_report;
 370         int no_warning=0;
 371         char *tip;
 372         int run_local_script;
 373         char *plugins;
 374         char *email;
 375         char *proxy;
 376
 377         char *rna_lib;
 378         /*over_aln*/
 379         char  **overaln_param;
 380         char    n_overaln_param;
 381         char  * exon_boundaries;
 382         char  * overaln_mode;
 383         char  *overaln_model;
 384         int    overaln_P1;
 385         int    overaln_P2;
 386         int    overaln_P3;
 387         int    overaln_P4;
 388
 389         int     overaln_threshold;
 390         int     overaln_target;
 391         int     clean_overaln;
 392
 393         char *dump;
 394
 395         argv=standard_initialisation (argv, &argc);
 396         set_string_variable ("t_coffee", argv[0]);
 397
 398 /*Running other programs via T-Coffee*/
 399         if (argc>=3 && strm (argv[1], "-other_pg"))
 400           {
 401             //standard_initialisation (NULL,NULL);
 402             return run_other_pg (argc-2, argv+2);
 403           }
 404
 405 /*PARAMETER PROTOTYPE:    READ PARAMETER FILE     */
 406                  get_cl_param(\
 407                             /*argc*/      argc             ,\
 408                             /*argv*/      argv             ,\
 409                             /*output*/    &le              ,\
 410                             /*Name*/      "-no_error_report"        ,\
 411                             /*Flag*/      &garbage        ,\
 412                             /*TYPE*/      "D"              ,\
 413                             /*OPTIONAL?*/ OPTIONAL         ,\
 414                             /*MAX Nval*/  1                ,\
 415                             /*DOC*/       "Limit the maximum memory usage (in Megabytes). 0: no limit" ,\
 416                             /*Parameter*/ &no_error_report          ,\
 417                             /*Def 1*/     "0"             ,\
 418                             /*Def 2*/     "1"             ,\
 419                             /*Min_value*/ "any"            ,\
 420                             /*Max Value*/ "any"             \
 421                                           );
 422
 423 /*PARAMETER PROTOTYPE:    READ PARAMETER FILE     */
 424                declare_name (parameters);
 425                get_cl_param(\
 426                             /*argc*/      argc             ,\
 427                             /*argv*/      argv             ,\
 428                             /*output*/    &le              ,\
 429                             /*Name*/      "-parameters"        ,\
 430                             /*Flag*/      &garbage        ,\
 431                             /*TYPE*/      "R_F"              ,\
 432                             /*OPTIONAL?*/ OPTIONAL         ,\
 433                             /*MAX Nval*/  1                ,\
 434                             /*DOC*/       "get bottom parameters" ,\
 435                             /*Parameter*/ &parameters          ,\
 436                             /*Def 1*/     "NULL"             ,\
 437                             /*Def 2*/     "stdin"             ,\
 438                             /*Min_value*/ "any"            ,\
 439                             /*Max Value*/ "any"             \
 440                    );
 441
 442
 443                special_mode_list1=declare_char (100, STRING);
 444
 445                n_special_mode1=get_cl_param(                    \
 446                             /*argc*/      argc             ,\
 447                             /*argv*/      argv             ,\
 448                             /*output*/    &le              ,\
 449                             /*Name*/      "-mode"        ,\
 450                             /*Flag*/      &garbage        ,\
 451                             /*TYPE*/      "S"              ,\
 452                             /*OPTIONAL?*/ OPTIONAL         ,\
 453                             /*MAX Nval*/  100                ,\
 454                             /*DOC*/       "specifies a special mode: genome, quickaln, dali, 3dcoffee" ,\
 455                             /*Parameter*/ special_mode_list1          ,\
 456                             /*Def 1*/     "unspecified"             ,\
 457                             /*Def 2*/     "HARD_CODED"       ,\
 458                             /*Min_value*/ "any"            ,\
 459                             /*Max Value*/ "any"             \
 460                    );
 461
 462
 463                special_mode_list2=declare_char (100, STRING);
 464                n_special_mode2=get_cl_param(\
 465                             /*argc*/      argc             ,\
 466                             /*argv*/      argv             ,\
 467                             /*output*/    &le              ,\
 468                             /*Name*/      "-special_mode"        ,\
 469                             /*Flag*/      &garbage        ,\
 470                             /*TYPE*/      "S"              ,\
 471                             /*OPTIONAL?*/ OPTIONAL         ,\
 472                             /*MAX Nval*/  100                ,\
 473                             /*DOC*/       "[DEPRECATED ** -special_mode is deprected use -mode instead]" ,\
 474                             /*Parameter*/ special_mode_list2          ,\
 475                             /*Def 1*/     "unspecified"             ,\
 476                             /*Def 2*/     "HARD_CODED"       ,\
 477                             /*Min_value*/ "any"            ,\
 478                             /*Max Value*/ "any"             \
 479                    );
 480
 481                special_mode_list=declare_char (n_special_mode1+n_special_mode2, STRING);
 482                n_special_mode=0;
 483                for (a=0; a<n_special_mode1; a++)
 484                  if (!strm (special_mode_list1[a], "unspecified"))sprintf ( special_mode_list[n_special_mode++], "%s", special_mode_list1[a]);
 485                for (a=0; a<n_special_mode2; a++)
 486                  if (!strm (special_mode_list2[a], "unspecified"))sprintf ( special_mode_list[n_special_mode++], "%s", special_mode_list2[a]);
 487                free_char (special_mode_list1, -1);
 488                free_char (special_mode_list2, -1);
 489
 490                declare_name (t_coffee_defaults);
 491                get_cl_param(\
 492                             /*argc*/      argc             ,\
 493                             /*argv*/      argv             ,\
 494                             /*output*/    &le              ,\
 495                             /*Name*/      "-t_coffee_defaults"        ,\
 496                             /*Flag*/      &t_coffee_defaults_flag     ,\
 497                             /*TYPE*/      "R_F"              ,\
 498                             /*OPTIONAL?*/ OPTIONAL         ,\
 499                             /*MAX Nval*/  1                ,\
 500                             /*DOC*/       "get top parameters" ,\
 501                             /*Parameter*/ &t_coffee_defaults          ,\
 502                             /*Def 1*/     "NULL"             ,\
 503                             /*Def 2*/     "NULL"       ,\
 504                             /*Min_value*/ "any"            ,\
 505                             /*Max Value*/ "any"             \
 506                    );
 507                /*PARAMETER PROTOTYPE:    -type_only: must stay here: needed by special_mode    */
 508                get_cl_param(\
 509                             /*argc*/      argc           ,\
 510                             /*argv*/      argv           ,\
 511                             /*output*/    &le            ,\
 512                             /*Name*/      "-type_only"        ,\
 513                             /*Flag*/      &type_only       ,\
 514                             /*TYPE*/      "FL"            ,\
 515                             /*OPTIONAL?*/ OPTIONAL       ,\
 516                             /*MAX Nval*/  1              ,\
 517                             /*DOC*/       "exit after checking the type and returning it to the stdout",\
 518                             /*Parameter*/ &type_only          ,\
 519                             /*Def 1*/    "0"              ,\
 520                             /*Def 2*/    "1"              ,\
 521                             /*Min_value*/ "any"          ,\
 522                             /*Max Value*/ "any"           \
 523                    );
 524
 525                /*PARAMETER PROTOTYPE:    CHECK_TYPE     */
 526                get_cl_param(                                    \
 527                             /*argc*/      argc          ,\
 528                             /*argv*/      argv          ,       \
 529                             /*output*/    &le           ,       \
 530                             /*Name*/      "-check_type"  ,      \
 531                             /*Flag*/      &check_type    ,      \
 532                             /*TYPE*/      "FL"          ,       \
 533                             /*OPTIONAL?*/ OPTIONAL      ,       \
 534                             /*MAX Nval*/  0             ,               \
 535                             /*DOC*/       "Make sure that -type and the real type of the sequences agree"          , \
 536                             /*Parameter*/ &check_type    ,              \
 537                             /*Def 1*/    "0"            ,               \
 538                             /*Def 2*/    "1"            ,               \
 539                             /*Min_value*/ "any"         ,               \
 540                             /*Max Value*/ "any"                         \
 541                                           );
 542                /*PARAMETER PROTOTYPE:    INFILE    */
 543                declare_name (type);
 544                get_cl_param(                                    \
 545                             /*argc*/      argc           ,      \
 546                             /*argv*/      argv           ,      \
 547                             /*output*/    &le            ,      \
 548                             /*Name*/      "-type"        ,      \
 549                             /*Flag*/      &garbage       ,      \
 550                             /*TYPE*/      "S"            ,      \
 551                             /*OPTIONAL?*/ OPTIONAL       ,      \
 552                             /*MAX Nval*/  1              ,              \
 553                             /*DOC*/       "PROTEIN, DNA or RNA. Automatically set, but can be forced with this flag"           , \
 554                             /*Parameter*/ &type          ,              \
 555                             /*Def 1*/    ""              ,              \
 556                             /*Def 2*/    ""              ,              \
 557                             /*Min_value*/ "any"          ,              \
 558                             /*Max Value*/ "any"                         \
 559                                           );
 560
 561
 562 /* extra>prompt>special>parameters>defaults*/
 563  argv=break_list ( argv, &argc, "=;, \n");
 564  argv=merge_list ( argv, &argc);
 565  if (argc>1 && argv[1][0]!='-')argv=push_string ("-seq ", argv, &argc, 1);
 566
 567  if ( name_is_in_list ("-method",argv, argc,100)==-1)
 568    {
 569      NO_METHODS_IN_CL=1;
 570    }
 571
 572 if (t_coffee_defaults_flag)
 573   {
 574     char *pname=NULL;
 575
 576     pname=getenv ( "TCOFFEE_DEFAULTS");
 577
 578     if (check_file_exists ( t_coffee_defaults))pname=t_coffee_defaults;
 579     else if ( getenv ( "TCOFFEE_DEFAULTS"))
 580       {
 581         pname=getenv ( "TCOFFEE_DEFAULTS");
 582         if (check_file_exists(pname));
 583         else pname=NULL;
 584       }
 585     else
 586       {
 587         declare_name(pname);sprintf (pname, "%s/.t_coffee_defaults",getenv ( "HOME") );
 588         if (!check_file_exists (pname)){vfree(pname);pname=NULL;}
 589       }
 590
 591     if (pname)
 592       {
 593         argv=push_string (file2string(pname), argv, &argc, 1);
 594         t_coffee_defaults=pname;
 595       }
 596     else
 597       {
 598         t_coffee_defaults=NULL;
 599       }
 600   }
 601
 602  if ( parameters && parameters[0])argv=push_string (file2string (parameters), argv, &argc, 1);
 603
 604
 605  if (n_special_mode && !type_only)
 606    {
 607      char *special_mode;
 608      char *lseq_type;
 609      declare_name(lseq_type);
 610      if (type && !strm (type, ""))
 611        sprintf (lseq_type,"%s",type);
 612      else
 613        sprintf (lseq_type,"%s",get_seq_type_from_cl (argc, argv));
 614
 615      for ( a=0; a< n_special_mode; a++)
 616        {
 617          char *new_arg=NULL;
 618
 619          special_mode=special_mode_list[a];
 620
 621          store_mode (special_mode);
 622
 623
 624          if (special_mode && !special_mode[0]);
 625          else if ( strm (special_mode, "genepredx"))new_arg=get_genepredx_defaults(NULL,lseq_type);
 626          else if ( strm (special_mode, "genepredpx"))new_arg=get_genepredpx_defaults(NULL,lseq_type);
 627
 628          else if ( strm (special_mode, "regular") || strm (special_mode, "regular_fast")|| strm (special_mode, "default"))new_arg=get_defaults (NULL,lseq_type);
 629          else if ( strm (special_mode, "genome"))new_arg=get_genome_defaults(NULL,lseq_type);
 630          else if ( strm (special_mode, "quickaln"))new_arg=get_very_fast_defaults(NULL,lseq_type);
 631          else if ( strm (special_mode, "dali"))new_arg=get_dali_defaults(NULL,lseq_type);
 632          else if ( strm (special_mode, "evaluate"))new_arg=get_evaluate_defaults(NULL,lseq_type);
 633          else if ( strm (special_mode, "precomputed"))new_arg=get_precomputed_defaults(NULL,lseq_type);
 634          else if ( strm (special_mode, "3dcoffee"))new_arg=get_3dcoffee_defaults(NULL,lseq_type);
 635          else if ( strm (special_mode, "expresso"))new_arg=get_expresso_defaults(NULL,lseq_type);
 636          else if ( strm (special_mode, "repeats"))new_arg=get_repeat_defaults(NULL,lseq_type);
 637          else if ( strm (special_mode, "psicoffee"))new_arg=get_psicoffee_defaults(NULL,lseq_type);
 638           else if ( strm (special_mode, "procoffee"))new_arg=get_procoffee_defaults(NULL,lseq_type);
 639           else if ( strm (special_mode, "blastr"))new_arg=get_blastr_defaults(NULL,lseq_type);
 640
 641          else if ( strm (special_mode, "accurate") || strm (special_mode, "accurate_slow") || strm (special_mode, "psicoffee_expresso"))new_arg=get_accurate_defaults(NULL, lseq_type);
 642          else if ( strm (special_mode, "accurate4DNA"))new_arg=get_accurate4DNA_defaults(NULL,lseq_type);
 643          else if ( strm (special_mode, "accurate4RNA"))new_arg=get_accurate4RNA_defaults(NULL,lseq_type);
 644          else if ( strm (special_mode, "best4RNA"))new_arg=get_best4RNA_defaults(NULL,lseq_type);
 645          else if ( strm (special_mode, "accurate4PROTEIN"))new_arg=get_accurate4PROTEIN_defaults(NULL,lseq_type);
 646
 647          else if ( strm (special_mode, "low_memory") || strm (special_mode, "memory"))new_arg=get_low_memory_defaults(NULL,lseq_type);
 648
 649
 650          else if ( strm (special_mode, "dna"))new_arg=get_dna_defaults(NULL,lseq_type);
 651          else if ( strm (special_mode, "cdna"))new_arg=get_dna_defaults(NULL,lseq_type);
 652          else if ( strm (special_mode, "protein"))new_arg=get_low_memory_defaults(NULL,lseq_type);
 653          else if ( strm (special_mode, "mcoffee"))new_arg=get_mcoffee_defaults(NULL,lseq_type);
 654          else if ( strm (special_mode, "dmcoffee"))new_arg=get_dmcoffee_defaults(NULL,lseq_type);
 655          else if ( strm (special_mode, "fmcoffee"))new_arg=get_fmcoffee_defaults(NULL,lseq_type);
 656
 657          else if ( strm (special_mode, "rcoffee_consan"))new_arg=get_rcoffee_consan_defaults(NULL,lseq_type);
 658          else if ( strm (special_mode, "rmcoffee") ||strm (special_mode, "mrcoffee") )new_arg=get_rmcoffee_defaults(NULL,lseq_type);
 659          else if ( strm (special_mode, "rcoffee"))new_arg=get_rcoffee_defaults(NULL,lseq_type);
 660
 661          else if ( strm (special_mode, "rcoffee_slow_accurate"))new_arg=get_rcoffee_consan_defaults(NULL,lseq_type);
 662          else if ( strm (special_mode, "rcoffee_fast_approximate"))new_arg=get_rmcoffee_defaults(NULL,lseq_type);
 663          else if ( strm (special_mode, "t_coffee"))new_arg=get_t_coffee_defaults(NULL,lseq_type);
 664
 665
 666          else if ( strm (special_mode, "unspecified"));
 667          else
 668            {
 669              fprintf ( stderr, "\nERROR: special_mode %s is unknown [FATAL:%s]\n",special_mode, PROGRAM);
 670              myexit (EXIT_FAILURE);
 671            }
 672
 673          if (new_arg)argv=push_string (new_arg, argv, &argc, 1);
 674        }
 675    }
 676
 677 if ( getenv ("TCOFFEE_EXTRA_PARAM"))argv=push_string (getenv ("TCOFFEE_EXTRA_PARAM"), argv, &argc, argc);
 678
 679
 680 argv=break_list ( argv, &argc, "=;, \n");
 681 argv=merge_list ( argv, &argc);
 682 /*check_cl4t_coffee ( argc, argv); */
 683
 684
 685 /*PARAMETER PROTOTYPE:    VERSION      */
 686                get_cl_param(\
 687                             /*argc*/      argc             ,\
 688                             /*argv*/      argv             ,\
 689                             /*output*/    &le              ,\
 690                             /*Name*/      "-version"        ,\
 691                             /*Flag*/      &do_version        ,\
 692                             /*TYPE*/      "FL"              ,\
 693                             /*OPTIONAL?*/ OPTIONAL         ,\
 694                             /*MAX Nval*/  1                ,\
 695                             /*DOC*/       "forces the program to output the version number and exit" ,\
 696                             /*Parameter*/ &do_version          ,\
 697                             /*Def 1*/     "0"             ,\
 698                             /*Def 2*/     "1"             ,\
 699                             /*Min_value*/ "0"            ,\
 700                             /*Max Value*/ "1"             \
 701                    );
 702
 703
 704
 705 /*PARAMETER PROTOTYPE:    DO EVALUATE      */
 706                get_cl_param(\
 707                             /*argc*/      argc             ,\
 708                             /*argv*/      argv             ,\
 709                             /*output*/    &le              ,\
 710                             /*Name*/      "-score"        ,\
 711                             /*Flag*/      &do_evaluate        ,\
 712                             /*TYPE*/      "FL"              ,\
 713                             /*OPTIONAL?*/ OPTIONAL         ,\
 714                             /*MAX Nval*/  1                ,\
 715                             /*DOC*/       "DEPRECATED: use -special_mode evaluate instead " ,\
 716                             /*Parameter*/ &do_evaluate          ,\
 717                             /*Def 1*/     "0"             ,\
 718                             /*Def 2*/     "1"             ,\
 719                             /*Min_value*/ "0"            ,\
 720                             /*Max Value*/ "1"             \
 721                    );
 722 if ( !do_evaluate)
 723   {
 724 /*PARAMETER PROTOTYPE:    DO EVALUATE      */
 725                get_cl_param(\
 726                             /*argc*/      argc             ,\
 727                             /*argv*/      argv             ,\
 728                             /*output*/    &le              ,\
 729                             /*Name*/      "-evaluate"        ,\
 730                             /*Flag*/      &do_evaluate        ,\
 731                             /*TYPE*/      "FL"              ,\
 732                             /*OPTIONAL?*/ OPTIONAL         ,\
 733                             /*MAX Nval*/  1                ,\
 734                             /*DOC*/       "Use -special_mode evaluate for a default behavior " ,\
 735                             /*Parameter*/ &do_evaluate          ,\
 736                             /*Def 1*/     "0"             ,\
 737                             /*Def 2*/     "1"             ,\
 738                             /*Min_value*/ "0"            ,\
 739                             /*Max Value*/ "1"             \
 740                    );
 741   }
 742 /*PARAMETER PROTOTYPE:    DO EVALUATE      */
 743                get_cl_param(\
 744                             /*argc*/      argc             ,\
 745                             /*argv*/      argv             ,\
 746                             /*output*/    &le              ,\
 747                             /*Name*/      "-genepred"        ,\
 748                             /*Flag*/      &do_genepred        ,\
 749                             /*TYPE*/      "FL"              ,\
 750                             /*OPTIONAL?*/ OPTIONAL         ,\
 751                             /*MAX Nval*/  1                ,\
 752                             /*DOC*/       "Use -special_mode genepred for a default behavior " ,\
 753                             /*Parameter*/ &do_genepred          ,\
 754                             /*Def 1*/     "0"             ,\
 755                             /*Def 2*/     "1"             ,\
 756                             /*Min_value*/ "0"            ,\
 757                             /*Max Value*/ "1"             \
 758                    );
 759 /*PARAMETER PROTOTYPE:    DO FORMAT      */
 760                get_cl_param(\
 761                             /*argc*/      argc             ,\
 762                             /*argv*/      argv             ,\
 763                             /*output*/    &le              ,\
 764                             /*Name*/      "-convert"        ,\
 765                             /*Flag*/      &do_convert        ,\
 766                             /*TYPE*/      "FL"              ,\
 767                             /*OPTIONAL?*/ OPTIONAL         ,\
 768                             /*MAX Nval*/  1                ,\
 769                             /*DOC*/       "forces the program to make a conversion" ,\
 770                             /*Parameter*/ &do_convert          ,\
 771                             /*Def 1*/     "0"             ,\
 772                             /*Def 2*/     "1"             ,\
 773                             /*Min_value*/ "0"            ,\
 774                             /*Max Value*/ "1"             \
 775                    );
 776
 777
 778
 779 /*PARAMETER PROTOTYPE*/
 780
 781      declare_name (se_name);
 782      get_cl_param(\
 783                             /*argc*/      argc          ,\
 784                             /*argv*/      argv          ,\
 785                             /*output*/    &le           ,\
 786                             /*Name*/      "-quiet"      ,\
 787                             /*Flag*/      &quiet        ,\
 788                             /*TYPE*/      "W_F"         ,\
 789                             /*OPTIONAL?*/ OPTIONAL      ,\
 790                             /*MAX Nval*/  1             ,\
 791                             /*DOC*/       "Defines the file in which the log output is written"          ,\
 792                             /*Parameter*/ &se_name      ,\
 793                             /*Def 1*/     "stderr"      ,\
 794                             /*Def 2*/     "/dev/null"   ,\
 795                             /*Min_value*/ "any"         ,\
 796                             /*Max Value*/ "any"          \
 797                    );
 798      if (type_only==1)sprintf ( se_name, "/dev/null");
 799
 800      /*PARAMETER PROTOTYPE:    DO FORMAT      */
 801                get_cl_param(\
 802                             /*argc*/      argc             ,\
 803                             /*argv*/      argv             ,\
 804                             /*output*/    &le              ,\
 805                             /*Name*/      "-check_configuration"        ,\
 806                             /*Flag*/      &check_configuration       ,\
 807                             /*TYPE*/      "FL"              ,\
 808                             /*OPTIONAL?*/ OPTIONAL         ,\
 809                             /*MAX Nval*/  1                ,\
 810                             /*DOC*/       "checks that the required programs are installed" ,\
 811                             /*Parameter*/ &check_configuration          ,\
 812                             /*Def 1*/     "0"             ,\
 813                             /*Def 2*/     "1"             ,\
 814                             /*Min_value*/ "0"            ,\
 815                             /*Max Value*/ "1"             \
 816                             );
 817           /*PARAMETER PROTOTYPE:    UPDATE      */
 818                get_cl_param(\
 819                             /*argc*/      argc             ,\
 820                             /*argv*/      argv             ,\
 821                             /*output*/    &le              ,\
 822                             /*Name*/      "-update"        ,\
 823                             /*Flag*/      &update,\
 824                             /*TYPE*/      "FL"              ,\
 825                             /*OPTIONAL?*/ OPTIONAL         ,\
 826                             /*MAX Nval*/  1                ,\
 827                             /*DOC*/       "checks the existence of an updated version" ,\
 828                             /*Parameter*/ &update          ,\
 829                             /*Def 1*/     "0"             ,\
 830                             /*Def 2*/     "1"             ,\
 831                             /*Min_value*/ "0"            ,\
 832                             /*Max Value*/ "1"             \
 833                             );
 834
 835
 836
 837      if ( check_configuration)
 838        {
 839
 840          check_configuration4program();
 841          return EXIT_SUCCESS;
 842
 843        }
 844      if ( update)
 845        {
 846          myexit (check_for_update(DISTRIBUTION_ADDRESS));
 847        }
 848      if ( do_version)
 849        {
 850          fprintf ( stdout, "PROGRAM: %s (%s)\n",PROGRAM,VERSION);
 851          return EXIT_SUCCESS;
 852        }
 853
 854
 855      le=vfopen ( se_name, "w");
 856      fprintf ( le, "\nPROGRAM: %s (%s)\n",PROGRAM,VERSION);
 857
 858 /*PARAMETER PROTOTYPE: RUN NAME*/
 859                declare_name (full_log);
 860                get_cl_param(\
 861                             /*argc*/      argc           ,\
 862                             /*argv*/      argv          ,\
 863                             /*output*/    &le           ,\
 864                             /*Name*/      "-full_log"   ,\
 865                             /*Flag*/      &garbage      ,\
 866                             /*TYPE*/      "S"          ,\
 867                             /*OPTIONAL?*/ OPTIONAL      ,\
 868                             /*MAX Nval*/  1             ,\
 869                             /*DOC*/       "Sets the prefix of all the output files"          ,\
 870                             /*Parameter*/ &full_log     ,\
 871                             /*Def 1*/     "NULL"        ,\
 872                             /*Def 2*/     "full_log"            ,\
 873                             /*Min_value*/ "any"         ,\
 874                             /*Max Value*/ "any"          \
 875                    );
 876                vremove(full_log);
 877 /*PARAMETER PROTOTYPE: RUN NAME*/
 878                declare_name (genepred_score);
 879                get_cl_param(\
 880                             /*argc*/      argc           ,\
 881                             /*argv*/      argv          ,\
 882                             /*output*/    &le           ,\
 883                             /*Name*/      "-genepred_score"   ,\
 884                             /*Flag*/      &garbage      ,\
 885                             /*TYPE*/      "S"          ,\
 886                             /*OPTIONAL?*/ OPTIONAL      ,\
 887                             /*MAX Nval*/  1             ,\
 888                             /*DOC*/       "nsd,tot, <seq_name>"          ,\
 889                             /*Parameter*/ &genepred_score     ,\
 890                             /*Def 1*/     "nsd"        ,\
 891                             /*Def 2*/     ""            ,\
 892                             /*Min_value*/ "any"         ,\
 893                             /*Max Value*/ "any"          \
 894                    );
 895 /*PARAMETER PROTOTYPE: RUN NAME*/
 896                declare_name (run_name);
 897                get_cl_param(\
 898                             /*argc*/      argc           ,\
 899                             /*argv*/      argv          ,\
 900                             /*output*/    &le           ,\
 901                             /*Name*/      "-run_name"   ,\
 902                             /*Flag*/      &garbage      ,\
 903                             /*TYPE*/      "S"          ,\
 904                             /*OPTIONAL?*/ OPTIONAL      ,\
 905                             /*MAX Nval*/  1             ,\
 906                             /*DOC*/       "Sets the prefix of all the output files"          ,\
 907                             /*Parameter*/ &run_name     ,\
 908                             /*Def 1*/     "NULL"        ,\
 909                             /*Def 2*/     ""            ,\
 910                             /*Min_value*/ "any"         ,\
 911                             /*Max Value*/ "any"          \
 912                    );
 913
 914 /*PARAMETER PROTOTYPE: MEM MODE*/
 915                declare_name(mem_mode);
 916                get_cl_param(\
 917                             /*argc*/      argc          ,\
 918                             /*argv*/      argv          ,\
 919                             /*output*/    &le           ,\
 920                             /*Name*/      "-mem_mode"   ,\
 921                             /*Flag*/      &garbage      ,\
 922                             /*TYPE*/      "S"          ,\
 923                             /*OPTIONAL?*/ OPTIONAL      ,\
 924                             /*MAX Nval*/  1             ,\
 925                             /*DOC*/       "Deprecated" ,\
 926                             /*Parameter*/ &mem_mode     ,\
 927                             /*Def 1*/     "mem"         ,\
 928                             /*Def 2*/     ""            ,\
 929                             /*Min_value*/ "any"         ,\
 930                             /*Max Value*/ "any"          \
 931                    );
 932
 933 /*PARAMETER PROTOTYPE: EXTEND  */
 934                get_cl_param(\
 935                             /*argc*/      argc          ,\
 936                             /*argv*/      argv          ,\
 937                             /*output*/    &le           ,\
 938                             /*Name*/      "-extend"     ,\
 939                             /*Flag*/      &do_extend    ,\
 940                             /*TYPE*/      "D"           ,\
 941                             /*OPTIONAL?*/ OPTIONAL      ,\
 942                             /*MAX Nval*/  1             ,\
 943                             /*DOC*/       "Do Library Extention On the Fly"          ,\
 944                             /*Parameter*/ &do_extend    ,\
 945                             /*Def 1*/     "1"           ,\
 946                             /*Def 2*/     "1"           ,\
 947                             /*Min_value*/ "any"         ,\
 948                             /*Max Value*/ "any"          \
 949                    );
 950 /*PARAMETER PROTOTYPE: EXTEND  */
 951                declare_name (extend_mode);
 952                get_cl_param(\
 953                             /*argc*/      argc          ,\
 954                             /*argv*/      argv          ,\
 955                             /*output*/    &le           ,\
 956                             /*Name*/      "-extend_mode"     ,\
 957                             /*Flag*/      &garbage    ,\
 958                             /*TYPE*/      "S"           ,\
 959                             /*OPTIONAL?*/ OPTIONAL      ,\
 960                             /*MAX Nval*/  1             ,\
 961                             /*DOC*/       "Library extension mode"          ,\
 962                             /*Parameter*/ &extend_mode    ,\
 963                             /*Def 1*/     "very_fast_triplet"           ,\
 964                             /*Def 2*/     ""           ,\
 965                             /*Min_value*/ "any"         ,\
 966                             /*Max Value*/ "any"          \
 967                    );
 968                /*PARAMETER PROTOTYPE: EXTEND  */
 969                get_cl_param(\
 970                             /*argc*/      argc          ,\
 971                             /*argv*/      argv          ,\
 972                             /*output*/    &le           ,\
 973                             /*Name*/      "-max_n_pair"     ,\
 974                             /*Flag*/      &garbage    ,\
 975                             /*TYPE*/      "D"           ,\
 976                             /*OPTIONAL?*/ OPTIONAL      ,\
 977                             /*MAX Nval*/  1             ,\
 978                             /*DOC*/       "Indicates the Number of Pairs to Compare when making prf Vs prf. 0<=>every pair "          ,\
 979                             /*Parameter*/ &max_n_pair    ,\
 980                             /*Def 1*/     "10"           ,\
 981                             /*Def 2*/     "3"           ,\
 982                             /*Min_value*/ "any"         ,\
 983                             /*Max Value*/ "any"          \
 984                    );
 985
 986 /*PARAMETER PROTOTYPE: SEQUENCES TO EXTEND */
 987         seq_name_for_quadruplet=declare_char ( 200, STRING);
 988         nseq_for_quadruplet=get_cl_param(\
 989                             /*argc*/      argc          ,\
 990                             /*argv*/      argv          ,\
 991                             /*output*/    &le           ,\
 992                             /*Name*/      "-seq_name_for_quadruplet"         ,\
 993                             /*Flag*/      &garbage      ,\
 994                             /*TYPE*/      "S"           ,\
 995                             /*OPTIONAL?*/ OPTIONAL      ,\
 996                             /*MAX Nval*/  200           ,\
 997                             /*DOC*/       "Indicates which sequence must be used to compute quadruplets"          ,\
 998                             /*Parameter*/ seq_name_for_quadruplet    ,\
 999                             /*Def 1*/     "all",\
1000                             /*Def 2*/     ""       ,\
1001                             /*Min_value*/ "any"         ,\
1002                             /*Max Value*/ "any"          \
1003                    );
1004 /*PARAMETER PROTOTYPE: COMPACT */
1005                declare_name (compact_mode);
1006                get_cl_param(\
1007                             /*argc*/      argc          ,\
1008                             /*argv*/      argv          ,\
1009                             /*output*/    &le           ,\
1010                             /*Name*/      "-compact"    ,\
1011                             /*Flag*/      &do_compact   ,\
1012                             /*TYPE*/      "S"          ,\
1013                             /*OPTIONAL?*/ OPTIONAL      ,\
1014                             /*MAX Nval*/  1             ,\
1015                             /*DOC*/       "Deprecated"          ,\
1016                             /*Parameter*/ &compact_mode ,\
1017                             /*Def 1*/     "default"      ,\
1018                             /*Def 2*/     "default"      ,\
1019                             /*Min_value*/ "0"           ,\
1020                             /*Max Value*/ "1"           \
1021                    );
1022
1023
1024 /*PARAMETER PROTOTYPE:        CLEAN*/
1025                declare_name ( clean_mode);
1026                get_cl_param(\
1027                             /*argc*/      argc          ,\
1028                             /*argv*/      argv          ,\
1029                             /*output*/    &le           ,\
1030                             /*Name*/      "-clean"      ,\
1031                             /*Flag*/      &do_clean     ,\
1032                             /*TYPE*/      "S"           ,\
1033                             /*OPTIONAL?*/ OPTIONAL      ,\
1034                             /*MAX Nval*/  1             ,\
1035                             /*DOC*/       "Deprecated"          ,\
1036                             /*Parameter*/ &clean_mode   ,\
1037                             /*Def 1*/     "no"          ,\
1038                             /*Def 2*/     "shadow"      ,\
1039                             /*Min_value*/ "any"         ,\
1040                             /*Max Value*/ "any"         \
1041                    );
1042
1043 /*PARAMETER PROTOTYPE:        DO SELF */
1044                get_cl_param(\
1045                             /*argc*/      argc          ,\
1046                             /*argv*/      argv          ,\
1047                             /*output*/    &le           ,\
1048                             /*Name*/      "-do_self"    ,\
1049                             /*Flag*/      &do_self      ,\
1050                             /*TYPE*/      "FL"          ,\
1051                             /*OPTIONAL?*/ OPTIONAL      ,\
1052                             /*MAX Nval*/  0             ,\
1053                             /*DOC*/       "Make self extension. Used by Mocca"          ,\
1054                             /*Parameter*/ &do_self      ,\
1055                             /*Def 1*/     "0"           ,\
1056                             /*Def 2*/     "1"           ,\
1057                             /*Min_value*/ "0"           ,\
1058                             /*Max Value*/ "1"           \
1059                    );
1060
1061 /*PARAMETER PROTOTYPE:        DO NORMALISE */
1062                get_cl_param(\
1063                             /*argc*/      argc          ,\
1064                             /*argv*/      argv          ,\
1065                             /*output*/    &le           ,\
1066                             /*Name*/      "-do_normalise"    ,\
1067                             /*Flag*/      &garbage      ,\
1068                             /*TYPE*/      "D"          ,\
1069                             /*OPTIONAL?*/ OPTIONAL      ,\
1070                             /*MAX Nval*/  1             ,\
1071                             /*DOC*/       "Normalisation factor when computing scores"          ,\
1072                             /*Parameter*/ &do_normalise ,\
1073                             /*Def 1*/     "1000"           ,\
1074                             /*Def 2*/     "1000"       ,\
1075                             /*Min_value*/ "-10000"           ,\
1076                             /*Max Value*/ "10000"           \
1077                    );
1078 /*PARAMETER PROTOTYPE:        IN */
1079                template_file_list=declare_char (100, STRING);
1080                n_template_file=get_cl_param(                    \
1081                             /*argc*/      argc          ,\
1082                             /*argv*/      argv          ,\
1083                             /*output*/    &le           ,\
1084                             /*Name*/      "-template_file"         ,\
1085                             /*Flag*/      &garbage      ,\
1086                             /*TYPE*/      "S"           ,\
1087                             /*OPTIONAL?*/ OPTIONAL      ,\
1088                             /*MAX Nval*/  1000           ,\
1089                             /*DOC*/       "List of templates file for the sequences",\
1090                             /*Parameter*/ template_file_list     ,      \
1091                             /*Def 1*/    "",\
1092                             /*Def 2*/     "stdin"       ,\
1093                             /*Min_value*/ "any"         ,\
1094                             /*Max Value*/ "any"          \
1095                                           );
1096
1097 /*PARAMETER PROTOTYPE:    VERSION      */
1098                setenv_list=declare_char (100, STRING);
1099                n_setenv=get_cl_param(\
1100                             /*argc*/      argc             ,\
1101                             /*argv*/      argv             ,\
1102                             /*output*/    &le              ,\
1103                             /*Name*/      "-setenv"        ,\
1104                             /*Flag*/      &do_version        ,\
1105                             /*TYPE*/      "S"              ,\
1106                             /*OPTIONAL?*/ OPTIONAL         ,\
1107                             /*MAX Nval*/  2                ,\
1108                             /*DOC*/       "Declares a parameter variable" ,\
1109                             /*Parameter*/ setenv_list          ,        \
1110                             /*Def 1*/     "0"             ,\
1111                             /*Def 2*/     "1"             ,\
1112                             /*Min_value*/ "0"            ,\
1113                             /*Max Value*/ "1"             \
1114                                           );
1115 /*PARAMETER PROTOTYPE:        IN */
1116                template_mode_list=declare_char (100, STRING);
1117                n_template_mode=get_cl_param(                    \
1118                             /*argc*/      argc          ,\
1119                             /*argv*/      argv          ,\
1120                             /*output*/    &le           ,\
1121                             /*Name*/      "-template_mode"         ,\
1122                             /*Flag*/      &garbage      ,\
1123                             /*TYPE*/      "S"           ,\
1124                             /*OPTIONAL?*/ OPTIONAL      ,\
1125                             /*MAX Nval*/  1000           ,\
1126                             /*DOC*/       "List of template procedures",\
1127                             /*Parameter*/ template_mode_list     ,      \
1128                             /*Def 1*/    "",\
1129                             /*Def 2*/     "stdin"       ,\
1130                             /*Min_value*/ "any"         ,\
1131                             /*Max Value*/ "any"          \
1132                                           );
1133                for (a=0; a<n_template_mode; a++)
1134                  {
1135                    sprintf (template_file_list[n_template_file++], "%s", template_mode_list [a]);
1136                  }
1137 /*PARAMETER PROTOTYPE:        remove_template_file*/
1138
1139                get_cl_param(\
1140                             /*argc*/      argc          ,\
1141                             /*argv*/      argv          ,\
1142                             /*output*/    &le           ,\
1143                             /*Name*/      "-remove_template_file"      ,\
1144                             /*Flag*/      &remove_template_file     ,\
1145                             /*TYPE*/      "D"           ,\
1146                             /*OPTIONAL?*/ OPTIONAL      ,\
1147                             /*MAX Nval*/  1             ,\
1148                             /*DOC*/       "Remove all the template files: 0 keep all, 1: only remove the template files 2: remove template files AND template lists "          ,\
1149                             /*Parameter*/ &remove_template_file   ,\
1150                             /*Def 1*/     "0"          ,\
1151                             /*Def 2*/     "1"      ,\
1152                             /*Min_value*/ "any"         ,\
1153                             /*Max Value*/ "any"         \
1154                    );
1155                set_int_variable ("remove_template_file", remove_template_file);
1156
1157         /*PARAMETER PROTOTYPE:        IN */
1158                profile_template_file_list=declare_char (100, STRING);
1159                n_profile_template_file=get_cl_param(                    \
1160                             /*argc*/      argc          ,\
1161                             /*argv*/      argv          ,\
1162                             /*output*/    &le           ,\
1163                             /*Name*/      "-profile_template_file"         ,\
1164                             /*Flag*/      &garbage      ,\
1165                             /*TYPE*/      "S"           ,\
1166                             /*OPTIONAL?*/ OPTIONAL      ,\
1167                             /*MAX Nval*/  1000           ,\
1168                             /*DOC*/       "List of templates files asscoaciated with profiles",\
1169                             /*Parameter*/ profile_template_file_list     , \
1170                             /*Def 1*/    "",\
1171                             /*Def 2*/     "stdin"       ,\
1172                             /*Min_value*/ "any"         ,\
1173                             /*Max Value*/ "any"          \
1174                                           );
1175
1176                /*PARAMETER PROTOTYPE:        IN */
1177         list_file=declare_char (2000, STRING);
1178         n_list=get_cl_param(\
1179                             /*argc*/      argc          ,\
1180                             /*argv*/      argv          ,\
1181                             /*output*/    &le           ,\
1182                             /*Name*/      "-in"         ,\
1183                             /*Flag*/      &garbage      ,\
1184                             /*TYPE*/      "S"           ,\
1185                             /*OPTIONAL?*/ OPTIONAL      ,\
1186                             /*MAX Nval*/  2000           ,\
1187                             /*DOC*/       "Reads the Ssequences, Mmethods, Llibraries,Xmatrices,Rprofiles,Pstructures,AAlignments"          ,\
1188                             /*Parameter*/ list_file     ,\
1189                             /*Def 1*/    "",\
1190                             /*Def 2*/     "stdin"       ,\
1191                             /*Min_value*/ "any"         ,\
1192                             /*Max Value*/ "any"          \
1193                                           );
1194
1195
1196         /*PARAMETER PROTOTYPE:        IN */
1197         seq_list=declare_char (1000, STRING);
1198         n_seq_list=get_cl_param(                                \
1199                                 /*argc*/      argc          ,   \
1200                                 /*argv*/      argv          ,   \
1201                                 /*output*/    &le           ,   \
1202                                 /*Name*/      "-seq"         ,  \
1203                                 /*Flag*/      &garbage      ,   \
1204                                 /*TYPE*/      "S"           ,   \
1205                                 /*OPTIONAL?*/ OPTIONAL      ,   \
1206                                 /*MAX Nval*/  1000           ,          \
1207                                 /*DOC*/       "List of sequences in any acceptable format", \
1208                                 /*Parameter*/ seq_list     ,            \
1209                                 /*Def 1*/    "",                        \
1210                                 /*Def 2*/     "stdin"       ,           \
1211                                 /*Min_value*/ "any"         ,           \
1212                                 /*Max Value*/ "any"                     \
1213                                               );
1214         aln_file_list=declare_char (1000, STRING);
1215         n_aln_file_list=get_cl_param(                           \
1216                                 /*argc*/      argc          ,   \
1217                                 /*argv*/      argv          ,   \
1218                                 /*output*/    &le           ,   \
1219                                 /*Name*/      "-aln"         ,  \
1220                                 /*Flag*/      &garbage      ,   \
1221                                 /*TYPE*/      "S"           ,   \
1222                                 /*OPTIONAL?*/ OPTIONAL      ,   \
1223                                 /*MAX Nval*/  1000           ,          \
1224                                 /*DOC*/       "List of sequences in any acceptable format", \
1225                                 /*Parameter*/ aln_file_list     ,               \
1226                                 /*Def 1*/    "",                        \
1227                                 /*Def 2*/     "stdin"       ,           \
1228                                 /*Min_value*/ "any"         ,           \
1229                                 /*Max Value*/ "any"                     \
1230                                               );
1231         method_limits=declare_char (1000, STRING);
1232         n_method_limits=get_cl_param(                           \
1233                                 /*argc*/      argc          ,   \
1234                                 /*argv*/      argv          ,   \
1235                                 /*output*/    &le           ,   \
1236                                 /*Name*/      "-method_limits"         ,        \
1237                                 /*Flag*/      &garbage      ,   \
1238                                 /*TYPE*/      "S"           ,   \
1239                                 /*OPTIONAL?*/ OPTIONAL      ,   \
1240                                 /*MAX Nval*/  1000           ,          \
1241                                 /*DOC*/       "List of limits for selected methods: method maxnseq maxlen (-1 = nolimit)", \
1242                                 /*Parameter*/ method_limits     ,               \
1243                                 /*Def 1*/    "",                        \
1244                                 /*Def 2*/     ""       ,                \
1245                                 /*Min_value*/ "any"         ,           \
1246                                 /*Max Value*/ "any"                     \
1247                                               );
1248         method_list=declare_char (1000, STRING);
1249         n_method_list=get_cl_param(                             \
1250                                 /*argc*/      argc          ,   \
1251                                 /*argv*/      argv          ,   \
1252                                 /*output*/    &le           ,   \
1253                                 /*Name*/      "-method"         ,       \
1254                                 /*Flag*/      &garbage      ,   \
1255                                 /*TYPE*/      "S"           ,   \
1256                                 /*OPTIONAL?*/ OPTIONAL      ,   \
1257                                 /*MAX Nval*/  1000           ,          \
1258                                 /*DOC*/       "List of sequences in any acceptable format", \
1259                                 /*Parameter*/ method_list     ,         \
1260                                 /*Def 1*/    "",                        \
1261                                 /*Def 2*/     ""       ,                \
1262                                 /*Min_value*/ "any"         ,           \
1263                                 /*Max Value*/ "any"                     \
1264                                               );
1265         lib_file_list=declare_char (1000, STRING);
1266         n_lib_file_list=get_cl_param(                           \
1267                                 /*argc*/      argc          ,   \
1268                                 /*argv*/      argv          ,   \
1269                                 /*output*/    &le           ,   \
1270                                 /*Name*/      "-lib"         ,  \
1271                                 /*Flag*/      &garbage      ,   \
1272                                 /*TYPE*/      "S"           ,   \
1273                                 /*OPTIONAL?*/ OPTIONAL      ,   \
1274                                 /*MAX Nval*/  1000           ,          \
1275                                 /*DOC*/       "List of sequences in any acceptable format", \
1276                                 /*Parameter*/ lib_file_list     ,               \
1277                                 /*Def 1*/    "",                        \
1278                                 /*Def 2*/     "stdin"       ,           \
1279                                 /*Min_value*/ "any"         ,           \
1280                                 /*Max Value*/ "any"                     \
1281                                               );
1282         profile_list=declare_char ( 2000, STRING);
1283         n_profile_list=get_cl_param(                                    \
1284                             /*argc*/      argc             ,\
1285                             /*argv*/      argv             ,\
1286                             /*output*/    &le              ,\
1287                             /*Name*/      "-profile"        ,\
1288                             /*Flag*/      &garbage        ,\
1289                             /*TYPE*/      "S"              ,\
1290                             /*OPTIONAL?*/ OPTIONAL         ,\
1291                             /*MAX Nval*/  2000                ,\
1292                             /*DOC*/       "Input one or many MSA that will be treated as profiles" ,\
1293                             /*Parameter*/ profile_list          ,\
1294                             /*Def 1*/    ""             ,\
1295                             /*Def 2*/    ""             ,\
1296                             /*Min_value*/ "any"            ,\
1297                             /*Max Value*/ "any"             \
1298                                           );
1299         declare_name (profile1);
1300         get_cl_param(                                           \
1301                      /*argc*/      argc             ,           \
1302                             /*argv*/      argv             ,\
1303                             /*output*/    &le              ,\
1304                             /*Name*/      "-profile1"        ,\
1305                             /*Flag*/      &garbage        ,\
1306                             /*TYPE*/      "S"              ,\
1307                             /*OPTIONAL?*/ OPTIONAL         ,\
1308                             /*MAX Nval*/  1                ,\
1309                             /*DOC*/       "Input one profile (ClustalW option)" ,\
1310                             /*Parameter*/ &profile1          ,\
1311                             /*Def 1*/    ""             ,\
1312                             /*Def 2*/    ""             ,\
1313                             /*Min_value*/ "any"            ,\
1314                             /*Max Value*/ "any"             \
1315                    );
1316         declare_name (profile2);
1317         get_cl_param(                                           \
1318                             /*argc*/      argc             ,\
1319                             /*argv*/      argv             ,\
1320                             /*output*/    &le              ,\
1321                             /*Name*/      "-profile2"        ,\
1322                             /*Flag*/      &garbage        ,\
1323                             /*TYPE*/      "S"              ,\
1324                             /*OPTIONAL?*/ OPTIONAL         ,\
1325                             /*MAX Nval*/  1                ,\
1326                             /*DOC*/       "Input a profile (ClustalW option)" ,\
1327                             /*Parameter*/ &profile2          ,\
1328                             /*Def 1*/    ""             ,\
1329                             /*Def 2*/    ""             ,\
1330                             /*Min_value*/ "any"            ,\
1331                             /*Max Value*/ "any"             \
1332                    );
1333
1334         pdb_list=declare_char ( 200, STRING);
1335         n_pdb=get_cl_param(\
1336                             /*argc*/      argc          ,\
1337                             /*argv*/      argv          ,\
1338                             /*output*/    &le           ,\
1339                             /*Name*/      "-pdb"         ,\
1340                             /*Flag*/      &garbage      ,\
1341                             /*TYPE*/      "S"           ,\
1342                             /*OPTIONAL?*/ OPTIONAL      ,\
1343                             /*MAX Nval*/  200           ,\
1344                             /*DOC*/       "Reads/fetch a pdb file: PDBID(PDB_CHAIN)[opt] (FIRST,LAST)[opt],"          ,\
1345                             /*Parameter*/ pdb_list     ,\
1346                             /*Def 1*/    "",\
1347                             /*Def 2*/     ""       ,\
1348                             /*Min_value*/ "any"         ,\
1349                             /*Max Value*/ "any"          \
1350                    );
1351
1352 /*PARAMETER PROTOTYPE:    OUT_LIB     */
1353
1354                get_cl_param(\
1355                             /*argc*/      argc          ,\
1356                             /*argv*/      argv          ,\
1357                             /*output*/    &le           ,\
1358                             /*Name*/      "-relax_lib"    ,\
1359                             /*Flag*/      &garbage      ,\
1360                             /*TYPE*/      "D"         ,\
1361                             /*OPTIONAL?*/ OPTIONAL      ,\
1362                             /*MAX Nval*/  1             ,\
1363                             /*DOC*/       "self extend the library, without adding new positions", \
1364                             /*Parameter*/&relax_lib ,\
1365                             /*Def 1*/    "1"      ,\
1366                             /*Def 2*/    "1"      ,\
1367                             /*Min_value*/ "any"         ,\
1368                             /*Max Value*/ "any"          \
1369                    );
1370 /*PARAMETER PROTOTYPE:    OUT_LIB     */
1371
1372                get_cl_param(\
1373                             /*argc*/      argc          ,\
1374                             /*argv*/      argv          ,\
1375                             /*output*/    &le           ,\
1376                             /*Name*/      "-filter_lib"    ,\
1377                             /*Flag*/      &garbage      ,\
1378                             /*TYPE*/      "D"         ,\
1379                             /*OPTIONAL?*/ OPTIONAL      ,\
1380                             /*MAX Nval*/  1             ,\
1381                             /*DOC*/       "Removes from the library every value below the threshold",\
1382                             /*Parameter*/&filter_lib ,\
1383                             /*Def 1*/    "0"      ,\
1384                             /*Def 2*/    "10"      ,\
1385                             /*Min_value*/ "any"         ,\
1386                             /*Max Value*/ "any"          \
1387                    );
1388 /*PARAMETER PROTOTYPE:    SHRINK_LIB     */
1389
1390                get_cl_param(\
1391                             /*argc*/      argc          ,\
1392                             /*argv*/      argv          ,\
1393                             /*output*/    &le           ,\
1394                             /*Name*/      "-shrink_lib"    ,\
1395                             /*Flag*/      &garbage      ,\
1396                             /*TYPE*/      "D"         ,\
1397                             /*OPTIONAL?*/ OPTIONAL      ,\
1398                             /*MAX Nval*/  1             ,\
1399                             /*DOC*/       "Runks linked_pairwise on the lib to remove every useless diagonal"          ,\
1400                             /*Parameter*/&shrink_lib       ,\
1401                             /*Def 1*/    "0"      ,\
1402                             /*Def 2*/    "1"      ,\
1403                             /*Min_value*/ "any"         ,\
1404                             /*Max Value*/ "any"          \
1405                    );
1406 /*PARAMETER PROTOTYPE:    OUT_LIB     */
1407         declare_name (out_lib);
1408                get_cl_param(\
1409                             /*argc*/      argc          ,\
1410                             /*argv*/      argv          ,\
1411                             /*output*/    &le           ,\
1412                             /*Name*/      "-out_lib"    ,\
1413                             /*Flag*/      &garbage      ,\
1414                             /*TYPE*/      "W_F"         ,\
1415                             /*OPTIONAL?*/ OPTIONAL      ,\
1416                             /*MAX Nval*/  1             ,\
1417                             /*DOC*/       "Prompts the program to write the computed library file"          ,\
1418                             /*Parameter*/&out_lib       ,\
1419                             /*Def 1*/    "no"      ,\
1420                             /*Def 2*/    "default"      ,\
1421                             /*Min_value*/ "any"         ,\
1422                             /*Max Value*/ "any"          \
1423                    );
1424                /*PARAMETER PROTOTYPE:    OUT_LIB_MODE     */
1425                declare_name (out_lib_mode);
1426                get_cl_param(\
1427                             /*argc*/      argc          ,\
1428                             /*argv*/      argv          ,\
1429                             /*output*/    &le           ,\
1430                             /*Name*/      "-out_lib_mode"    ,\
1431                             /*Flag*/      &garbage      ,\
1432                             /*TYPE*/      "S"         ,\
1433                             /*OPTIONAL?*/ OPTIONAL      ,\
1434                             /*MAX Nval*/  1             ,\
1435                             /*DOC*/       "Save the primary or the extended library:[primary|extende]extended_[pair|lib]_[raw|pc]"          ,\
1436                             /*Parameter*/&out_lib_mode       ,\
1437                             /*Def 1*/    "primary"      ,\
1438                             /*Def 2*/    "extended",\
1439                             /*Min_value*/ "any"         ,\
1440                             /*Max Value*/ "any"          \
1441                    );
1442 /*PARAMETER PROTOTYPE:    LIB_ONLY     */
1443
1444                get_cl_param(\
1445                             /*argc*/      argc          ,\
1446                             /*argv*/      argv          ,\
1447                             /*output*/    &le           ,\
1448                             /*Name*/      "-lib_only"    ,\
1449                             /*Flag*/      &garbage      ,\
1450                             /*TYPE*/      "D"         ,\
1451                             /*OPTIONAL?*/ OPTIONAL      ,\
1452                             /*MAX Nval*/  1             ,\
1453                             /*DOC*/       "Only Compute the library",\
1454                             /*Parameter*/&lib_only       ,\
1455                             /*Def 1*/    "0"      ,\
1456                             /*Def 2*/    "1"      ,\
1457                             /*Min_value*/ "any"         ,\
1458                             /*Max Value*/ "any"          \
1459                    );
1460
1461 /*PARAMETER PROTOTYPE:    OUT_LIB     */
1462         declare_name (outseqweight);
1463                get_cl_param(\
1464                             /*argc*/      argc          ,\
1465                             /*argv*/      argv          ,\
1466                             /*output*/    &le           ,\
1467                             /*Name*/      "-outseqweight"    ,\
1468                             /*Flag*/      &garbage      ,\
1469                             /*TYPE*/      "W_F"         ,\
1470                             /*OPTIONAL?*/ OPTIONAL      ,\
1471                             /*MAX Nval*/  1             ,\
1472                             /*DOC*/       "Prompts the program to write the sequuence weight values"          ,\
1473                             /*Parameter*/&outseqweight       ,\
1474                             /*Def 1*/    "no"      ,\
1475                             /*Def 2*/    "default"      ,\
1476                             /*Min_value*/ "any"         ,\
1477                             /*Max Value*/ "any"          \
1478                    );
1479                /*PARAMETER PROTOTYPE:    DPA    */
1480                get_cl_param(\
1481                             /*argc*/      argc          ,\
1482                             /*argv*/      argv          ,\
1483                             /*output*/    &le           ,\
1484                             /*Name*/      "-dpa"  ,\
1485                             /*Flag*/      &dpa    ,\
1486                             /*TYPE*/      "FL"          ,\
1487                             /*OPTIONAL?*/ OPTIONAL      ,\
1488                             /*MAX Nval*/  0             ,\
1489                             /*DOC*/       "Use DPA mode"          ,\
1490                             /*Parameter*/ &dpa    ,\
1491                             /*Def 1*/    "0"            ,\
1492                             /*Def 2*/    "1"            ,\
1493                             /*Min_value*/ "any"         ,\
1494                             /*Max Value*/ "any"          \
1495                    );
1496
1497 /*PARAMETER PROTOTYPE:    SEQ TO ALIGN     */
1498                declare_name (seq_source);
1499                get_cl_param(\
1500                             /*argc*/      argc           ,\
1501                             /*argv*/      argv           ,\
1502                             /*output*/    &le            ,\
1503                             /*Name*/      "-seq_source",\
1504                             /*Flag*/      &garbage       ,\
1505                             /*TYPE*/      "S"          ,\
1506                             /*OPTIONAL?*/ OPTIONAL       ,\
1507                             /*MAX Nval*/  1              ,\
1508                             /*DOC*/       "Indicates the files that will be used as sequence sources, important for dpa. With the default mode alignments must be provided with the Sflag as well as tye Aflag if they contribute novel sequences",\
1509                             /*Parameter*/ &seq_source   ,\
1510                             /*Def 1*/    "ANY"          ,\
1511                             /*Def 2*/    ""              ,\
1512                             /*Min_value*/ "any"          ,\
1513                             /*Max Value*/ "any"           \
1514                    );
1515
1516 /*PARAMETER PROTOTYPE:    COSMETIC PENALTY     */
1517                get_cl_param(\
1518                             /*argc*/      argc          ,\
1519                             /*argv*/      argv          ,\
1520                             /*output*/    &le           ,\
1521                             /*Name*/      "-cosmetic_penalty" ,\
1522                             /*Flag*/      &garbage      ,\
1523                             /*TYPE*/      "D"           ,\
1524                             /*OPTIONAL?*/ OPTIONAL      ,\
1525                             /*MAX Nval*/  1             ,\
1526                             /*DOC*/       "A very low Gap Opening Penalty.It only affects the non stable portions of the alignmnent.Negative values penalize gaps, positive values reward them"          ,\
1527                             /*Parameter*/ &cosmetic_penalty          ,\
1528                             /*Def 1*/    "0"            ,\
1529                             /*Def 2*/    "0"             ,\
1530                             /*Min_value*/ "any"         ,\
1531                             /*Max Value*/ "any"          \
1532                    );
1533 /*PARAMETER PROTOTYPE:    GAPOPEN     */
1534                get_cl_param(\
1535                             /*argc*/      argc          ,\
1536                             /*argv*/      argv          ,\
1537                             /*output*/    &le           ,\
1538                             /*Name*/      "-gapopen"    ,\
1539                             /*Flag*/      &garbage      ,\
1540                             /*TYPE*/      "D"           ,\
1541                             /*OPTIONAL?*/ OPTIONAL      ,\
1542                             /*MAX Nval*/  1             ,\
1543                             /*DOC*/       "Gap opening penalty. Must be negative, best matches get a score of 1000"          ,\
1544                             /*Parameter*/ &gop          ,\
1545                             /*Def 1*/    "0"            ,\
1546                             /*Def 2*/    ""             ,\
1547                             /*Min_value*/ "any"         ,\
1548                             /*Max Value*/ "any"          \
1549                    );
1550
1551 /*PARAMETER PROTOTYPE:    GAPEXT     */
1552                get_cl_param(\
1553                             /*argc*/      argc          ,\
1554                             /*argv*/      argv          ,\
1555                             /*output*/    &le           ,\
1556                             /*Name*/      "-gapext"     ,\
1557                             /*Flag*/      &garbage      ,\
1558                             /*TYPE*/      "D"           ,\
1559                             /*OPTIONAL?*/ OPTIONAL      ,\
1560                             /*MAX Nval*/  1             ,\
1561                             /*DOC*/       "Gap Extension Penalty. Positive values give rewards to gaps and prevent the alignment of unrelated segments"          ,\
1562                             /*Parameter*/ &gep          ,\
1563                             /*Def 1*/    "0"            ,\
1564                             /*Def 2*/    ""             ,\
1565                             /*Min_value*/ "any"         ,\
1566                             /*Max Value*/ "any"         \
1567                    );
1568
1569 /*PARAMETER PROTOTYPE:    F_GAPOPEN     */
1570                get_cl_param(\
1571                             /*argc*/      argc          ,\
1572                             /*argv*/      argv          ,\
1573                             /*output*/    &le           ,\
1574                             /*Name*/      "-fgapopen"    ,\
1575                             /*Flag*/      &garbage      ,\
1576                             /*TYPE*/      "D"           ,\
1577                             /*OPTIONAL?*/ OPTIONAL      ,\
1578                             /*MAX Nval*/  1             ,\
1579                             /*DOC*/       "Deprecated"          ,\
1580                             /*Parameter*/ &f_gop          ,\
1581                             /*Def 1*/    "0"            ,\
1582                             /*Def 2*/    ""             ,\
1583                             /*Min_value*/ "any"         ,\
1584                             /*Max Value*/ "any"          \
1585                    );
1586 /*PARAMETER PROTOTYPE:    F_GAPEXT     */
1587                get_cl_param(\
1588                             /*argc*/      argc          ,\
1589                             /*argv*/      argv          ,\
1590                             /*output*/    &le           ,\
1591                             /*Name*/      "-fgapext"     ,\
1592                             /*Flag*/      &garbage      ,\
1593                             /*TYPE*/      "D"           ,\
1594                             /*OPTIONAL?*/ OPTIONAL      ,\
1595                             /*MAX Nval*/  1             ,\
1596                             /*DOC*/       "Deprecated"          ,\
1597                             /*Parameter*/ &f_gep          ,\
1598                             /*Def 1*/    "0"            ,\
1599                             /*Def 2*/    ""             ,\
1600                             /*Min_value*/ "any"         ,\
1601                             /*Max Value*/ "any"         \
1602                    );
1603 /*PARAMETER PROTOTYPE:    NEW_TREE     */
1604                get_cl_param(\
1605                             /*argc*/      argc          ,\
1606                             /*argv*/      argv          ,\
1607                             /*output*/    &le           ,\
1608                             /*Name*/      "-nomatch"     ,\
1609                             /*Flag*/      &garbage      ,\
1610                             /*TYPE*/      "D"           ,\
1611                             /*OPTIONAL?*/ OPTIONAL      ,\
1612                             /*MAX Nval*/  1             ,\
1613                             /*DOC*/       "Deprecated"          ,\
1614                             /*Parameter*/ &nomatch          ,\
1615                             /*Def 1*/    "0"            ,\
1616                             /*Def 2*/    "0"             ,\
1617                             /*Min_value*/ "any"         ,\
1618                             /*Max Value*/ "any"         \
1619                    );
1620                declare_name ( tree_file);
1621                get_cl_param(\
1622                             /*argc*/      argc          ,\
1623                             /*argv*/      argv          ,\
1624                             /*output*/    &le           ,\
1625                             /*Name*/      "-newtree"    ,\
1626                             /*Flag*/      &garbage      ,\
1627                             /*TYPE*/      "W_F"         ,\
1628                             /*OPTIONAL?*/ OPTIONAL      ,\
1629                             /*MAX Nval*/  1             ,\
1630                             /*DOC*/       "Name of the output guide tree"          ,\
1631                             /*Parameter*/&tree_file     ,\
1632                             /*Def 1*/    "default"      ,\
1633                             /*Def 2*/    ""             ,\
1634                             /*Min_value*/ "any"         ,\
1635                             /*Max Value*/ "any"         \
1636                    );
1637                declare_name ( ph_tree_file);
1638                get_cl_param(\
1639                             /*argc*/      argc          ,\
1640                             /*argv*/      argv          ,\
1641                             /*output*/    &le           ,\
1642                             /*Name*/      "-tree"    ,\
1643                             /*Flag*/      &garbage      ,\
1644                             /*TYPE*/      "W_F"         ,\
1645                             /*OPTIONAL?*/ OPTIONAL      ,\
1646                             /*MAX Nval*/  1             ,\
1647                             /*DOC*/       "Name of the output guide tree"          ,\
1648                             /*Parameter*/&ph_tree_file     ,\
1649                             /*Def 1*/    "NO"      ,\
1650                             /*Def 2*/    "default"             ,\
1651                             /*Min_value*/ "any"         ,\
1652                             /*Max Value*/ "any"         \
1653                    );
1654
1655 /*PARAMETER PROTOTYPE:    USETREE     */
1656                declare_name ( use_tree);
1657                get_cl_param(\
1658                             /*argc*/      argc          ,\
1659                             /*argv*/      argv          ,\
1660                             /*output*/    &le           ,\
1661                             /*Name*/      "-usetree",\
1662                             /*Flag*/      &garbage      ,\
1663                             /*TYPE*/      "R_F"         ,\
1664                             /*OPTIONAL?*/ OPTIONAL      ,\
1665                             /*MAX Nval*/  1             ,\
1666                             /*DOC*/       "Use an existing guide tree"          ,\
1667                             /*Parameter*/ &use_tree     ,\
1668                             /*Def 1*/    "NULL"         ,\
1669                             /*Def 2*/    "NULL"         ,\
1670                             /*Min_value*/ "any"         ,\
1671                             /*Max Value*/ "any"         \
1672                    );
1673                /*PARAMETER PROTOTYPE:    */
1674                declare_name ( tree_mode);
1675                get_cl_param(\
1676                             /*argc*/      argc          ,\
1677                             /*argv*/      argv          ,\
1678                             /*output*/    &le           ,\
1679                             /*Name*/      "-tree_mode"  ,\
1680                             /*Flag*/      &garbage      ,\
1681                             /*TYPE*/      "S"           ,\
1682                             /*OPTIONAL?*/ OPTIONAL      ,\
1683                             /*MAX Nval*/  1             ,\
1684                             /*DOC*/       "nj, upgma, cwph",\
1685                             /*Parameter*/ &tree_mode    ,\
1686                             /*Def 1*/    "nj"         ,\
1687                             /*Def 2*/    "nj"         ,\
1688                             /*Min_value*/ "1"         ,\
1689                             /*Max Value*/ "1"          \
1690                    );
1691 /*PARAMETER PROTOTYPE:    OUT_LIB     */
1692                declare_name ( distance_matrix_mode);
1693                get_cl_param(\
1694                             /*argc*/      argc          ,\
1695                             /*argv*/      argv          ,\
1696                             /*output*/    &le           ,\
1697                             /*Name*/      "-distance_matrix_mode"  ,\
1698                             /*Flag*/      &garbage      ,\
1699                             /*TYPE*/      "S"           ,\
1700                             /*OPTIONAL?*/ OPTIONAL      ,\
1701                             /*MAX Nval*/  1             ,\
1702                             /*DOC*/       "Computation of the distances for the tree: slow, fast, very_fast, ktup"          ,\
1703                             /*Parameter*/ &distance_matrix_mode    ,\
1704                             /*Def 1*/    "ktup"         ,\
1705                             /*Def 2*/    "idscore"         ,\
1706                             /*Min_value*/ "any"         ,\
1707                             /*Max Value*/ "any"          \
1708                    );
1709 /*PARAMETER PROTOTYPE:    OUT_LIB     */
1710                declare_name ( distance_matrix_sim_mode);
1711                get_cl_param(\
1712                             /*argc*/      argc          ,\
1713                             /*argv*/      argv          ,\
1714                             /*output*/    &le           ,\
1715                             /*Name*/      "-distance_matrix_sim_mode"  ,\
1716                             /*Flag*/      &garbage      ,\
1717                             /*TYPE*/      "S"           ,\
1718                             /*OPTIONAL?*/ OPTIONAL      ,\
1719                             /*MAX Nval*/  1             ,\
1720                             /*DOC*/       "Choice of the distance measure: <mat>_sim1, _sim2, _sim3, _cov, _gap"          ,\
1721                             /*Parameter*/ &distance_matrix_sim_mode    ,\
1722                             /*Def 1*/    "idmat_sim1"         ,\
1723                             /*Def 2*/    "idmat_sim1"         ,\
1724                             /*Min_value*/ "any"         ,\
1725                             /*Max Value*/ "any"          \
1726                    );
1727 /*PARAMETER PROTOTYPE:    OUT_LIB     */
1728                get_cl_param(\
1729                             /*argc*/      argc          ,\
1730                             /*argv*/      argv          ,\
1731                             /*output*/    &le           ,\
1732                             /*Name*/      "-quicktree"  ,\
1733                             /*Flag*/      &quicktree    ,\
1734                             /*TYPE*/      "FL"          ,\
1735                             /*OPTIONAL?*/ OPTIONAL      ,\
1736                             /*MAX Nval*/  0             ,\
1737                             /*DOC*/       "Use distance_matrix_mode=very_fast"          ,\
1738                             /*Parameter*/ &quicktree    ,\
1739                             /*Def 1*/    "0"            ,\
1740                             /*Def 2*/    "1"            ,\
1741                             /*Min_value*/ "any"         ,\
1742                             /*Max Value*/ "any"          \
1743                    );
1744                if ( quicktree)sprintf ( distance_matrix_mode, "very_fast");
1745 /*PARAMETER PROTOTYPE:    OUTFILE     */
1746                declare_name ( out_aln);
1747                tot_out_aln=declare_char (200, STRING);
1748                 get_cl_param(\
1749                             /*argc*/      argc          ,\
1750                             /*argv*/      argv          ,\
1751                             /*output*/    &le           ,\
1752                             /*Name*/      "-outfile"    ,\
1753                             /*Flag*/      &garbage      ,\
1754                             /*TYPE*/      "W_F"         ,\
1755                             /*OPTIONAL?*/ OPTIONAL      ,\
1756                             /*MAX Nval*/  1             ,\
1757                             /*DOC*/       "Name of the output alignment"          ,\
1758                             /*Parameter*/ &out_aln      ,\
1759                             /*Def 1*/    "default"      ,\
1760                             /*Def 2*/    ""             ,\
1761                             /*Min_value*/ "any"         ,\
1762                             /*Max Value*/ "any"          \
1763                    );
1764
1765 /*PARAMETER PROTOTYPE:    MAXIMISE     */
1766                get_cl_param(\
1767                             /*argc*/      argc          ,\
1768                             /*argv*/      argv          ,\
1769                             /*output*/    &le           ,\
1770                             /*Name*/      "-maximise"   ,\
1771                             /*Flag*/      &maximise     ,\
1772                             /*TYPE*/      "FL"          ,\
1773                             /*OPTIONAL?*/ OPTIONAL      ,\
1774                             /*MAX Nval*/  0             ,\
1775                             /*DOC*/       "Deprecated"          ,\
1776                             /*Parameter*/ &maximise     ,\
1777                             /*Def 1*/    "1"            ,\
1778                             /*Def 2*/    "1"            ,\
1779                             /*Min_value*/ "any"         ,\
1780                             /*Max Value*/ "any"         \
1781                    );
1782
1783 /*PARAMETER PROTOTYPE:    OUTPUT_FORMAT    */
1784                out_aln_format=declare_char ( 200, STRING);
1785                n_out_aln_format=get_cl_param(\
1786                             /*argc*/      argc           ,\
1787                             /*argv*/      argv           ,\
1788                             /*output*/    &le            ,\
1789                             /*Name*/      "-output"      ,\
1790                             /*Flag*/      &garbage       ,\
1791                             /*TYPE*/      "S"            ,\
1792                             /*OPTIONAL?*/ OPTIONAL       ,\
1793                             /*MAX Nval*/  200              ,\
1794                             /*DOC*/       "Specifies one or many formats that must be output: clustalw_aln, msf_aln. The file extension is the output format"           ,\
1795                             /*Parameter*/ out_aln_format,\
1796                             /*Def 1*/    "aln,html"           ,\
1797                             /*Def 2*/    "1"             ,\
1798                             /*Min_value*/ "any"          ,\
1799                             /*Max Value*/ "any"           \
1800                    );
1801 /*PARAMETER PROTOTYPE:    INFILE    */
1802                declare_name (infile);
1803                get_cl_param(\
1804                             /*argc*/      argc           ,\
1805                             /*argv*/      argv           ,\
1806                             /*output*/    &le            ,\
1807                             /*Name*/      "-infile"      ,\
1808                             /*Flag*/      &garbage       ,\
1809                             /*TYPE*/      "R_F"            ,\
1810                             /*OPTIONAL?*/ OPTIONAL       ,\
1811                             /*MAX Nval*/  1              ,\
1812                             /*DOC*/       "input a pre-computed alignment, or a file to reformat"           ,\
1813                             /*Parameter*/ &infile        ,\
1814                             /*Def 1*/    ""              ,\
1815                             /*Def 2*/    ""              ,\
1816                             /*Min_value*/ "any"          ,\
1817                             /*Max Value*/ "any"           \
1818                    );
1819
1820 /*PARAMETER PROTOTYPE:    INFILE    */
1821                declare_name (matrix);
1822                get_cl_param(\
1823                             /*argc*/      argc           ,\
1824                             /*argv*/      argv           ,\
1825                             /*output*/    &le            ,\
1826                             /*Name*/      "-matrix"      ,\
1827                             /*Flag*/      &garbage       ,\
1828                             /*TYPE*/      "S"            ,\
1829                             /*OPTIONAL?*/ OPTIONAL       ,\
1830                             /*MAX Nval*/  1              ,\
1831                             /*DOC*/       "Specifies the substitution matrix.",\
1832                             /*Parameter*/ &matrix        ,\
1833                             /*Def 1*/    "default"              ,\
1834                             /*Def 2*/    "default"    ,\
1835                             /*Min_value*/ "any"          ,\
1836                             /*Max Value*/ "any"           \
1837                    );
1838 /*PARAMETER PROTOTYPE:    TG_MODE    */
1839
1840                get_cl_param(\
1841                             /*argc*/      argc           ,\
1842                             /*argv*/      argv           ,\
1843                             /*output*/    &le            ,\
1844                             /*Name*/      "-tg_mode"      ,\
1845                             /*Flag*/      &garbage       ,\
1846                             /*TYPE*/      "D"            ,\
1847                             /*OPTIONAL?*/ OPTIONAL       ,\
1848                             /*MAX Nval*/  1              ,\
1849                             /*DOC*/       "0: Penalise Term gap with gapopen and gapext\n1: gapopen only\n2: No penalty\n",\
1850                             /*Parameter*/ &tg_mode        ,\
1851                             /*Def 1*/    "1",\
1852                             /*Def 2*/    "0",\
1853                             /*Min_value*/ "any"          ,\
1854                             /*Max Value*/ "any"           \
1855                    );
1856 /*PARAMETER PROTOTYPE:    DP_MODE    */
1857                declare_name (profile_mode);
1858                get_cl_param(\
1859                             /*argc*/      argc           ,\
1860                             /*argv*/      argv           ,\
1861                             /*output*/    &le            ,\
1862                             /*Name*/      "-profile_mode"      ,\
1863                             /*Flag*/      &garbage       ,\
1864                             /*TYPE*/      "S"            ,\
1865                             /*OPTIONAL?*/ OPTIONAL       ,\
1866                             /*MAX Nval*/  1              ,\
1867                             /*DOC*/       "Function used to compute profile2profile scores",\
1868                             /*Parameter*/ &profile_mode        ,\
1869                             /*Def 1*/    "cw_profile_profile",\
1870                             /*Def 2*/    "cw_profile_profile",\
1871                             /*Min_value*/ "any"          ,\
1872                             /*Max Value*/ "any"           \
1873                    );
1874
1875                declare_name (profile_comparison);
1876                get_cl_param(\
1877                             /*argc*/      argc           ,\
1878                             /*argv*/      argv           ,\
1879                             /*output*/    &le            ,\
1880                             /*Name*/      "-profile_comparison"      ,\
1881                             /*Flag*/      &garbage       ,\
1882                             /*TYPE*/      "S"            ,\
1883                             /*OPTIONAL?*/ OPTIONAL       ,\
1884                             /*MAX Nval*/  1              ,\
1885                             /*DOC*/       "Method used to compare two profiles: full<N>: compares <every | N best> pair of sequence and every pair of structure if a structure method is used,profile: compares only the profiles.  ",\
1886                             /*Parameter*/ &profile_comparison        ,\
1887                             /*Def 1*/    "profile",\
1888                             /*Def 2*/    "full50",\
1889                             /*Min_value*/ "any"          ,\
1890                             /*Max Value*/ "any"           \
1891                    );
1892 /*PARAMETER PROTOTYPE:    DP_MODE    */
1893                declare_name (dp_mode);
1894                get_cl_param(\
1895                             /*argc*/      argc           ,\
1896                             /*argv*/      argv           ,\
1897                             /*output*/    &le            ,\
1898                             /*Name*/      "-dp_mode"      ,\
1899                             /*Flag*/      &garbage       ,\
1900                             /*TYPE*/      "S"            ,\
1901                             /*OPTIONAL?*/ OPTIONAL       ,\
1902                             /*MAX Nval*/  1              ,\
1903                             /*DOC*/       "Type of alignment algorithm used by T-Coffee: gotoh_pair_wise, myers_millers_pair_wise, "           ,\
1904                             /*Parameter*/ &dp_mode        ,\
1905                             /*Def 1*/    "linked_pair_wise",\
1906                             /*Def 2*/    "cfasta_pair_wise",\
1907                             /*Min_value*/ "any"          ,\
1908                             /*Max Value*/ "any"           \
1909                    );
1910 /*PARAMETER PROTOTYPE:    KTUP    */
1911                get_cl_param(\
1912                             /*argc*/      argc           ,\
1913                             /*argv*/      argv           ,\
1914                             /*output*/    &le            ,\
1915                             /*Name*/      "-ktuple"      ,\
1916                             /*Flag*/      &garbage       ,\
1917                             /*TYPE*/      "D"            ,\
1918                             /*OPTIONAL?*/ OPTIONAL       ,\
1919                             /*MAX Nval*/  1              ,\
1920                             /*DOC*/       "Word size when using the heursitic dynamic programming modes fasta_pair_wise and cfasta_pair_wise "           ,\
1921                             /*Parameter*/ &ktup          ,\
1922                             /*Def 1*/    "1",\
1923                             /*Def 2*/    "1",\
1924                             /*Min_value*/ "any"          ,\
1925                             /*Max Value*/ "any"           \
1926                    );
1927 /*PARAMETER PROTOTYPE:    FASTA_STEP    */
1928                get_cl_param(\
1929                             /*argc*/      argc           ,\
1930                             /*argv*/      argv           ,\
1931                             /*output*/    &le            ,\
1932                             /*Name*/      "-ndiag"      ,\
1933                             /*Flag*/      &garbage       ,\
1934                             /*TYPE*/      "D"            ,\
1935                             /*OPTIONAL?*/ OPTIONAL       ,\
1936                             /*MAX Nval*/  1              ,\
1937                             /*DOC*/       "Number of diagonals to consider when using the heursitic dynamic programming modes fasta_pair_wise and cfasta_pair_wise"           ,\
1938                             /*Parameter*/ &fasta_step          ,\
1939                             /*Def 1*/    "0",\
1940                             /*Def 2*/    "10",\
1941                             /*Min_value*/ "any"          ,\
1942                             /*Max Value*/ "any"           \
1943                    );
1944 /*PARAMETER PROTOTYPE:    FASTA_STEP    */
1945                get_cl_param(\
1946                             /*argc*/      argc           ,\
1947                             /*argv*/      argv           ,\
1948                             /*output*/    &le            ,\
1949                             /*Name*/      "-diag_threshold"      ,\
1950                             /*Flag*/      &garbage       ,\
1951                             /*TYPE*/      "D"            ,\
1952                             /*OPTIONAL?*/ OPTIONAL       ,\
1953                             /*MAX Nval*/  1              ,\
1954                             /*DOC*/       "ND"           ,\
1955                             /*Parameter*/ &diag_threshold ,\
1956                             /*Def 1*/    "0",\
1957                             /*Def 2*/    "10",\
1958                             /*Min_value*/ "any"          ,\
1959                             /*Max Value*/ "any"           \
1960                    );
1961 /*PARAMETER PROTOTYPE:    diag_mode    */
1962                get_cl_param(\
1963                             /*argc*/      argc           ,\
1964                             /*argv*/      argv           ,\
1965                             /*output*/    &le            ,\
1966                             /*Name*/      "-diag_mode"      ,\
1967                             /*Flag*/      &garbage       ,\
1968                             /*TYPE*/      "D"            ,\
1969                             /*OPTIONAL?*/ OPTIONAL       ,\
1970                             /*MAX Nval*/  1              ,\
1971                             /*DOC*/       "0: Use the whole Diag\n1: Use the best match\n"           ,\
1972                             /*Parameter*/ &diag_mode          ,\
1973                             /*Def 1*/    "0",\
1974                             /*Def 2*/    "1",
1975                             /*Min_value*/ "any"          ,\
1976                             /*Max Value*/ "any"           \
1977                    );
1978 /*PARAMETER PROTOTYPE:    SIM_MATRIX    */
1979                declare_name (sim_matrix);
1980                get_cl_param(\
1981                             /*argc*/      argc           ,\
1982                             /*argv*/      argv           ,\
1983                             /*output*/    &le            ,\
1984                             /*Name*/      "-sim_matrix"      ,\
1985                             /*Flag*/      &garbage       ,\
1986                             /*TYPE*/      "S"            ,\
1987                             /*OPTIONAL?*/ OPTIONAL       ,\
1988                             /*MAX Nval*/  1              ,\
1989                             /*DOC*/       "Degenerated matrix used to compute a similarity"           ,\
1990                             /*Parameter*/ &sim_matrix        ,\
1991                             /*Def 1*/    "vasiliky",\
1992                             /*Def 2*/    "idmat",\
1993                             /*Min_value*/ "any"          ,\
1994                             /*Max Value*/ "any"           \
1995                    );
1996
1997 /*PARAMETER PROTOTYPE:    INFILE    */
1998                declare_name (transform);
1999                get_cl_param(\
2000                             /*argc*/      argc           ,\
2001                             /*argv*/      argv           ,\
2002                             /*output*/    &le            ,\
2003                             /*Name*/      "-transform"        ,\
2004                             /*Flag*/      &garbage       ,\
2005                             /*TYPE*/      "S"            ,\
2006                             /*OPTIONAL?*/ OPTIONAL       ,\
2007                             /*MAX Nval*/  1              ,\
2008                             /*DOC*/       "dna2rna, rna2dna, dna2prot", \
2009                             /*Parameter*/ &transform          ,\
2010                             /*Def 1*/    ""              ,\
2011                             /*Def 2*/    ""              ,\
2012                             /*Min_value*/ "any"          ,\
2013                             /*Max Value*/ "any"           \
2014                    );
2015 /*PARAMETER PROTOTYPE:    INFILE    */
2016                get_cl_param(                                    \
2017                             /*argc*/      argc           ,\
2018                             /*argv*/      argv           ,\
2019                             /*output*/    &le            ,\
2020                             /*Name*/      "-extend_seq"        ,\
2021                             /*Flag*/      &extend_seq       ,\
2022                             /*TYPE*/      "FL"            ,\
2023                             /*OPTIONAL?*/ OPTIONAL       ,\
2024                             /*MAX Nval*/  0             ,\
2025                             /*DOC*/       "extend the sequences",       \
2026                             /*Parameter*/ &extend_seq          ,\
2027                             /*Def 1*/    "0"              ,\
2028                             /*Def 2*/    "1"              ,\
2029                             /*Min_value*/ "any"          ,\
2030                             /*Max Value*/ "any"           \
2031                             );
2032
2033 /*PARAMETER PROTOTYPE:    INFILE    */
2034                declare_name (outorder);
2035                get_cl_param(\
2036                             /*argc*/      argc           ,\
2037                             /*argv*/      argv           ,\
2038                             /*output*/    &le            ,\
2039                             /*Name*/      "-outorder"        ,\
2040                             /*Flag*/      &garbage       ,\
2041                             /*TYPE*/      "S"            ,\
2042                             /*OPTIONAL?*/ OPTIONAL       ,\
2043                             /*MAX Nval*/  1              ,\
2044                             /*DOC*/       "Specifies the order of the sequences in the msa: input or aligned"           ,\
2045                             /*Parameter*/ &outorder       ,\
2046                             /*Def 1*/    "input"          ,\
2047                             /*Def 2*/    "input"        ,\
2048                             /*Min_value*/ "any"          ,\
2049                             /*Max Value*/ "any"           \
2050                    );
2051
2052 /*PARAMETER PROTOTYPE:    INFILE    */
2053                declare_name (inorder);
2054                get_cl_param(\
2055                             /*argc*/      argc           ,\
2056                             /*argv*/      argv           ,\
2057                             /*output*/    &le            ,\
2058                             /*Name*/      "-inorder"        ,\
2059                             /*Flag*/      &garbage       ,\
2060                             /*TYPE*/      "S"            ,\
2061                             /*OPTIONAL?*/ OPTIONAL       ,\
2062                             /*MAX Nval*/  1              ,\
2063                             /*DOC*/       "aligned: sort the sequences in alphabetic order before starting thus making the input order irrelevant but delivering a library in arbitratry order, keep: input order is used in the library but results become input order dependant"           ,\
2064                             /*Parameter*/ &inorder       ,\
2065                             /*Def 1*/    "aligned"          ,\
2066                             /*Def 2*/    "input"        ,\
2067                             /*Min_value*/ "any"          ,\
2068                             /*Max Value*/ "any"           \
2069                    );
2070
2071 /*PARAMETER PROTOTYPE:    INFILE    */
2072                declare_name (output_res_num);
2073                get_cl_param(\
2074                             /*argc*/      argc           ,\
2075                             /*argv*/      argv           ,\
2076                             /*output*/    &le            ,\
2077                             /*Name*/      "-seqnos"        ,\
2078                             /*Flag*/      &garbage       ,\
2079                             /*TYPE*/      "S"            ,\
2080                             /*OPTIONAL?*/ OPTIONAL       ,\
2081                             /*MAX Nval*/  1              ,\
2082                             /*DOC*/       "Adds Residue Numbers to the MSA"           ,\
2083                             /*Parameter*/ &output_res_num ,\
2084                             /*Def 1*/    "off"            ,\
2085                             /*Def 2*/    "on"             ,\
2086                             /*Min_value*/ "any"           ,\
2087                             /*Max Value*/ "any"            \
2088                    );
2089 /*PARAMETER PROTOTYPE:    INFILE    */
2090                declare_name (residue_case);
2091                get_cl_param(\
2092                             /*argc*/      argc           ,\
2093                             /*argv*/      argv           ,\
2094                             /*output*/    &le            ,\
2095                             /*Name*/      "-case"        ,\
2096                             /*Flag*/      &garbage       ,\
2097                             /*TYPE*/      "S"            ,\
2098                             /*OPTIONAL?*/ OPTIONAL       ,\
2099                             /*MAX Nval*/  1              ,\
2100                             /*DOC*/       "Causes the case to be: kept:lower:upper."           ,\
2101                             /*Parameter*/ &residue_case         ,\
2102                             /*Def 1*/    "keep"            ,\
2103                             /*Def 2*/    "upper"             ,\
2104                             /*Min_value*/ "any"           ,\
2105                             /*Max Value*/ "any"            \
2106                    );
2107
2108 /*PARAMETER PROTOTYPE:    CPU     */
2109
2110                get_cl_param(\
2111                             /*argc*/      argc          ,\
2112                             /*argv*/      argv          ,\
2113                             /*output*/    &le           ,\
2114                             /*Name*/      "-cpu"        ,\
2115                             /*Flag*/      &garbage      ,\
2116                             /*TYPE*/      "D"           ,\
2117                             /*OPTIONAL?*/ OPTIONAL      ,\
2118                             /*MAX Nval*/  1             ,\
2119                             /*DOC*/       "Makes it possible to add a pre-specified amount of cpu time to the measured usage"          ,\
2120                             /*Parameter*/ &extra_cpu    ,\
2121                             /*Def 1*/    "0"            ,\
2122                             /*Def 2*/    "0"            ,\
2123                             /*Min_value*/ "any"         ,\
2124                             /*Max Value*/ "any"          \
2125                    );
2126
2127 /*PARAMETER PROTOTYPE:    MAXNSEQ     */
2128
2129                get_cl_param(\
2130                             /*argc*/      argc          ,\
2131                             /*argv*/      argv          ,\
2132                             /*output*/    &le           ,\
2133                             /*Name*/      "-maxnseq"        ,\
2134                             /*Flag*/      &garbage      ,\
2135                             /*TYPE*/      "D"           ,\
2136                             /*OPTIONAL?*/ OPTIONAL      ,\
2137                             /*MAX Nval*/  1             ,\
2138                             /*DOC*/       "Maximum number of sequences (-1=no max)"          ,\
2139                             /*Parameter*/ &maxnseq    ,\
2140                             /*Def 1*/    "1000"            ,\
2141                             /*Def 2*/    "0"            ,\
2142                             /*Min_value*/ "any"         ,\
2143                             /*Max Value*/ "any"          \
2144                    );
2145
2146 /*PARAMETER PROTOTYPE:    MAXLEN     */
2147
2148                get_cl_param(\
2149                             /*argc*/      argc          ,\
2150                             /*argv*/      argv          ,\
2151                             /*output*/    &le           ,\
2152                             /*Name*/      "-maxlen"        ,\
2153                             /*Flag*/      &garbage      ,\
2154                             /*TYPE*/      "D"           ,\
2155                             /*OPTIONAL?*/ OPTIONAL      ,\
2156                             /*MAX Nval*/  1             ,\
2157                             /*DOC*/       "Maximum length of a sequence (-1=no max)"          ,\
2158                             /*Parameter*/ &maxlen    ,\
2159                             /*Def 1*/    "-1"            ,\
2160                             /*Def 2*/    "-1"            ,\
2161                             /*Min_value*/ "any"         ,\
2162                             /*Max Value*/ "any"          \
2163                    );
2164 /*PARAMETER PROTOTYPE:    WEIGHT      */
2165
2166                get_cl_param(\
2167                             /*argc*/      argc             ,\
2168                             /*argv*/      argv             ,\
2169                             /*output*/    &le              ,\
2170                             /*Name*/      "-sample_dp"        ,\
2171                             /*Flag*/      &garbage        ,\
2172                             /*TYPE*/      "D"              ,\
2173                             /*OPTIONAL?*/ OPTIONAL         ,\
2174                             /*MAX Nval*/  1                ,\
2175                             /*DOC*/       "defines the tie breaking strategy (only with gotoh_pair_wise)" ,\
2176                             /*Parameter*/ &sample_dp          ,\
2177                             /*Def 1*/    "0"             ,\
2178                             /*Def 2*/    "1"             ,\
2179                             /*Min_value*/ "0"            ,\
2180                             /*Max Value*/ "2"             \
2181                    );
2182                if ( sample_dp)cputenv ("SAMPLE_DP_4_TCOFFEE=%d", sample_dp);
2183
2184
2185 /*PARAMETER PROTOTYPE:    WEIGHT      */
2186                declare_name ( weight);
2187                get_cl_param(\
2188                             /*argc*/      argc             ,\
2189                             /*argv*/      argv             ,\
2190                             /*output*/    &le              ,\
2191                             /*Name*/      "-weight"        ,\
2192                             /*Flag*/      &garbage        ,\
2193                             /*TYPE*/      "S"              ,\
2194                             /*OPTIONAL?*/ OPTIONAL         ,\
2195                             /*MAX Nval*/  1                ,\
2196                             /*DOC*/       "Defines the library weight: sim OR  sim_(matrix) OR winsim" ,\
2197                             /*Parameter*/ &weight          ,\
2198                             /*Def 1*/    "default"             ,\
2199                             /*Def 2*/    "sim"             ,\
2200                             /*Min_value*/ "any"            ,\
2201                             /*Max Value*/ "any"             \
2202                    );     /*PARAMETER PROTOTYPE:    WEIGHT      */
2203                declare_name ( seq_weight);
2204
2205                get_cl_param(\
2206                             /*argc*/      argc             ,\
2207                             /*argv*/      argv             ,\
2208                             /*output*/    &le              ,\
2209                             /*Name*/      "-seq_weight"        ,\
2210                             /*Flag*/      &garbage        ,\
2211                             /*TYPE*/      "S"              ,\
2212                             /*OPTIONAL?*/ OPTIONAL         ,\
2213                             /*MAX Nval*/  1                ,\
2214                             /*DOC*/       "Defines the sequences weighting scheme t_coffee" ,\
2215                             /*Parameter*/ &seq_weight          ,\
2216                             /*Def 1*/    "t_coffee"             ,\
2217                             /*Def 2*/    "t_coffee"             ,\
2218                             /*Min_value*/ "any"            ,\
2219                             /*Max Value*/ "any"             \
2220                    );
2221
2222 /*PARAMETER PROTOTYPE:    DO ALIGN      */
2223                get_cl_param(\
2224                             /*argc*/      argc             ,\
2225                             /*argv*/      argv             ,\
2226                             /*output*/    &le              ,\
2227                             /*Name*/      "-align"        ,\
2228                             /*Flag*/      &do_align        ,\
2229                             /*TYPE*/      "FL"              ,\
2230                             /*OPTIONAL?*/ OPTIONAL         ,\
2231                             /*MAX Nval*/  0                ,\
2232                             /*DOC*/       "forces the program to make the alignment" ,\
2233                             /*Parameter*/ &do_align          ,\
2234                             /*Def 1*/     "1"             ,\
2235                             /*Def 2*/     "1"             ,\
2236                             /*Min_value*/ "any"            ,\
2237                             /*Max Value*/ "any"             \
2238                    );
2239 /*PARAMETER PROTOTYPE:    DO DOMAIN      */
2240                get_cl_param(\
2241                             /*argc*/      argc             ,\
2242                             /*argv*/      argv             ,\
2243                             /*output*/    &le              ,\
2244                             /*Name*/      "-mocca"        ,\
2245                             /*Flag*/      &do_domain        ,\
2246                             /*TYPE*/      "FL"              ,\
2247                             /*OPTIONAL?*/ OPTIONAL         ,\
2248                             /*MAX Nval*/  0                ,\
2249                             /*DOC*/       "forces the program to extract domains" ,\
2250                             /*Parameter*/ &do_domain          ,\
2251                             /*Def 1*/     "0"             ,\
2252                             /*Def 2*/     "1"             ,\
2253                             /*Min_value*/ "any"            ,\
2254                             /*Max Value*/ "any"             \
2255                    );
2256                if ( !do_domain)
2257                  {
2258 /*PARAMETER PROTOTYPE:    DO DOMAIN      */
2259                    get_cl_param(                                \
2260                             /*argc*/      argc             ,    \
2261                             /*argv*/      argv             ,\
2262                             /*output*/    &le              ,\
2263                             /*Name*/      "-domain"        ,\
2264                             /*Flag*/      &do_domain        ,\
2265                             /*TYPE*/      "FL"              ,\
2266                             /*OPTIONAL?*/ OPTIONAL         ,\
2267                             /*MAX Nval*/  0                ,\
2268                             /*DOC*/       "forces the program to extract domains" ,\
2269                             /*Parameter*/ &do_domain          ,\
2270                             /*Def 1*/     "0"             ,\
2271                             /*Def 2*/     "1"             ,\
2272                             /*Min_value*/ "any"            ,\
2273                             /*Max Value*/ "any"             \
2274                                           );
2275                  }
2276 /*PARAMETER PROTOTYPE:    Domain Param      */
2277                get_cl_param(\
2278                             /*argc*/      argc             ,\
2279                             /*argv*/      argv             ,\
2280                             /*output*/    &le              ,\
2281                             /*Name*/      "-start"        ,\
2282                             /*Flag*/      &domain_start        ,\
2283                             /*TYPE*/      "D"              ,\
2284                             /*OPTIONAL?*/ OPTIONAL         ,\
2285                             /*MAX Nval*/  1                ,\
2286                             /*DOC*/       "start of the master domain in the mocca mode" ,\
2287                             /*Parameter*/ &domain_start          ,\
2288                             /*Def 1*/     "0"             ,\
2289                             /*Def 2*/     "1"             ,\
2290                             /*Min_value*/ "any"            ,\
2291                             /*Max Value*/ "any"             \
2292                    );
2293 get_cl_param(\
2294                             /*argc*/      argc             ,\
2295                             /*argv*/      argv             ,\
2296                             /*output*/    &le              ,\
2297                             /*Name*/      "-len"        ,\
2298                             /*Flag*/      &domain_len        ,\
2299                             /*TYPE*/      "D"              ,\
2300                             /*OPTIONAL?*/ OPTIONAL         ,\
2301                             /*MAX Nval*/  1                ,\
2302                             /*DOC*/       "length of the master domain in the mocca mode" ,\
2303                             /*Parameter*/ &domain_len          ,\
2304                             /*Def 1*/     "0"             ,\
2305                             /*Def 2*/     "1"             ,\
2306                             /*Min_value*/ "any"            ,\
2307                             /*Max Value*/ "any"             \
2308                    );
2309
2310 get_cl_param(\
2311                             /*argc*/      argc             ,\
2312                             /*argv*/      argv             ,\
2313                             /*output*/    &le              ,\
2314                             /*Name*/      "-scale"        ,\
2315                             /*Flag*/      &domain_scale        ,\
2316                             /*TYPE*/      "D"              ,\
2317                             /*OPTIONAL?*/ OPTIONAL         ,\
2318                             /*MAX Nval*/  1                ,\
2319                             /*DOC*/       "Decreases the t_coffee score by Scale, so that non match get negative values" ,\
2320                             /*Parameter*/ &domain_scale          ,\
2321                             /*Def 1*/     "0"             ,\
2322                             /*Def 2*/     "1"             ,\
2323                             /*Min_value*/ "any"            ,\
2324                             /*Max Value*/ "any"             \
2325                    );
2326 get_cl_param(\
2327                             /*argc*/      argc             ,\
2328                             /*argv*/      argv             ,\
2329                             /*output*/    &le              ,\
2330                             /*Name*/      "-mocca_interactive"        ,\
2331                             /*Flag*/      &domain_interactive        ,\
2332                             /*TYPE*/      "FL"             ,\
2333                             /*OPTIONAL?*/ OPTIONAL         ,\
2334                             /*MAX Nval*/  0                ,\
2335                             /*DOC*/       "Runs Mocca in an interactive manneer" ,\
2336                             /*Parameter*/ &domain_interactive,\
2337                             /*Def 1*/     "0"             ,\
2338                             /*Def 2*/     "1"             ,\
2339                             /*Min_value*/ "any"            ,\
2340                             /*Max Value*/ "any"             \
2341                    );
2342 /*PARAMETER PROTOTYPE:    WEIGHT      */
2343                declare_name (method_evaluate_mode);
2344                get_cl_param(\
2345                             /*argc*/      argc             ,\
2346                             /*argv*/      argv             ,\
2347                             /*output*/    &le              ,\
2348                             /*Name*/      "-method_evaluate_mode"        ,\
2349                             /*Flag*/      &garbage        ,\
2350                             /*TYPE*/      "S"              ,\
2351                             /*OPTIONAL?*/ OPTIONAL         ,\
2352                             /*MAX Nval*/  1                ,\
2353                             /*DOC*/       "Specifies which method should be used to evaluate the score at the pairwise level" ,\
2354                             /*Parameter*/ &method_evaluate_mode          ,\
2355                             /*Def 1*/    "default"             ,\
2356                             /*Def 2*/    "default"             ,\
2357                             /*Min_value*/ "any"            ,\
2358                             /*Max Value*/ "any"             \
2359                                           );
2360  /*PARAMETER PROTOTYPE:    WEIGHT      */
2361                declare_name (evaluate_mode);
2362                get_cl_param(\
2363                             /*argc*/      argc             ,\
2364                             /*argv*/      argv             ,\
2365                             /*output*/    &le              ,\
2366                             /*Name*/      "-evaluate_mode"        ,\
2367                             /*Flag*/      &garbage        ,\
2368                             /*TYPE*/      "S"              ,\
2369                             /*OPTIONAL?*/ OPTIONAL         ,\
2370                             /*MAX Nval*/  1                ,\
2371                             /*DOC*/       "Mode used to produce the color output:t_coffee_fast,t_coffee_slow  " ,\
2372                             /*Parameter*/ &evaluate_mode          ,\
2373                             /*Def 1*/    "triplet"             ,\
2374                             /*Def 2*/    "dali"             ,\
2375                             /*Min_value*/ "any"            ,\
2376                             /*Max Value*/ "any"             \
2377                    );
2378                get_cl_param(\
2379                             /*argc*/      argc             ,\
2380                             /*argv*/      argv             ,\
2381                             /*output*/    &le              ,\
2382                             /*Name*/      "-get_type"        ,\
2383                             /*Flag*/      &get_type        ,\
2384                             /*TYPE*/      "FL"              ,\
2385                             /*OPTIONAL?*/ OPTIONAL         ,\
2386                             /*MAX Nval*/  1                ,\
2387                             /*DOC*/       "forces t_coffee top get the type of the sequences" ,\
2388                             /*Parameter*/ &get_type          ,\
2389                             /*Def 1*/    "0"             ,\
2390                             /*Def 2*/    "1"             ,\
2391                             /*Min_value*/ "0"            ,\
2392                             /*Max Value*/ "1"             \
2393                    );
2394
2395 get_cl_param(\
2396                             /*argc*/      argc             ,\
2397                             /*argv*/      argv             ,\
2398                             /*output*/    &le              ,\
2399                             /*Name*/      "-clean_aln"        ,\
2400                             /*Flag*/      &clean_aln        ,\
2401                             /*TYPE*/      "D"              ,\
2402                             /*OPTIONAL?*/ OPTIONAL         ,\
2403                             /*MAX Nval*/  1                ,\
2404                             /*DOC*/       "Forces weak portion of aln to be realigned" ,\
2405                             /*Parameter*/ &clean_aln          ,\
2406                             /*Def 1*/    "0"             ,\
2407                             /*Def 2*/    "1"             ,\
2408                             /*Min_value*/ "0"            ,\
2409                             /*Max Value*/ "1"             \
2410                    );
2411 get_cl_param(\
2412                             /*argc*/      argc             ,\
2413                             /*argv*/      argv             ,\
2414                             /*output*/    &le              ,\
2415                             /*Name*/      "-clean_threshold"        ,\
2416                             /*Flag*/      &clean_threshold        ,\
2417                             /*TYPE*/      "D"              ,\
2418                             /*OPTIONAL?*/ OPTIONAL         ,\
2419                             /*MAX Nval*/  1                ,\
2420                             /*DOC*/       "Threshold for the portions of the MSA that will are realigned by '-clean_evaluate_mode'. The threshold refers to the CORE score set by '-evaluate_mode'" ,\
2421                             /*Parameter*/ &clean_threshold          ,\
2422                             /*Def 1*/     "1"             ,\
2423                             /*Def 2*/     "1"             ,\
2424                             /*Min_value*/ "any"            ,\
2425                             /*Max Value*/ "any"             \
2426                    );
2427 get_cl_param(\
2428                             /*argc*/      argc             ,\
2429                             /*argv*/      argv             ,\
2430                             /*output*/    &le              ,\
2431                             /*Name*/      "-clean_iteration"        ,\
2432                             /*Flag*/      &clean_iteration        ,\
2433                             /*TYPE*/      "D"              ,\
2434                             /*OPTIONAL?*/ OPTIONAL         ,\
2435                             /*MAX Nval*/  1                ,\
2436                             /*DOC*/       "Number of rounds for '-clean_aln'" ,\
2437                             /*Parameter*/ &clean_iteration          ,\
2438                             /*Def 1*/     "1"             ,\
2439                             /*Def 2*/     "1"             ,\
2440                             /*Min_value*/ "any"            ,\
2441                             /*Max Value*/ "any"             \
2442                    );
2443 declare_name (clean_evaluate_mode);
2444 get_cl_param(\
2445                             /*argc*/      argc             ,\
2446                             /*argv*/      argv             ,\
2447                             /*output*/    &le              ,\
2448                             /*Name*/      "-clean_evaluate_mode"        ,\
2449                             /*Flag*/      &garbage        ,\
2450                             /*TYPE*/      "S"              ,\
2451                             /*OPTIONAL?*/ OPTIONAL         ,\
2452                             /*MAX Nval*/  1                ,\
2453                             /*DOC*/       "Mode used to score residues (see evaluate_mode)" ,\
2454                             /*Parameter*/ &clean_evaluate_mode          ,\
2455                             /*Def 1*/    "t_coffee_fast"             ,\
2456                             /*Def 2*/    "t_coffee_fast"             ,\
2457                             /*Min_value*/ "any"            ,\
2458                             /*Max Value*/ "any"             \
2459                    );
2460
2461 /*PARAMETER PROTOTYPE:    DO EXTENDED MATRIX      */
2462                get_cl_param(\
2463                             /*argc*/      argc             ,\
2464                             /*argv*/      argv             ,\
2465                             /*output*/    &le              ,\
2466                             /*Name*/      "-extend_matrix"        ,\
2467                             /*Flag*/      &do_extended_matrix        ,\
2468                             /*TYPE*/      "FL"              ,\
2469                             /*OPTIONAL?*/ OPTIONAL         ,\
2470                             /*MAX Nval*/  0                ,\
2471                             /*DOC*/       "Deprecated" ,\
2472                             /*Parameter*/ &do_extended_matrix          ,\
2473                             /*Def 1*/     "0"             ,\
2474                             /*Def 2*/     "1"             ,\
2475                             /*Min_value*/ "any"            ,\
2476                             /*Max Value*/ "any"             \
2477                    );
2478 get_cl_param(\
2479                             /*argc*/      argc             ,\
2480                             /*argv*/      argv             ,\
2481                             /*output*/    &le              ,\
2482                             /*Name*/      "-prot_min_sim"        ,\
2483                             /*Flag*/      &prot_min_sim        ,\
2484                             /*TYPE*/      "D"              ,\
2485                             /*OPTIONAL?*/ OPTIONAL         ,\
2486                             /*MAX Nval*/  1                ,\
2487                             /*DOC*/       "Minimum similarity between a sequence and its BLAST relatives" ,\
2488                             /*Parameter*/ &prot_min_sim          ,\
2489                             /*Def 1*/     "40"             ,\
2490                             /*Def 2*/     "20"             ,\
2491                             /*Min_value*/ "any"            ,\
2492                             /*Max Value*/ "any"             \
2493                    );
2494  set_int_variable ("prot_min_sim", prot_min_sim);
2495
2496 get_cl_param(\
2497                             /*argc*/      argc             ,\
2498                             /*argv*/      argv             ,\
2499                             /*output*/    &le              ,\
2500                             /*Name*/      "-prot_max_sim"        ,\
2501                             /*Flag*/      &prot_max_sim        ,\
2502                             /*TYPE*/      "D"              ,\
2503                             /*OPTIONAL?*/ OPTIONAL         ,\
2504                             /*MAX Nval*/  1                ,\
2505                             /*DOC*/       "Maximum similarity between a sequence and its BLAST relatives" ,\
2506                             /*Parameter*/ &prot_max_sim          ,\
2507                             /*Def 1*/     "90"             ,\
2508                             /*Def 2*/     "100"             ,\
2509                             /*Min_value*/ "any"            ,\
2510                             /*Max Value*/ "any"             \
2511                    );
2512  set_int_variable ("prot_max_sim", prot_max_sim);
2513
2514 get_cl_param(\
2515                             /*argc*/      argc             ,\
2516                             /*argv*/      argv             ,\
2517                             /*output*/    &le              ,\
2518                             /*Name*/      "-prot_min_cov"        ,\
2519                             /*Flag*/      &prot_min_cov        ,\
2520                             /*TYPE*/      "D"              ,\
2521                             /*OPTIONAL?*/ OPTIONAL         ,\
2522                             /*MAX Nval*/  1                ,\
2523                             /*DOC*/       "Minimum coverage of a sequence by its BLAST relatives" ,\
2524                             /*Parameter*/ &prot_min_cov          ,\
2525                             /*Def 1*/     "40"             ,\
2526                             /*Def 2*/     "0"             ,\
2527                             /*Min_value*/ "any"            ,\
2528                             /*Max Value*/ "any"             \
2529                    );
2530 set_int_variable ("prot_min_cov", prot_min_cov);
2531 declare_name(pdb_type);
2532 get_cl_param(\
2533                             /*argc*/      argc             ,\
2534                             /*argv*/      argv             ,\
2535                             /*output*/    &le              ,\
2536                             /*Name*/      "-pdb_type"        ,\
2537                             /*Flag*/      &pdb_min_sim        ,\
2538                             /*TYPE*/      "S"              ,\
2539                             /*OPTIONAL?*/ OPTIONAL         ,\
2540                             /*MAX Nval*/  1                ,\
2541                             /*DOC*/       "d: diffraction, n: nmr, m:model" ,\
2542                             /*Parameter*/ &pdb_type          ,\
2543                             /*Def 1*/     "d"             ,\
2544                             /*Def 2*/     "d"             ,\
2545                             /*Min_value*/ "any"            ,\
2546                             /*Max Value*/ "any"             \
2547                    );
2548 set_string_variable ("pdb_type", pdb_type);
2549 get_cl_param(\
2550                             /*argc*/      argc             ,\
2551                             /*argv*/      argv             ,\
2552                             /*output*/    &le              ,\
2553                             /*Name*/      "-pdb_min_sim"        ,\
2554                             /*Flag*/      &pdb_min_sim        ,\
2555                             /*TYPE*/      "D"              ,\
2556                             /*OPTIONAL?*/ OPTIONAL         ,\
2557                             /*MAX Nval*/  1                ,\
2558                             /*DOC*/       "Minimum similarity between a sequence and its PDB target" ,\
2559                             /*Parameter*/ &pdb_min_sim          ,\
2560                             /*Def 1*/     "35"             ,\
2561                             /*Def 2*/     "35"             ,\
2562                             /*Min_value*/ "any"            ,\
2563                             /*Max Value*/ "any"             \
2564                    );
2565
2566  set_int_variable ("pdb_min_sim", pdb_min_sim);
2567  get_cl_param(                                                  \
2568                             /*argc*/      argc             ,\
2569                             /*argv*/      argv             ,\
2570                             /*output*/    &le              ,\
2571                             /*Name*/      "-pdb_max_sim"        ,\
2572                             /*Flag*/      &pdb_max_sim        ,\
2573                             /*TYPE*/      "D"              ,\
2574                             /*OPTIONAL?*/ OPTIONAL         ,\
2575                             /*MAX Nval*/  1                ,\
2576                             /*DOC*/       "Maximum similarity between a sequence and its PDB target" ,\
2577                             /*Parameter*/ &pdb_max_sim          ,\
2578                             /*Def 1*/     "100"             ,\
2579                             /*Def 2*/     "0"             ,\
2580                             /*Min_value*/ "any"            ,\
2581                             /*Max Value*/ "any"             \
2582                    );
2583  set_int_variable ("pdb_max_sim", pdb_max_sim);
2584  get_cl_param(                                                  \
2585                             /*argc*/      argc             ,\
2586                             /*argv*/      argv             ,\
2587                             /*output*/    &le              ,\
2588                             /*Name*/      "-pdb_min_cov"        ,\
2589                             /*Flag*/      &pdb_min_cov        ,\
2590                             /*TYPE*/      "D"              ,\
2591                             /*OPTIONAL?*/ OPTIONAL         ,\
2592                             /*MAX Nval*/  1                ,\
2593                             /*DOC*/       "Minimum coverage of a sequence by its PDB target" ,\
2594                             /*Parameter*/ &pdb_min_cov          ,\
2595                             /*Def 1*/     "50"             ,\
2596                             /*Def 2*/     "25"             ,\
2597                             /*Min_value*/ "any"            ,\
2598                             /*Max Value*/ "any"             \
2599                    );
2600 set_int_variable ("pdb_min_cov", pdb_min_cov);
2601
2602
2603
2604 declare_name (pdb_blast_server);
2605  get_cl_param(\
2606                             /*argc*/      argc          ,\
2607                             /*argv*/      argv          ,\
2608                             /*output*/    &le           ,\
2609                             /*Name*/      "-pdb_blast_server"    ,\
2610                             /*Flag*/      &garbage      ,\
2611                             /*TYPE*/      "W_F"         ,\
2612                             /*OPTIONAL?*/ OPTIONAL      ,\
2613                             /*MAX Nval*/  1             ,\
2614                             /*DOC*/       "ND"          ,\
2615                             /*Parameter*/&pdb_blast_server       ,\
2616                             /*Def 1*/    "EBI"      ,\
2617                             /*Def 2*/    "default"      ,\
2618                             /*Min_value*/ "any"         ,\
2619                             /*Max Value*/ "any"          \
2620                    );
2621 declare_name (prot_blast_server);
2622  get_cl_param(\
2623                             /*argc*/      argc          ,\
2624                             /*argv*/      argv          ,\
2625                             /*output*/    &le           ,\
2626                             /*Name*/      "-blast"    ,\
2627                             /*Flag*/      &garbage      ,\
2628                             /*TYPE*/      "W_F"         ,\
2629                             /*OPTIONAL?*/ OPTIONAL      ,\
2630                             /*MAX Nval*/  1             ,\
2631                             /*DOC*/       "ND"          ,\
2632                             /*Parameter*/&prot_blast_server       ,\
2633                             /*Def 1*/    ""      ,\
2634                             /*Def 2*/    ""      ,\
2635                             /*Min_value*/ "any"         ,\
2636                             /*Max Value*/ "any"          \
2637                    );
2638  //make sure that -blast and -blast_server are both supported blast>blast_server
2639  if ( !prot_blast_server[0])
2640    {
2641      get_cl_param(                                              \
2642                             /*argc*/      argc          ,\
2643                             /*argv*/      argv          ,\
2644                             /*output*/    &le           ,\
2645                             /*Name*/      "-blast_server"    ,\
2646                             /*Flag*/      &garbage      ,\
2647                             /*TYPE*/      "W_F"         ,\
2648                             /*OPTIONAL?*/ OPTIONAL      ,\
2649                             /*MAX Nval*/  1             ,\
2650                             /*DOC*/       "ND"          ,\
2651                             /*Parameter*/&prot_blast_server       ,\
2652                             /*Def 1*/    "EBI"      ,\
2653                             /*Def 2*/    "default"      ,\
2654                             /*Min_value*/ "any"         ,\
2655                             /*Max Value*/ "any"          \
2656                    );
2657    }
2658  // HERE ("%s", blast_server);
2659  if ( strm (prot_blast_server, "env"))prot_blast_server=get_env_variable ("blast_server_4_TCOFFEE",IS_FATAL);
2660  set_string_variable ("blast_server", prot_blast_server);
2661
2662
2663
2664  declare_name (pdb_db);
2665  get_cl_param(\
2666                             /*argc*/      argc          ,\
2667                             /*argv*/      argv          ,\
2668                             /*output*/    &le           ,\
2669                             /*Name*/      "-pdb_db"    ,\
2670                             /*Flag*/      &garbage      ,\
2671                             /*TYPE*/      "W_F"         ,\
2672                             /*OPTIONAL?*/ OPTIONAL      ,\
2673                             /*MAX Nval*/  1             ,\
2674                             /*DOC*/       "Non Redundant PDB database"          ,\
2675                             /*Parameter*/&pdb_db       ,\
2676                             /*Def 1*/    "pdb"      ,\
2677                             /*Def 2*/    "default"      ,\
2678                             /*Min_value*/ "any"         ,\
2679                             /*Max Value*/ "any"          \
2680                    );
2681  if ( strm (pdb_db, "env"))pdb_db=get_env_variable ("pdb_db_4_TCOFFEE", IS_FATAL);
2682  set_string_variable ("pdb_db", pdb_db);
2683
2684
2685 declare_name (prot_db);
2686  get_cl_param(\
2687                             /*argc*/      argc          ,\
2688                             /*argv*/      argv          ,\
2689                             /*output*/    &le           ,\
2690                             /*Name*/      "-protein_db"    ,\
2691                             /*Flag*/      &garbage      ,\
2692                             /*TYPE*/      "W_F"         ,\
2693                             /*OPTIONAL?*/ OPTIONAL      ,\
2694                             /*MAX Nval*/  1             ,\
2695                             /*DOC*/       "ND"          ,\
2696                             /*Parameter*/&prot_db       ,\
2697                             /*Def 1*/    "uniprot"      ,\
2698                             /*Def 2*/    "default"      ,\
2699                             /*Min_value*/ "any"         ,\
2700                             /*Max Value*/ "any"          \
2701                    );
2702  if ( strm (prot_db, "env"))prot_db=get_env_variable ("protein_db_4_TCOFFEE", IS_FATAL);
2703  set_string_variable ("prot_db", prot_db);
2704
2705  declare_name (method_log);
2706  get_cl_param(                                                  \
2707                             /*argc*/      argc          ,\
2708                             /*argv*/      argv          ,\
2709                             /*output*/    &le           ,\
2710                             /*Name*/      "-method_log"    ,\
2711                             /*Flag*/      &garbage      ,\
2712                             /*TYPE*/      "W_F"         ,\
2713                             /*OPTIONAL?*/ OPTIONAL      ,\
2714                             /*MAX Nval*/  1             ,\
2715                             /*DOC*/       "ND"          ,\
2716                             /*Parameter*/&method_log       ,\
2717                             /*Def 1*/    "no"      ,\
2718                             /*Def 2*/    "default"      ,\
2719                             /*Min_value*/ "any"         ,\
2720                             /*Max Value*/ "any"          \
2721                    );
2722 /*PARAMETER PROTOTYPE:        IN */
2723         struc_to_use=declare_char ( 200, STRING);
2724         n_struc_to_use=get_cl_param(\
2725                             /*argc*/      argc          ,\
2726                             /*argv*/      argv          ,\
2727                             /*output*/    &le           ,\
2728                             /*Name*/      "-struc_to_use"         ,\
2729                             /*Flag*/      &garbage      ,\
2730                             /*TYPE*/      "S"           ,\
2731                             /*OPTIONAL?*/ OPTIONAL      ,\
2732                             /*MAX Nval*/  200           ,\
2733                             /*DOC*/       "Specifies the structures that must be used when combining sequences and structures. The default is to use all the structures."          ,\
2734                             /*Parameter*/ struc_to_use     ,\
2735                             /*Def 1*/    "",\
2736                             /*Def 2*/     "stdin"       ,\
2737                             /*Min_value*/ "any"         ,\
2738                             /*Max Value*/ "any"          \
2739                    );
2740
2741 declare_name (cache);
2742  get_cl_param(\
2743                             /*argc*/      argc          ,\
2744                             /*argv*/      argv          ,\
2745                             /*output*/    &le           ,\
2746                             /*Name*/      "-cache"    ,\
2747                             /*Flag*/      &garbage      ,\
2748                             /*TYPE*/      "W_F"         ,\
2749                             /*OPTIONAL?*/ OPTIONAL      ,\
2750                             /*MAX Nval*/  1             ,\
2751                             /*DOC*/       "Specifies that a cache must be used to save the structures and their comparison, as well as the blast searches.\navailable modes are: use,ignore,update,local, directory name"          ,\
2752                             /*Parameter*/ &cache       ,\
2753                             /*Def 1*/    "use"      ,\
2754                             /*Def 2*/    "update"      ,\
2755                             /*Min_value*/ "any"         ,\
2756                             /*Max Value*/ "any"          \
2757                    );
2758 declare_name (align_pdb_param_file);
2759  get_cl_param(\
2760                             /*argc*/      argc          ,\
2761                             /*argv*/      argv          ,\
2762                             /*output*/    &le           ,\
2763                             /*Name*/      "-align_pdb_param_file"    ,\
2764                             /*Flag*/      &garbage      ,\
2765                             /*TYPE*/      "W_F"         ,\
2766                             /*OPTIONAL?*/ OPTIONAL      ,\
2767                             /*MAX Nval*/  1             ,\
2768                             /*DOC*/       "parameter_file"          ,\
2769                             /*Parameter*/ &align_pdb_param_file       ,\
2770                             /*Def 1*/    "no"      ,\
2771                             /*Def 2*/    "no"      ,\
2772                             /*Min_value*/ "any"         ,\
2773                             /*Max Value*/ "any"          \
2774                    );
2775 declare_name (align_pdb_hasch_mode);
2776  get_cl_param(\
2777                             /*argc*/      argc          ,\
2778                             /*argv*/      argv          ,\
2779                             /*output*/    &le           ,\
2780                             /*Name*/      "-align_pdb_hasch_mode"    ,\
2781                             /*Flag*/      &garbage      ,\
2782                             /*TYPE*/      "W_F"         ,\
2783                             /*OPTIONAL?*/ OPTIONAL      ,\
2784                             /*MAX Nval*/  1             ,\
2785                             /*DOC*/       "parameter_file"          ,\
2786                             /*Parameter*/ &align_pdb_hasch_mode       ,\
2787                             /*Def 1*/    "hasch_ca_trace_bubble"      ,\
2788                             /*Def 2*/    "hasch_ca_trace_bubble"      ,\
2789                             /*Min_value*/ "any"         ,\
2790                             /*Max Value*/ "any"          \
2791                    );
2792 declare_name (use_seqan);
2793  get_cl_param(\
2794                             /*argc*/      argc          ,\
2795                             /*argv*/      argv          ,\
2796                             /*output*/    &le           ,\
2797                             /*Name*/      "-external_aligner"    ,\
2798                             /*Flag*/      &garbage      ,\
2799                             /*TYPE*/      "S"         ,\
2800                             /*OPTIONAL?*/ OPTIONAL      ,\
2801                             /*MAX Nval*/  1             ,\
2802                             /*DOC*/       "Use seqan to compute the MSA",\
2803                             /*Parameter*/ &use_seqan      ,\
2804                             /*Def 1*/    "NO"      ,\
2805                             /*Def 2*/    "seqan_tcoffee"      ,\
2806                             /*Min_value*/ "any"         ,\
2807                             /*Max Value*/ "any"          \
2808                    );
2809 declare_name (msa_mode);
2810  get_cl_param(\
2811                             /*argc*/      argc          ,\
2812                             /*argv*/      argv          ,\
2813                             /*output*/    &le           ,\
2814                             /*Name*/      "-msa_mode"    ,\
2815                             /*Flag*/      &garbage      ,\
2816                             /*TYPE*/      "S"         ,\
2817                             /*OPTIONAL?*/ OPTIONAL      ,\
2818                             /*MAX Nval*/  1             ,\
2819                             /*DOC*/       "Algorithm used to compute the MSA: tree | graph"          ,\
2820                             /*Parameter*/ &msa_mode      ,\
2821                             /*Def 1*/    "tree"      ,\
2822                             /*Def 2*/    "tree"      ,\
2823                             /*Min_value*/ "any"         ,\
2824                             /*Max Value*/ "any"          \
2825                    );
2826
2827 declare_name (master_mode);
2828 get_cl_param(\
2829                             /*argc*/      argc          ,\
2830                             /*argv*/      argv          ,\
2831                             /*output*/    &le           ,\
2832                             /*Name*/      "-master"    ,\
2833                             /*Flag*/      &garbage      ,\
2834                             /*TYPE*/      "S"         ,\
2835                             /*OPTIONAL?*/ OPTIONAL      ,\
2836                             /*MAX Nval*/  1             ,\
2837                             /*DOC*/       "Align all the sequences to the master sequences: file or number"          ,\
2838                             /*Parameter*/ &master_mode      ,\
2839                             /*Def 1*/    "no"      ,\
2840                             /*Def 2*/    "_LONG_N_10"      ,\
2841                             /*Min_value*/ "any"         ,\
2842                             /*Max Value*/ "any"          \
2843                    );
2844  get_cl_param(                                                  \
2845                             /*argc*/      argc          ,\
2846                             /*argv*/      argv          ,\
2847                             /*output*/    &le           ,\
2848                             /*Name*/      "-blast_nseq"    ,\
2849                             /*Flag*/      &garbage      ,\
2850                             /*TYPE*/      "D"         ,\
2851                             /*OPTIONAL?*/ OPTIONAL      ,\
2852                             /*MAX Nval*/  1             ,\
2853                             /*DOC*/       "Maximum number of querries for BLAST (0: all)"          ,\
2854                             /*Parameter*/ &blast_maxnseq      ,\
2855                             /*Def 1*/    "0"      ,\
2856                             /*Def 2*/    "0"      ,\
2857                             /*Min_value*/ "0"         ,\
2858                             /*Max Value*/ "any"          \
2859                    );
2860  get_cl_param(\
2861                             /*argc*/      argc          ,\
2862                             /*argv*/      argv          ,\
2863                             /*output*/    &le           ,\
2864                             /*Name*/      "-lalign_n_top"    ,\
2865                             /*Flag*/      &garbage      ,\
2866                             /*TYPE*/      "D"         ,\
2867                             /*OPTIONAL?*/ OPTIONAL      ,\
2868                             /*MAX Nval*/  1             ,\
2869                             /*DOC*/       "Number of local alignments reported by the local method (lalign) when building the library"          ,\
2870                             /*Parameter*/ &lalign_n_top      ,\
2871                             /*Def 1*/    "10"      ,\
2872                             /*Def 2*/    "10"      ,\
2873                             /*Min_value*/ "any"         ,\
2874                             /*Max Value*/ "any"          \
2875                    );
2876 get_cl_param(\
2877                             /*argc*/      argc          ,\
2878                             /*argv*/      argv          ,\
2879                             /*output*/    &le           ,\
2880                             /*Name*/      "-iterate"    ,\
2881                             /*Flag*/      &garbage      ,\
2882                             /*TYPE*/      "D"         ,\
2883                             /*OPTIONAL?*/ OPTIONAL      ,\
2884                             /*MAX Nval*/  1             ,\
2885                             /*DOC*/       "NUmber of iteration on the progressive alignment [0: no iteration, -1: Nseq iterations]",\
2886                             /*Parameter*/ &iterate      ,\
2887                             /*Def 1*/    "0"      ,\
2888                             /*Def 2*/    "100"      ,\
2889                             /*Min_value*/ "any"         ,\
2890                             /*Max Value*/ "any"          \
2891                    );
2892
2893 get_cl_param(\
2894                             /*argc*/      argc          ,\
2895                             /*argv*/      argv          ,\
2896                             /*output*/    &le           ,\
2897                             /*Name*/      "-trim"    ,\
2898                             /*Flag*/      &garbage      ,\
2899                             /*TYPE*/      "D"         ,\
2900                             /*OPTIONAL?*/ OPTIONAL      ,\
2901                             /*MAX Nval*/  1             ,\
2902                             /*DOC*/       "trim dataset",\
2903                             /*Parameter*/ &trim      ,\
2904                             /*Def 1*/    "0"      ,\
2905                             /*Def 2*/    "1"      ,\
2906                             /*Min_value*/ "any"         ,\
2907                             /*Max Value*/ "any"          \
2908                    );
2909 get_cl_param(\
2910                             /*argc*/      argc          ,\
2911                             /*argv*/      argv          ,\
2912                             /*output*/    &le           ,\
2913                             /*Name*/      "-split"    ,\
2914                             /*Flag*/      &garbage      ,\
2915                             /*TYPE*/      "D"         ,\
2916                             /*OPTIONAL?*/ OPTIONAL      ,\
2917                             /*MAX Nval*/  1             ,\
2918                             /*DOC*/       "split dataset",\
2919                             /*Parameter*/ &split      ,\
2920                             /*Def 1*/    "0"      ,\
2921                             /*Def 2*/    "1"      ,\
2922                             /*Min_value*/ "any"         ,\
2923                             /*Max Value*/ "any"          \
2924                    );
2925 declare_name(trimfile);
2926 get_cl_param(\
2927                             /*argc*/      argc          ,\
2928                             /*argv*/      argv          ,\
2929                             /*output*/    &le           ,\
2930                             /*Name*/      "-trimfile"    ,\
2931                             /*Flag*/      &garbage      ,\
2932                             /*TYPE*/      "S"         ,\
2933                             /*OPTIONAL?*/ OPTIONAL      ,\
2934                             /*MAX Nval*/  1             ,\
2935                             /*DOC*/       "trim dataset filename",\
2936                             /*Parameter*/ &trimfile      ,\
2937                             /*Def 1*/    "default"      ,\
2938                             /*Def 2*/    ""      ,\
2939                             /*Min_value*/ "any"         ,\
2940                             /*Max Value*/ "any"          \
2941                    );
2942 get_cl_param(\
2943                             /*argc*/      argc          ,\
2944                             /*argv*/      argv          ,\
2945                             /*output*/    &le           ,\
2946                             /*Name*/      "-split"    ,\
2947                             /*Flag*/      &garbage      ,\
2948                             /*TYPE*/      "D"         ,\
2949                             /*OPTIONAL?*/ OPTIONAL      ,\
2950                             /*MAX Nval*/  1             ,\
2951                             /*DOC*/       "split dataset",\
2952                             /*Parameter*/ &split      ,\
2953                             /*Def 1*/    "0"      ,\
2954                             /*Def 2*/    "1"      ,\
2955                             /*Min_value*/ "any"         ,\
2956                             /*Max Value*/ "any"          \
2957                    );
2958
2959 if (trim && !split)split=trim;
2960
2961 get_cl_param(\
2962                             /*argc*/      argc          ,\
2963                             /*argv*/      argv          ,\
2964                             /*output*/    &le           ,\
2965                             /*Name*/      "-split_nseq_thres"    ,\
2966                             /*Flag*/      &garbage      ,\
2967                             /*TYPE*/      "D"         ,\
2968                             /*OPTIONAL?*/ OPTIONAL      ,\
2969                             /*MAX Nval*/  1             ,\
2970                             /*DOC*/       "Maximum Number of sequences within a subgroup",\
2971                             /*Parameter*/ &split_nseq_thres      ,\
2972                             /*Def 1*/    "0"      ,\
2973                             /*Def 2*/    "1"      ,\
2974                             /*Min_value*/ "any"         ,\
2975                             /*Max Value*/ "any"          \
2976                    );
2977 get_cl_param(\
2978                             /*argc*/      argc          ,\
2979                             /*argv*/      argv          ,\
2980                             /*output*/    &le           ,\
2981                             /*Name*/      "-split_score_thres"    ,\
2982                             /*Flag*/      &garbage      ,\
2983                             /*TYPE*/      "D"         ,\
2984                             /*OPTIONAL?*/ OPTIONAL      ,\
2985                             /*MAX Nval*/  1             ,\
2986                             /*DOC*/       "Minimum score within a split dataset",\
2987                             /*Parameter*/ &split_score_thres      ,\
2988                             /*Def 1*/    "0"      ,\
2989                             /*Def 2*/    "1"      ,\
2990                             /*Min_value*/ "any"         ,\
2991                             /*Max Value*/ "any"          \
2992                    );
2993 get_cl_param(\
2994                             /*argc*/      argc          ,\
2995                             /*argv*/      argv          ,\
2996                             /*output*/    &le           ,\
2997                             /*Name*/      "-check_pdb_status"    ,\
2998                             /*Flag*/      &garbage      ,\
2999                             /*TYPE*/      "D"         ,\
3000                             /*OPTIONAL?*/ OPTIONAL      ,\
3001                             /*MAX Nval*/  1             ,\
3002                             /*DOC*/       "Reports the existance of a PDB file",\
3003                             /*Parameter*/ &check_pdb_status      ,\
3004                             /*Def 1*/    "0"      ,\
3005                             /*Def 2*/    "1"      ,\
3006                             /*Min_value*/ "any"         ,\
3007                             /*Max Value*/ "any"          \
3008                    );
3009 get_cl_param(\
3010                             /*argc*/      argc          ,\
3011                             /*argv*/      argv          ,\
3012                             /*output*/    &le           ,\
3013                             /*Name*/      "-clean_seq_name"    ,\
3014                             /*Flag*/      &garbage      ,\
3015                             /*TYPE*/      "D"         ,\
3016                             /*OPTIONAL?*/ OPTIONAL      ,\
3017                             /*MAX Nval*/  1             ,\
3018                             /*DOC*/       "Remove Special Char from sequence names",\
3019                             /*Parameter*/ &clean_seq_name      ,\
3020                             /*Def 1*/    "0"      ,\
3021                             /*Def 2*/    "1"      ,\
3022                             /*Min_value*/ "any"         ,\
3023                             /*Max Value*/ "any"          \
3024                    );
3025
3026
3027 /*PARAMETER PROTOTYPE:    SEQ TO ALIGN     */
3028                seq_to_keep=declare_char ( 2000, STRING);
3029                n_seq_to_keep=get_cl_param(\
3030                             /*argc*/      argc           ,\
3031                             /*argv*/      argv           ,\
3032                             /*output*/    &le            ,\
3033                             /*Name*/      "-seq_to_keep",\
3034                             /*Flag*/      &garbage       ,\
3035                             /*TYPE*/      "S"          ,\
3036                             /*OPTIONAL?*/ OPTIONAL       ,\
3037                             /*MAX Nval*/  200              ,\
3038                             /*DOC*/       "File containing the name of the sequences to keep when triming OR a list of names)",\
3039                             /*Parameter*/ seq_to_keep   ,\
3040                             /*Def 1*/    "NULL"          ,\
3041                             /*Def 2*/    ""              ,\
3042                             /*Min_value*/ "any"          ,\
3043                             /*Max Value*/ "any"           \
3044                    );
3045 /*******************************************************************************************************/
3046 /*                                                                                                     */
3047 /*                           TCoffee_dpa Parameter:START                                               */
3048 /*                                                                                                     */
3049 /*******************************************************************************************************/
3050 /*PARAMETER PROTOTYPE:    dpa_master_aln     */
3051                declare_name (dpa_master_aln);
3052                get_cl_param(\
3053                             /*argc*/      argc           ,\
3054                             /*argv*/      argv           ,\
3055                             /*output*/    &le            ,\
3056                             /*Name*/      "-dpa_master_aln",\
3057                             /*Flag*/      &garbage       ,\
3058                             /*TYPE*/      "S"          ,\
3059                             /*OPTIONAL?*/ OPTIONAL       ,\
3060                             /*MAX Nval*/  1              ,\
3061                             /*DOC*/       "Approximate Alignment: File|method",\
3062                             /*Parameter*/ &dpa_master_aln   ,\
3063                             /*Def 1*/    ""       ,\
3064                             /*Def 2*/    ""              ,\
3065                             /*Min_value*/ "any"          ,\
3066                             /*Max Value*/ "any"           \
3067                    );
3068                /*PARAMETER PROTOTYPE:    dpa_maxnseq    */
3069
3070                get_cl_param(\
3071                             /*argc*/      argc           ,\
3072                             /*argv*/      argv           ,\
3073                             /*output*/    &le            ,\
3074                             /*Name*/      "-dpa_maxnseq",\
3075                             /*Flag*/      &garbage       ,\
3076                             /*TYPE*/      "D"          ,\
3077                             /*OPTIONAL?*/ OPTIONAL       ,\
3078                             /*MAX Nval*/  1              ,\
3079                             /*DOC*/       "Maximum number of sequences to be aligned with DPA",\
3080                             /*Parameter*/ &dpa_maxnseq   ,\
3081                             /*Def 1*/    "0"       ,\
3082                             /*Def 2*/    "50"              ,\
3083                             /*Min_value*/ "any"          ,\
3084                             /*Max Value*/ "any"           \
3085                    );
3086 /*PARAMETER PROTOTYPE:    dpa_min_score1    */
3087
3088                get_cl_param(\
3089                             /*argc*/      argc           ,\
3090                             /*argv*/      argv           ,\
3091                             /*output*/    &le            ,\
3092                             /*Name*/      "-dpa_min_score1",\
3093                             /*Flag*/      &garbage       ,\
3094                             /*TYPE*/      "D"          ,\
3095                             /*OPTIONAL?*/ OPTIONAL       ,\
3096                             /*MAX Nval*/  200              ,\
3097                             /*DOC*/       "Minimum percent ID to merge sequences in the approximate alignment",\
3098                             /*Parameter*/ &dpa_min_score1   ,\
3099                             /*Def 1*/    ""       ,\
3100                             /*Def 2*/    ""              ,\
3101                             /*Min_value*/ "0"          ,\
3102                             /*Max Value*/ "100"           \
3103                    );
3104 /*PARAMETER PROTOTYPE:    dpa_min_score2    */
3105
3106                get_cl_param(\
3107                             /*argc*/      argc           ,\
3108                             /*argv*/      argv           ,\
3109                             /*output*/    &le            ,\
3110                             /*Name*/      "-dpa_min_score2",\
3111                             /*Flag*/      &garbage       ,\
3112                             /*TYPE*/      "D"          ,\
3113                             /*OPTIONAL?*/ OPTIONAL       ,\
3114                             /*MAX Nval*/  200              ,\
3115                             /*DOC*/       "Threshold for aligning a group in the slow double progressive alignment (automatically readjusted)",\
3116                             /*Parameter*/ &dpa_min_score2   ,\
3117                             /*Def 1*/    ""       ,\
3118                             /*Def 2*/    ""              ,\
3119                             /*Min_value*/ "0"          ,\
3120                             /*Max Value*/ "100"           \
3121                    );
3122 /*PARAMETER PROTOTYPE:    dpa_keep_tmp_file     */
3123                get_cl_param(\
3124                             /*argc*/      argc             ,\
3125                             /*argv*/      argv             ,\
3126                             /*output*/    &le              ,\
3127                             /*Name*/      "-dpa_keep_tmpfile"        ,\
3128                             /*Flag*/      &dpa_keep_tmpfile        ,\
3129                             /*TYPE*/      "FL"              ,\
3130                             /*OPTIONAL?*/ OPTIONAL         ,\
3131                             /*MAX Nval*/  1                ,\
3132                             /*DOC*/       "Prevents deletion of the tmpfile generated by t_coffee_dpa",\
3133                             /*Parameter*/ &do_version          ,\
3134                             /*Def 1*/     "0"             ,\
3135                             /*Def 2*/     "1"             ,\
3136                             /*Min_value*/ "0"            ,\
3137                             /*Max Value*/ "1"             \
3138
3139                             );
3140 /*PARAMETER PROTOTYPE:    dpa_debug     */
3141                get_cl_param(\
3142                             /*argc*/      argc             ,\
3143                             /*argv*/      argv             ,\
3144                             /*output*/    &le              ,\
3145                             /*Name*/      "-dpa_debug"        ,\
3146                             /*Flag*/      &dpa_debug        ,\
3147                             /*TYPE*/      "D"              ,\
3148                             /*OPTIONAL?*/ OPTIONAL         ,\
3149                             /*MAX Nval*/  1                ,\
3150                             /*DOC*/       "DEbug mode for DPA ( causes dpa tmp files to be kept)",\
3151                             /*Parameter*/ &do_version          ,\
3152                             /*Def 1*/     "0"             ,\
3153                             /*Def 2*/     "1"             ,\
3154                             /*Min_value*/ "0"            ,\
3155                             /*Max Value*/ "1"             \
3156
3157                             );
3158
3159 /*PARAMETER PROTOTYPE:    multi_core    */
3160                declare_name (multi_core);
3161                get_cl_param(\
3162                             /*argc*/      argc           ,\
3163                             /*argv*/      argv           ,\
3164                             /*output*/    &le            ,\
3165                             /*Name*/      "-multi_core",\
3166                             /*Flag*/      &garbage       ,\
3167                             /*TYPE*/      "S"          ,\
3168                             /*OPTIONAL?*/ OPTIONAL       ,\
3169                             /*MAX Nval*/  1              ,\
3170                             /*DOC*/       "Multi core: template_jobs_relax_[msa|pairwise]_evaluate",\
3171                             /*Parameter*/ &multi_core   ,\
3172                             /*Def 1*/    "templates_jobs_relax_msa_evaluate"       ,\
3173                             /*Def 2*/    "templates_jobs_relax_msa_evaluate"              ,\
3174                             /*Min_value*/ "0"          ,\
3175                             /*Max Value*/ "100"           \
3176                    );
3177                if (multi_core[0])set_string_variable ("multi_core",multi_core);
3178 /*PARAMETER PROTOTYPE:    multi_core    */
3179                get_cl_param(                                    \
3180                             /*argc*/      argc           ,\
3181                             /*argv*/      argv           ,\
3182                             /*output*/    &le            ,\
3183                             /*Name*/      "-n_core",\
3184                             /*Flag*/      &garbage       ,\
3185                             /*TYPE*/      "D"          ,\
3186                             /*OPTIONAL?*/ OPTIONAL       ,\
3187                             /*MAX Nval*/  1              ,\
3188                             /*DOC*/       "Number of cores to be used by machine [default=0 => all those defined in the environement]",\
3189                             /*Parameter*/ &n_core   ,\
3190                             /*Def 1*/    "0"       ,\
3191                             /*Def 2*/    "0"              ,\
3192                             /*Min_value*/ "0"          ,\
3193                             /*Max Value*/ "100"           \
3194                    );
3195                if (n_core)set_int_variable ("n_core",n_core);
3196
3197
3198 /*PARAMETER PROTOTYPE:    lib_list    */
3199                declare_name (lib_list);
3200                get_cl_param(\
3201                             /*argc*/      argc           ,\
3202                             /*argv*/      argv           ,\
3203                             /*output*/    &le            ,\
3204                             /*Name*/      "-lib_list",\
3205                             /*Flag*/      &garbage       ,\
3206                             /*TYPE*/      "S"          ,\
3207                             /*OPTIONAL?*/ OPTIONAL       ,\
3208                             /*MAX Nval*/  1              ,\
3209                             /*DOC*/       "A File that contains every pair/group of sequence to process when computing the lib, Format:<nseq> <index1><index2>",\
3210                             /*Parameter*/ &lib_list   ,\
3211                             /*Def 1*/    ""       ,\
3212                             /*Def 2*/    "default"              ,\
3213                             /*Min_value*/ "0"          ,\
3214                             /*Max Value*/ "100"           \
3215                    );
3216
3217                /*PARAMETER PROTOTYPE:    lib_list    */
3218                declare_name (prune_lib_mode);
3219                get_cl_param(\
3220                             /*argc*/      argc           ,\
3221                             /*argv*/      argv           ,\
3222                             /*output*/    &le            ,\
3223                             /*Name*/      "-prune_lib_mode",\
3224                             /*Flag*/      &garbage       ,\
3225                             /*TYPE*/      "S"          ,\
3226                             /*OPTIONAL?*/ OPTIONAL       ,\
3227                             /*MAX Nval*/  1              ,\
3228                             /*DOC*/       "A File that contains every pair/group of sequence to process when computing the lib, Format:<nseq> <index1><index2>",\
3229                             /*Parameter*/ &prune_lib_mode   ,\
3230                             /*Def 1*/    "5"       ,\
3231                             /*Def 2*/    "5"              ,\
3232                             /*Min_value*/ "0"          ,\
3233                             /*Max Value*/ "100"           \
3234                    );
3235                set_string_variable ("prune_lib_mode",prune_lib_mode);
3236
3237                /*PARAMETER PROTOTYPE:    multi_thread    */
3238                declare_name (tip);
3239                get_cl_param(\
3240                             /*argc*/      argc           ,\
3241                             /*argv*/      argv           ,\
3242                             /*output*/    &le            ,\
3243                             /*Name*/      "-tip",\
3244                             /*Flag*/      &garbage       ,\
3245                             /*TYPE*/      "S"          ,\
3246                             /*OPTIONAL?*/ OPTIONAL       ,\
3247                             /*MAX Nval*/  1              ,\
3248                             /*DOC*/       "Controls The Output of A TIP When Computation is over [one,all,none]",\
3249                             /*Parameter*/ &tip   ,\
3250                             /*Def 1*/    "none"       ,\
3251                             /*Def 2*/    "all"              ,\
3252                             /*Min_value*/ "any"          ,\
3253                             /*Max Value*/ "any"           \
3254                    );
3255                /*PARAMETER PROTOTYPE:    RNA LIB    */
3256                declare_name (rna_lib);
3257                get_cl_param(\
3258                             /*argc*/      argc           ,\
3259                             /*argv*/      argv           ,\
3260                             /*output*/    &le            ,\
3261                             /*Name*/      "-rna_lib",\
3262                             /*Flag*/      &garbage       ,\
3263                             /*TYPE*/      "S"          ,\
3264                             /*OPTIONAL?*/ OPTIONAL       ,\
3265                             /*MAX Nval*/  1              ,\
3266                             /*DOC*/       "",\
3267                             /*Parameter*/ &rna_lib   ,\
3268                             /*Def 1*/    ""       ,\
3269                             /*Def 2*/    ""              ,\
3270                             /*Min_value*/ "any"          ,\
3271                             /*Max Value*/ "any"           \
3272                    );
3273                get_cl_param(                                    \
3274                             /*argc*/      argc           ,\
3275                             /*argv*/      argv           ,\
3276                             /*output*/    &le            ,\
3277                             /*Name*/      "-no_warning",\
3278                             /*Flag*/      &garbage       ,\
3279                             /*TYPE*/      "D"          ,\
3280                             /*OPTIONAL?*/ OPTIONAL       ,\
3281                             /*MAX Nval*/  1              ,\
3282                             /*DOC*/       "Suppresses all Warnings",\
3283                             /*Parameter*/ &no_warning   ,\
3284                             /*Def 1*/    "0"       ,\
3285                             /*Def 2*/    "1"              ,\
3286                             /*Min_value*/ "0"          ,\
3287                             /*Max Value*/ "1"           \
3288                    );
3289                get_cl_param(                                    \
3290                             /*argc*/      argc           ,\
3291                             /*argv*/      argv           ,      \
3292                             /*output*/    &le            ,\
3293                             /*Name*/      "-run_local_script",\
3294                             /*Flag*/      &garbage       ,      \
3295                             /*TYPE*/      "D"          ,        \
3296                             /*OPTIONAL?*/ OPTIONAL       ,      \
3297                             /*MAX Nval*/  1              ,              \
3298                             /*DOC*/       "Run Local Script if in current directory",   \
3299                             /*Parameter*/ &run_local_script   ,         \
3300                             /*Def 1*/    "0"       ,                    \
3301                             /*Def 2*/    "1"              ,             \
3302                             /*Min_value*/ "0"          ,                \
3303                             /*Max Value*/ "1"                           \
3304                    );
3305                set_int_variable ("run_local_script", run_local_script);
3306                declare_name (plugins);
3307                get_cl_param(                                    \
3308                             /*argc*/      argc           ,\
3309                             /*argv*/      argv           ,      \
3310                             /*output*/    &le            ,\
3311                             /*Name*/      "-plugins",\
3312                             /*Flag*/      &garbage       ,      \
3313                             /*TYPE*/      "S"          ,        \
3314                             /*OPTIONAL?*/ OPTIONAL       ,      \
3315                             /*MAX Nval*/  1              ,              \
3316                             /*DOC*/       "Set the directory containing the plugins [no if no plugin]", \
3317                             /*Parameter*/ &plugins   ,          \
3318                             /*Def 1*/    "default"       ,                      \
3319                             /*Def 2*/    ""              ,              \
3320                             /*Min_value*/ "any"          ,              \
3321                             /*Max Value*/ "any"                         \
3322                    );
3323
3324
3325
3326                declare_name (proxy);
3327                get_cl_param(\
3328                             /*argc*/      argc           ,\
3329                             /*argv*/      argv           ,\
3330                             /*output*/    &le            ,\
3331                             /*Name*/      "-proxy",\
3332                             /*Flag*/      &garbage       ,\
3333                             /*TYPE*/      "S"          ,\
3334                             /*OPTIONAL?*/ OPTIONAL       ,\
3335                             /*MAX Nval*/  1              ,\
3336                             /*DOC*/       "proxy used to access to webservices, when required",\
3337                             /*Parameter*/ &proxy   ,\
3338                             /*Def 1*/    "unset"       ,\
3339                             /*Def 2*/    " "              ,\
3340                             /*Min_value*/ "any"          ,\
3341                             /*Max Value*/ "any"           \
3342                    );
3343                if ( !strm (proxy, "unset"))set_string_variable ("cl_proxy",proxy);
3344                declare_name (email);
3345                get_cl_param(\
3346                             /*argc*/      argc           ,\
3347                             /*argv*/      argv           ,\
3348                             /*output*/    &le            ,\
3349                             /*Name*/      "-email",\
3350                             /*Flag*/      &garbage       ,\
3351                             /*TYPE*/      "S"          ,\
3352                             /*OPTIONAL?*/ OPTIONAL       ,\
3353                             /*MAX Nval*/  1              ,\
3354                             /*DOC*/       "email provided to webservices, when required",\
3355                             /*Parameter*/ &email   ,\
3356                             /*Def 1*/    ""       ,\
3357                             /*Def 2*/    ""              ,\
3358                             /*Min_value*/ "any"          ,\
3359                             /*Max Value*/ "any"           \
3360                    );
3361                if ( strstr (email, "@"))
3362                  {
3363                    set_string_variable ("email", email);
3364                    set_string_variable ("cl_email", email);
3365                  }
3366
3367                get_cl_param(                                    \
3368                             /*argc*/      argc           ,\
3369                             /*argv*/      argv           ,\
3370                             /*output*/    &le            ,\
3371                             /*Name*/      "-clean_overaln",\
3372                             /*Flag*/      &garbage       ,\
3373                             /*TYPE*/      "D"          ,\
3374                             /*OPTIONAL?*/ OPTIONAL       ,\
3375                             /*MAX Nval*/  1              ,\
3376                             /*DOC*/       "Ratio between overaligned exon id Vs legitimates *100",\
3377                             /*Parameter*/ &clean_overaln   ,\
3378                             /*Def 1*/    "0"          ,\
3379                             /*Def 2*/    "1"              ,\
3380                             /*Min_value*/ "any"          ,\
3381                             /*Max Value*/ "any"           \
3382                                           );
3383                overaln_param=declare_char ( 10, STRING);
3384                n_overaln_param=get_cl_param(                    \
3385                             /*argc*/      argc           ,\
3386                             /*argv*/      argv           ,\
3387                             /*output*/    &le            ,\
3388                             /*Name*/      "-overaln_param",\
3389                             /*Flag*/      &garbage       ,\
3390                             /*TYPE*/      "S"          ,\
3391                             /*OPTIONAL?*/ OPTIONAL       ,\
3392                             /*MAX Nval*/  10              ,\
3393                             /*DOC*/       "Parameters for the overaln",\
3394                             /*Parameter*/ overaln_param   ,\
3395                             /*Def 1*/    "NULL"          ,\
3396                             /*Def 2*/    ""              ,\
3397                             /*Min_value*/ "any"          ,\
3398                             /*Max Value*/ "any"           \
3399                    );
3400                declare_name (overaln_mode);
3401                get_cl_param(\
3402                             /*argc*/      argc           ,\
3403                             /*argv*/      argv           ,\
3404                             /*output*/    &le            ,\
3405                             /*Name*/      "-overaln_mode",\
3406                             /*Flag*/      &garbage       ,\
3407                             /*TYPE*/      "S"          ,\
3408                             /*OPTIONAL?*/ OPTIONAL       ,\
3409                             /*MAX Nval*/  1              ,\
3410                             /*DOC*/       "lower || uanlaign",\
3411                             /*Parameter*/ &overaln_mode   ,\
3412                             /*Def 1*/    ""       ,\
3413                             /*Def 2*/    ""              ,\
3414                             /*Min_value*/ "any"          ,\
3415                             /*Max Value*/ "any"           \
3416                    );
3417                if (overaln_mode[0])set_string_variable ("overaln_mode", overaln_mode);
3418                declare_name (overaln_model);
3419                get_cl_param(\
3420                             /*argc*/      argc           ,\
3421                             /*argv*/      argv           ,\
3422                             /*output*/    &le            ,\
3423                             /*Name*/      "-overaln_model",\
3424                             /*Flag*/      &garbage       ,\
3425                             /*TYPE*/      "S"          ,\
3426                             /*OPTIONAL?*/ OPTIONAL       ,\
3427                             /*MAX Nval*/  1              ,\
3428                             /*DOC*/       "fsa1 (no exon boundaries), fsa2 (exon boundaries)",\
3429                             /*Parameter*/ &overaln_model   ,\
3430                             /*Def 1*/    ""       ,\
3431                             /*Def 2*/    ""              ,\
3432                             /*Min_value*/ "any"          ,\
3433                             /*Max Value*/ "any"           \
3434                    );
3435                if (overaln_mode[0])set_string_variable ("overaln_model", overaln_model);
3436
3437                get_cl_param(                                    \
3438                             /*argc*/      argc           ,\
3439                             /*argv*/      argv           ,\
3440                             /*output*/    &le            ,\
3441                             /*Name*/      "-overaln_threshold",\
3442                             /*Flag*/      &garbage       ,\
3443                             /*TYPE*/      "D"          ,\
3444                             /*OPTIONAL?*/ OPTIONAL       ,\
3445                             /*MAX Nval*/  1              ,\
3446                             /*DOC*/       "Ratio between overaligned exon id Vs legitimates *100",\
3447                             /*Parameter*/ &overaln_threshold   ,\
3448                             /*Def 1*/    "0"          ,\
3449                             /*Def 2*/    ""              ,\
3450                             /*Min_value*/ "any"          ,\
3451                             /*Max Value*/ "any"           \
3452                             );
3453                set_int_variable ("overaln_threshold", overaln_threshold);
3454
3455                get_cl_param(                                    \
3456                             /*argc*/      argc           ,\
3457                             /*argv*/      argv           ,\
3458                             /*output*/    &le            ,\
3459                             /*Name*/      "-overaln_target",\
3460                             /*Flag*/      &garbage       ,\
3461                             /*TYPE*/      "D"          ,\
3462                             /*OPTIONAL?*/ OPTIONAL       ,\
3463                             /*MAX Nval*/  1              ,\
3464                             /*DOC*/       "Ratio between overaligned exon id Vs legitimates *100",\
3465                             /*Parameter*/ &overaln_target   ,\
3466                             /*Def 1*/    "0"          ,\
3467                             /*Def 2*/    ""              ,\
3468                             /*Min_value*/ "any"          ,\
3469                             /*Max Value*/ "any"           \
3470                    );
3471                set_int_variable ("overaln_target", overaln_threshold);
3472
3473                get_cl_param(                                    \
3474                             /*argc*/      argc           ,\
3475                             /*argv*/      argv           ,\
3476                             /*output*/    &le            ,\
3477                             /*Name*/      "-overaln_P1",\
3478                             /*Flag*/      &garbage       ,\
3479                             /*TYPE*/      "D"          ,\
3480                             /*OPTIONAL?*/ OPTIONAL       ,\
3481                             /*MAX Nval*/  1              ,\
3482                             /*DOC*/       "Ratio between overaligned exon id Vs legitimates *100",\
3483                             /*Parameter*/ &overaln_P1   ,\
3484                             /*Def 1*/    "0"          ,\
3485                             /*Def 2*/    ""              ,\
3486                             /*Min_value*/ "any"          ,\
3487                             /*Max Value*/ "any"           \
3488                    );
3489                if (overaln_P1)set_int_variable ("overaln_P1", overaln_P1);
3490
3491                get_cl_param(                                    \
3492                             /*argc*/      argc           ,\
3493                             /*argv*/      argv           ,\
3494                             /*output*/    &le            ,\
3495                             /*Name*/      "-overaln_P2",\
3496                             /*Flag*/      &garbage       ,\
3497                             /*TYPE*/      "D"          ,\
3498                             /*OPTIONAL?*/ OPTIONAL       ,\
3499                             /*MAX Nval*/  1              ,\
3500                             /*DOC*/       "Ratio between overaligned exon id Vs legitimates *100",\
3501                             /*Parameter*/ &overaln_P2   ,\
3502                             /*Def 1*/    "0"          ,\
3503                             /*Def 2*/    ""              ,\
3504                             /*Min_value*/ "any"          ,\
3505                             /*Max Value*/ "any"           \
3506                    );
3507                 if (overaln_P2)set_int_variable ("overaln_P2", overaln_P2);
3508
3509                 get_cl_param(                                   \
3510                             /*argc*/      argc           ,\
3511                             /*argv*/      argv           ,\
3512                             /*output*/    &le            ,\
3513                             /*Name*/      "-overaln_P3",\
3514                             /*Flag*/      &garbage       ,\
3515                             /*TYPE*/      "D"          ,\
3516                             /*OPTIONAL?*/ OPTIONAL       ,\
3517                             /*MAX Nval*/  1              ,\
3518                             /*DOC*/       "Ratio between overaligned exon id Vs legitimates *100",\
3519                             /*Parameter*/ &overaln_P3   ,\
3520                             /*Def 1*/    "0"          ,\
3521                             /*Def 2*/    ""              ,\
3522                             /*Min_value*/ "any"          ,\
3523                             /*Max Value*/ "any"           \
3524                    );
3525                if (overaln_P3)set_int_variable ("overaln_P3", overaln_P3);
3526
3527                get_cl_param(                                    \
3528                             /*argc*/      argc           ,\
3529                             /*argv*/      argv           ,\
3530                             /*output*/    &le            ,\
3531                             /*Name*/      "-overaln_P4",\
3532                             /*Flag*/      &garbage       ,\
3533                             /*TYPE*/      "D"          ,\
3534                             /*OPTIONAL?*/ OPTIONAL       ,\
3535                             /*MAX Nval*/  1              ,\
3536                             /*DOC*/       "Ratio between overaligned exon id Vs legitimates *100",\
3537                             /*Parameter*/ &overaln_P4   ,\
3538                             /*Def 1*/    "0"          ,\
3539                             /*Def 2*/    ""              ,\
3540                             /*Min_value*/ "any"          ,\
3541                             /*Max Value*/ "any"           \
3542                    );
3543                if (overaln_P4)set_int_variable ("overaln_P4", overaln_P4);
3544
3545
3546                declare_name (exon_boundaries);
3547                get_cl_param(\
3548                             /*argc*/      argc           ,\
3549                             /*argv*/      argv           ,\
3550                             /*output*/    &le            ,\
3551                             /*Name*/      "-exon_boundaries",\
3552                             /*Flag*/      &garbage       ,\
3553                             /*TYPE*/      "S"          ,\
3554                             /*OPTIONAL?*/ OPTIONAL       ,\
3555                             /*MAX Nval*/  1              ,\
3556                             /*DOC*/       "exon_boundaries [EBI boj format]",\
3557                             /*Parameter*/ &exon_boundaries   ,\
3558                             /*Def 1*/    ""       ,\
3559                             /*Def 2*/    ""              ,\
3560                             /*Min_value*/ "any"          ,\
3561                             /*Max Value*/ "any"           \
3562                    );
3563                if ( exon_boundaries[0])set_string_variable ("exon_boundaries", exon_boundaries);
3564
3565                declare_name (dump);
3566                get_cl_param(\
3567                             /*argc*/      argc           ,\
3568                             /*argv*/      argv           ,\
3569                             /*output*/    &le            ,\
3570                             /*Name*/      "-dump",\
3571                             /*Flag*/      &garbage       ,\
3572                             /*TYPE*/      "S"          ,\
3573                             /*OPTIONAL?*/ OPTIONAL       ,\
3574                             /*MAX Nval*/  1              ,\
3575                             /*DOC*/       "dump",\
3576                             /*Parameter*/ &dump   ,\
3577                             /*Def 1*/    "no"       ,\
3578                             /*Def 2*/    ""              ,\
3579                             /*Min_value*/ "any"          ,\
3580                             /*Max Value*/ "any"           \
3581                            );
3582
3583                if (!strm (dump, "no"))
3584                  {
3585                    set_string_variable ("dump_output_file", vtmpnam (NULL));
3586                    set_string_variable ("dump_output_file_list", vtmpnam (NULL));
3587
3588                    set_string_variable ("dump",dump);
3589                  }
3590
3591
3592
3593 /*******************************************************************************************************/
3594 /*                                                                                                     */
3595 /*                           TCoffee_dpa Parameter:END                                                 */
3596 /*                                                                                                     */
3597 /*******************************************************************************************************/
3598
3599
3600
3601                if (argc==1  )
3602                  {
3603                    display_method_names ("display", stdout);
3604                    return EXIT_SUCCESS;
3605                  }
3606                get_cl_param( argc, argv,&le, NULL,NULL,NULL,0,0,NULL);
3607                prepare_cache (cache);
3608 /*******************************************************************************************************/
3609 /*                                                                                                     */
3610 /*                           FILL list_file (contains seq, aln and meth)                               */
3611 /*                                                                                                     */
3612 /*******************************************************************************************************/
3613
3614
3615
3616 /*Re-introduce the sequences introduced with -infile*/
3617 /*Standard*/
3618
3619                if ( infile[0] && !do_evaluate)
3620                    {
3621                    sprintf ( list_file[n_list++], "%s",infile);
3622                    }
3623 /*DO EVALUATE: The aln to evaluate must be provided via -infile*/
3624                else  if (do_evaluate)
3625                    {
3626                      if (!infile[0] ||  !(main_read_aln ( infile, NULL)))
3627                        {
3628                          fprintf ( stderr,"\nERROR: When using -evaluate, Provide a multiple sequence alignment via the -infile flag [FATAL:%s]\n", PROGRAM);
3629                          myexit (EXIT_FAILURE);
3630                        }
3631                      else if (! main_read_aln ( infile,NULL))
3632                        {
3633                          fprintf ( stderr,"\nERROR: FILE %s is NOT a valid alignment [FATAL:%s]\n", infile, PROGRAM);
3634                          myexit (EXIT_FAILURE);
3635                        }
3636                      else if ( infile[0]=='A' ||infile[0]=='S')
3637                        {
3638                          sprintf ( list_file[n_list++], "S%s",infile+1);
3639                        }
3640                      else sprintf ( list_file[n_list++], "S%s",infile);
3641                    }
3642
3643
3644
3645 /*Make Sure -infile is set*/
3646                if (!infile[0]&& (do_evaluate || do_convert))
3647                  {
3648
3649                    if ( do_evaluate || do_convert)sprintf ( infile, "%s",seq_list[0]);
3650                  }
3651
3652 /*EXPAND -in*/
3653                /*Introduce the sequences from the -profile flag*/
3654                if ( profile1 && profile1[0])
3655                  {
3656                    sprintf ( list_file[n_list++], "R%s",profile1);
3657                  }
3658                if ( profile2 && profile2[0])
3659                  {
3660                    sprintf ( list_file[n_list++], "R%s",profile2);
3661                  }
3662
3663                for ( a=0; a< n_profile_list; a++)
3664                  {
3665                    FILE *fp;
3666                    if ( (fp=find_token_in_file (profile_list[a], NULL, "FILE_LIST"))!=NULL)
3667                      {
3668                        int z;
3669                        char rname[1000];
3670                        vfclose (fp);
3671                        fp=vfopen (profile_list[a], "r");
3672
3673                        while ( (z=fgetc(fp))!=EOF)
3674                          {
3675                            ungetc(z, fp);
3676                            fscanf (fp, "%s\n", rname);
3677                            if ( check_file_exists(rname))sprintf ( list_file[n_list++], "R%s", rname);
3678                          }
3679                        vfclose (fp);
3680                      }
3681                    else if (format_is_conc_aln (profile_list[a]))
3682                      {
3683                        Alignment *P;
3684                        char *cname;
3685
3686                        P=input_conc_aln (profile_list[a],NULL);
3687                        while (P)
3688                          {
3689                            cname=vtmpnam (NULL);
3690                            output_fasta_aln (cname, P);
3691                            P=P->A;
3692                            sprintf ( list_file[n_list++], "R%s",cname);
3693                          }
3694                        free_aln (P);
3695                      }
3696
3697                    else
3698                      {
3699                        sprintf ( list_file[n_list++], "R%s",profile_list[a]);
3700                      }
3701                  }
3702                /*Introduce the sequences from the -seq flag*/
3703                for (a=0; a<n_seq_list; a++)
3704                  {
3705                    if (check_file_exists(seq_list[a]))
3706                      sprintf (list_file[n_list++], "S%s",seq_list[a]);
3707                    else if ( check_file_exists (seq_list[a]+1))
3708                      sprintf (list_file[n_list++], "%s",seq_list[a]);
3709                  }
3710                /*introduce the alignments from the -aln flag*/
3711                //Importnat: Must be introduced AFTER the profiles
3712                for (a=0; a<n_aln_file_list; a++)
3713                  {
3714                    sprintf (list_file[n_list++], "A%s",aln_file_list[a]);
3715                  }
3716                /*introduce the alignments from the -method flag*/
3717                for (a=0; a<n_method_list; a++)
3718                  {
3719                    sprintf (list_file[n_list++], "M%s",method_list[a]);
3720                  }
3721                /*introduce the alignments from the -library flag*/
3722                for (a=0; a<n_lib_file_list; a++)
3723                  {
3724                    sprintf (list_file[n_list++], "L%s",lib_file_list[a]);
3725                  }
3726                /*introduce sequences from the exon_boundaries flag flag*/
3727                if ( exon_boundaries && exon_boundaries[0] && check_file_exists (exon_boundaries))
3728                  {
3729                    Sequence *ExS;
3730                    Alignment *ExA;
3731                    char *tmpf;
3732                    //make sure boundaries do not get into the sequences*/
3733
3734                    ExS=main_read_seq (exon_boundaries);
3735                    ExS=seq2clean_seq (ExS, "BOJboj");
3736                    main_output_fasta_seq (tmpf=vtmpnam (NULL),ExA=seq2aln (ExS,NULL,RM_GAP), NO_HEADER);
3737                    sprintf (list_file[n_list++], "S%s",tmpf);
3738                    free_sequence (ExS, ExS->nseq);
3739                    free_aln (ExA);
3740                  }
3741                /*FETCH THE STRUCTURES INTRODUCED WITH -pdb and add them to -in*/
3742                if ( n_pdb)
3743                  {
3744                    for ( a=0; a< n_pdb; a++)
3745                      {
3746                        if ( is_number (pdb_list[a]));
3747                        else
3748                          {
3749                          pdb_start=pdb_end=0;
3750                          if ( a+1< n_pdb && is_number (pdb_list[a+1]))pdb_start=atoi (pdb_list[a+1]);
3751                          if ( a+2< n_pdb && is_number (pdb_list[a+2]))pdb_end=atoi (pdb_list[a+2]);
3752
3753                          pdb_name=get_pdb_struc ( pdb_list[a],pdb_start, pdb_end);
3754                          if (pdb_name){sprintf (list_file[n_list++], "P%s", pdb_name);}
3755                          /*Warning: do not free pdb_name: it is statically allocated by get_pdb_struc*/
3756                          }
3757                      }
3758                  }
3759
3760                /*Check That Enough Methods/Libraries/Alignments Have been Chiped in*/
3761
3762                if (list_file)
3763                  {
3764                    int *nn;
3765                    nn=vcalloc ( 256, sizeof (int));
3766                    for (a=0; a<n_list; a++)
3767                      {
3768                        if ( !check_file_exists(list_file[a]))nn[(int)list_file[a][0]]++;
3769                        else
3770                          {
3771                            if (is_seq (list_file[a]))nn['S']++;
3772                            else if ( is_aln (list_file[a]))nn['A']++;
3773                            else if ( is_lib (list_file[a]))nn['L']++;
3774                            else if ( is_method (list_file[a]))nn['M']++;
3775                            else
3776                              add_warning (stderr, "\nWARNING: File %s was not properly tagged. Potential ambiguity\n",list_file[a]);
3777                          }
3778                      }
3779
3780
3781                    if ( (nn['A']+nn['L']+nn['M'])==0)
3782                      {
3783                        sprintf ( list_file[n_list++], "Mproba_pair"); //new default
3784                        //sprintf ( list_file[n_list++], "Mlalign_id_pair");
3785                        //sprintf ( list_file[n_list++], "Mslow_pair");
3786                      }
3787                    vfree (nn);
3788                  }
3789
3790 /*FILL THE F STRUCTURE (Contains Information for Output names For the defaults)*/
3791                if (n_list==0 || argc<=1)
3792                  {
3793                    fprintf ( stderr, "\nERROR: You have NOT provided enough arguments [FATAL:%s]", PROGRAM);
3794                    myexit (EXIT_FAILURE);
3795                  }
3796
3797
3798                else if ( argv[1][0]!='-' && (check_file_exists( argv[1]) || check_file_exists(argv[1]+1)))
3799                  {
3800                    if (check_file_exists(argv[1]))F=parse_fname(argv[1]);
3801                    else if ( check_file_exists(argv[1]+1))F=parse_fname(argv[1]+1);
3802
3803                  }
3804                else if (infile[0])
3805                  {
3806
3807                    if ( check_file_exists (infile))F=parse_fname(infile);
3808                    else if (check_file_exists (infile+1))F =parse_fname(infile+1);
3809                  }
3810                else if ( exon_boundaries && exon_boundaries[0])
3811                  {
3812                    if ( check_file_exists (exon_boundaries))F=parse_fname(exon_boundaries);
3813                    else if (check_file_exists (exon_boundaries+1))F =parse_fname(exon_boundaries+1);
3814                  }
3815                else
3816                   {
3817
3818                   for ( a=0; a< n_list; a++)
3819                       {
3820                         if (!is_method(list_file[a]))
3821                           {
3822
3823
3824                              if ( check_file_exists( list_file[a])){F=parse_fname(list_file[a]);break;}
3825                              else if ( is_in_set ( list_file[a][0], "ASLX") && check_file_exists( list_file[a]+1)){F=parse_fname(list_file[a]+1);break;}
3826                              else if ( is_in_set ( list_file[a][0], "R") && check_file_exists( list_file[a]+1))
3827                                {
3828                                  char lname[100];
3829                                  F=parse_fname(list_file[a]+1);
3830                                  sprintf ( lname, "%s_1", F->name);
3831                                  sprintf ( F->name, "%s", lname);
3832                                  break;
3833                                }
3834
3835                              else if ( is_in_set ( list_file[a][0], "P") && is_pdb_struc (list_file[a]+1))
3836                                {
3837                                  F=parse_fname(is_pdb_struc (list_file[a]+1));break;
3838
3839                                }
3840                           }
3841                       }
3842
3843                   }
3844
3845
3846                /*Get Structures*/
3847                for ( a=0; a< n_list; a++)
3848                  {
3849                    if ( list_file[a][0]=='P' && !check_file_exists(list_file[a]))
3850                      {
3851                        char buf[1000];
3852                        sprintf(buf, "%s", list_file[a]+1);
3853                        sprintf(list_file[a], "P%s",is_pdb_struc (buf));
3854                      }
3855                  }
3856
3857                /*FATAL: NO SEQUENCES*/
3858                if (!F)
3859                  {
3860                    myexit (fprintf_error(stderr,"You have not provided any sequence"));
3861                  }
3862                if (run_name)F=parse_fname(run_name);
3863                else F->path[0]='\0';
3864
3865
3866                identify_list_format      (list_file, n_list);
3867
3868
3869                fprintf (le, "\nINPUT FILES\n");
3870                for ( a=0; a< n_list; a++)
3871                    {
3872                      fprintf (le, "\tInput File (%c) %s ",list_file[a][0],list_file[a]+1);
3873                      if ( list_file[a][0]=='A' || list_file[a][0]=='S' || list_file[a][0]=='P'|| list_file[a][0]=='R' )
3874                        {
3875                          fprintf (le, " Format %s\n", f=identify_seq_format ( list_file[a]+1));
3876
3877                          if (!f || f[0]=='\0')
3878                            {
3879                              myexit (fprintf_error(stderr,"The format of %s is not supported", list_file[a]+1));
3880
3881                            }
3882                          vfree (f);
3883                        }
3884                      else fprintf (le, "\n");
3885                    }
3886
3887
3888 /*CONVERT, ALIGN OR EVALUATE: CHOSE THE RIGHT VERB*/
3889                /*Set the Hierarchy of the verbs*/
3890                /*The first one decides...*/
3891
3892
3893                do_list=vcalloc ( 100, sizeof (int*));
3894                n_do=0;
3895                do_list[n_do++]=&do_genepred;
3896                do_list[n_do++]=&do_extended_matrix;
3897                do_list[n_do++]=&do_convert;
3898                do_list[n_do++]=&do_evaluate;
3899                do_list[n_do++]=&do_domain;
3900                do_list[n_do++]=&do_align;
3901
3902
3903                for ( a=0; a< n_do; a++)
3904                  {
3905                  if ( do_list[a][0])
3906                    {
3907                    for ( b=0; b< n_do; b++)if ( b!=a)do_list[b][0]=0;
3908                    break;
3909                    }
3910                  }
3911
3912
3913
3914 /*SET THE DEFAULT NAMES*/
3915                if ( do_convert)
3916                    {
3917                      if ( strm (tree_file, "default"))sprintf ( tree_file, "no");
3918                    }
3919
3920
3921
3922                if (  do_evaluate)
3923                    {
3924                    sprintf ( out_lib, "no");
3925                    sprintf ( tree_file, "no");
3926                    clean_aln=0;
3927                    }
3928                if (do_genepred)
3929                  {
3930                    sprintf ( tree_file, "no");
3931                    clean_aln=0;
3932                  }
3933
3934                if ( F && strm ( tree_file, "default"))sprintf ( tree_file ,"%s%s.dnd",F->path     ,F->name);
3935                if ( F && strm ( ph_tree_file, "default"))sprintf ( ph_tree_file ,"%s%s.ph",F->path     ,F->name);
3936
3937                for (a=0; a< n_out_aln_format; a++)
3938                  {
3939                    if (is_out_format_list (out_aln_format[a]));
3940                    else
3941                      {
3942                        fprintf (stderr, "\n%s is not a valid format [FATAL:%s]\n", out_aln_format[a], PROGRAM);
3943                        myexit (EXIT_FAILURE);
3944                      }
3945                  }
3946
3947                for (a=0; a<n_out_aln_format; a++)
3948                  {
3949                    out_aln_format[a]=format_name2aln_format_name(out_aln_format[a]);
3950                  }
3951
3952                if ( F && strm ( out_aln  , "default"))
3953                   {
3954                   for (a=0; a< n_out_aln_format; a++)
3955                     {
3956
3957                       sprintf ( tot_out_aln[a]   ,"%s%s.%s"      ,F->path,F->name,out_aln_format[a]);
3958                     }
3959                   }
3960                else
3961                   {
3962                     sprintf ( tot_out_aln[0], "%s", out_aln);
3963                     for (a=1; a< n_out_aln_format; a++)
3964                       sprintf ( tot_out_aln[a]   ,"%s%s.%s", F->path  ,out_aln, out_aln_format[a]);
3965                   }
3966
3967
3968
3969                if ( F && strm ( out_lib  , "default"))sprintf ( out_lib   ,"%s%s.tc_lib",F->path     , F->name);
3970
3971                if ( type && type[0])
3972                   {
3973                       if (strm2 (type,"Protein", "protein"))sprintf ( type, "PROTEIN");
3974                       if (strm2 (type,"DNA", "dna"))sprintf ( type, "DNA");
3975                       if (strm2 (type,"RNA", "rna"))sprintf ( type, "RNA");
3976
3977                   }
3978
3979
3980                if (   !use_tree && check_file_exists (tree_file))vremove (tree_file);
3981                else if ( !use_tree || (use_tree && strm (use_tree, "default")));
3982                else sprintf ( tree_file, "%s", use_tree);
3983
3984
3985 /*******************************************************************************************************/
3986 /*                                                                                                     */
3987 /*                           Input Sequences and Library                                               */
3988 /*                                                                                                     */
3989 /*******************************************************************************************************/
3990
3991                set_methods_limits (method_limits,n_method_limits,list_file, n_list, &maxnseq, &maxlen);
3992                /*Set Global Values*/
3993
3994
3995
3996 /*START*/
3997
3998                /*1 READ THE SEQUENCES*/
3999
4000                S=read_seq_in_n_list   (list_file, n_list, type,seq_source);
4001
4002                if ( check_type)
4003                  {
4004                    if (!strm (S->type, get_array_type (S->nseq, S->seq)))
4005                      {
4006                        fprintf ( stderr, "\nINCORRECT SEQUENCE TYPE (USE %s ONLY) [FATAL:%s]", S->type, PROGRAM);
4007                        myexit (EXIT_FAILURE);
4008                      }
4009                  }
4010
4011                if (S->nseq<=1 && !do_domain)
4012                  {
4013                    printf_exit (EXIT_FAILURE,stderr, "\nERROR: Your Dataset Contains %d Sequence. For multiple alignments you need at least 2 sequences[FATAL:%s]", S->nseq,PROGRAM);
4014                  }
4015
4016                store_seq_type (S->type);
4017
4018                if ( type_only==1)
4019                  {
4020                    fprintf ( stdout, "%s", S->type);
4021                    return EXIT_SUCCESS;
4022                  }
4023                /*Translate Sequences*/
4024                if ( transform && transform[0])
4025                  {
4026                    S=transform_sequence (S, transform);
4027                  }
4028
4029                /*Abort if the sequences are too long */
4030                if (maxlen!=-1 && S->max_len>maxlen)
4031                   {
4032                       fprintf ( stderr, "\nSEQUENCES TOO LONG [Longuest=%d][MAX=%d][FATAL:%s]\n", S->max_len,maxlen, PROGRAM);
4033                       myexit (EXIT_FAILURE);
4034
4035                   }
4036
4037
4038
4039
4040
4041                /* Get the Templates*/
4042
4043
4044
4045
4046
4047
4048
4049
4050
4051                if ( get_type)
4052                  {
4053                    S=get_sequence_type (S);
4054                    fprintf ( stdout , "%s\n", S->type);
4055                    free_sequence(S, S->nseq);
4056                    return 1;
4057                  }
4058
4059
4060                /*Reorder the sequences*/
4061                new_order=duplicate_char (S->name, -1, -1);
4062                if ( strm (inorder, "aligned"))new_order=sort_string_array   (new_order, S->nseq);
4063
4064                initial_order=duplicate_char (S->name, -1, -1);
4065                S=reorder_seq(S,new_order,S->nseq);
4066                free_char (new_order, -1);
4067
4068
4069
4070                /*3 PREPARE THE CONSTRAINT LIST*/
4071
4072                CL=declare_constraint_list ( S,NULL, NULL, 0,(strm(mem_mode, "disk"))?tmpfile():NULL, NULL);
4073
4074                sprintf ( CL->method_evaluate_mode, "%s", method_evaluate_mode);
4075
4076                (CL->TC)->use_seqan=use_seqan;
4077                CL->local_stderr=le;
4078                /*set the genepred parameters*/
4079                sprintf ( CL->genepred_score, "%s", genepred_score);
4080                /*Estimate the distance Matrix*/
4081
4082
4083                if (extend_seq)extend_seqaln(CL->S,NULL);
4084                CL->DM=cl2distance_matrix ( CL,NOALN,distance_matrix_mode, distance_matrix_sim_mode,1);
4085                if (extend_seq)unextend_seqaln(CL->S,NULL);
4086
4087
4088
4089                /*one to all alignment*/
4090                MASTER_SEQ=prepare_master(master_mode,S,CL, "ktup");
4091                if (!blast_maxnseq)CL->o2a_byte=(CL->S)->nseq;
4092                else CL->o2a_byte=blast_maxnseq;
4093
4094                /*4 GET TEMPLATES*/
4095                        //Intercept Master Sequences
4096
4097                if (MASTER_SEQ)
4098                  {
4099                    TEMP_SEQ=S;
4100                    S=MASTER_SEQ;
4101                  }
4102
4103                if ( n_template_file)
4104                  {
4105                    fprintf ( le, "\nLooking For Sequence Templates:\n");
4106                    for ( a=0; a< n_template_file; a++)
4107                      {
4108                        //correct for missing extension modes
4109                        if (strm (template_file_list[a],"RNA") && !strstr (extend_mode, "rna"))sprintf ( extend_mode, "rna2");
4110
4111
4112                        fprintf ( le, "\n\tTemplate Type: [%s] Mode Or File: [%s] [Start", template_type2type_name(template_file_list[a]), template_file_list[a]);
4113                        S=seq2template_seq(S, template_file_list[a], F);
4114                        fprintf ( le, "]");
4115
4116                        if (S==NULL)
4117                          {
4118                            add_warning (stderr, "\nImpossible to find %s Templates\nCheck that your blast server is properly installed [See documentation][FATAL:%s]\n", template_file_list[a],PROGRAM);
4119                            myexit (EXIT_FAILURE);
4120                          }
4121                      }
4122
4123                    if (seq2n_X_template ( S, "_*_"))
4124                      {
4125
4126                        sprintf (S->template_file, "%s",seq2template_file (S, NULL));
4127                      }
4128                  }
4129                else
4130                  {
4131                    int ptf=0;
4132                    for ( a=0; a<S->nseq; a++)
4133                      {
4134                        if ( seq_has_template ( S, a, "_P_"))ptf=1;
4135                      }
4136                    if (ptf)
4137                      {
4138                        int j;
4139                        sprintf ( S->template_file   ,"%s%s.template_file",F->path     , F->name);
4140                        seq2template_file (S,S->template_file);
4141                        display_output_filename ( stdout, "Template_List","fasta_seq", S->template_file, STORE);
4142                      }
4143                  }
4144
4145
4146                if (n_profile_template_file)
4147                  {
4148                    fprintf ( le, "\nLooking For Profile  Templates");
4149                    for ( a=0; a< n_profile_template_file; a++)
4150                      {
4151                        fprintf ( le, "\n\tTemplate Type: [%s] Mode Or File: [%s] [Start", template_type2type_name(profile_template_file_list[a]), profile_template_file_list[a]);
4152                        S=profile_seq2template_seq(S, profile_template_file_list[a], F);
4153                        fprintf ( le, "]");
4154                        if (S==NULL)
4155                          {
4156                            add_warning(stderr, "Impossible to find %s Templates\nCheck that your blast server is properly installed [See documentation][FATAL:%s]\n",profile_template_file_list[a], PROGRAM);
4157                            myexit (EXIT_FAILURE);
4158                          }
4159                      }
4160                  }
4161
4162
4163
4164
4165                //Release Master Sequences
4166                if (MASTER_SEQ )
4167                  {
4168                    int i;
4169                    S=TEMP_SEQ;
4170                    for (a=0; a< MASTER_SEQ->nseq; a++)
4171                      if ((i=name_is_in_list (MASTER_SEQ->name[a], S->name, S->nseq, 100))!=-1)
4172                        {
4173                          S->T[i]=MASTER_SEQ->T[a];
4174                        }
4175                  }
4176                S=seq2template_seq(S, "SELF_S_",F);
4177                S=seq2template_type (S);
4178
4179                le=display_sequences_names   ( S, le, check_pdb_status, TEMPLATES);
4180                /*4 GET TEMPLATES: DONE*/
4181
4182
4183
4184
4185                if (  matrix && matrix[0])
4186                  {
4187                    sprintf ( CL->method_matrix,"%s", matrix);
4188
4189                  }
4190                /*Set the filtering*/
4191                CL->filter_lib=filter_lib;
4192                /*Set the evaluation Functions*/
4193                CL->profile_mode=get_profile_mode_function (profile_mode, NULL);
4194                sprintf ( CL->profile_comparison, "%s", profile_comparison);
4195                if ( n_struc_to_use)
4196                  {
4197                    CL->STRUC_LIST=declare_sequence (1,1,n_struc_to_use);
4198                    CL->STRUC_LIST->nseq=0;
4199                    for ( a=0; a< n_struc_to_use; a++)
4200                      {
4201
4202                        sprintf ( (CL->STRUC_LIST)->name[(CL->STRUC_LIST)->nseq++],"%s",struc_to_use[a]);
4203                      }
4204                  }
4205                sprintf (CL->align_pdb_param_file, "%s", align_pdb_param_file);
4206                sprintf (CL->align_pdb_hasch_mode, "%s", align_pdb_hasch_mode);
4207
4208
4209
4210                /*Blast Parameters*/
4211                (CL->Prot_Blast)->min_id=prot_min_sim;
4212                (CL->Prot_Blast)->max_id=prot_max_sim;
4213                (CL->Prot_Blast)->min_cov=prot_min_cov;
4214                sprintf ( (CL->Prot_Blast)->blast_server, "%s", prot_blast_server);
4215                sprintf ( (CL->Prot_Blast)->db, "%s", prot_db);
4216
4217                (CL->Pdb_Blast)->min_id=pdb_min_sim;
4218
4219                (CL->Pdb_Blast)->max_id=pdb_max_sim;
4220                (CL->Pdb_Blast)->min_cov=pdb_min_cov;
4221                sprintf ( (CL->Pdb_Blast)->blast_server, "%s", pdb_blast_server);
4222                sprintf ( (CL->Pdb_Blast)->db, "%s", pdb_db);
4223                CL->check_pdb_status=check_pdb_status;
4224                /*split parameters */
4225                CL->split=split;
4226                CL->split_nseq_thres=split_nseq_thres;
4227                CL->split_score_thres=split_score_thres;
4228                /*Blast Parameters
4229                (CL->DNA_Blast)->min_id=dna_min_sim;
4230                (CL->DNA_Blast)->max_id=dna_max_sim;
4231                (CL->DNA_Blast)->min_cov=dna_min_cov;
4232                sprintf ( (CL->DNA_Blast)->blast_server, "%s", dna_blast_server);
4233                sprintf ( (CL->DNA_Blast)->db, "%s", dna_db);
4234                */
4235
4236                if ( method_log)
4237                  {
4238                    if ( strm (method_log, "default"))
4239                      {
4240                        sprintf ( CL->method_log, "%s%s.method_log",F->path, F->name);
4241                      }
4242                    else if ( !strm (method_log, "no"))
4243                      {
4244                       sprintf ( CL->method_log, "%s", method_log);
4245                      }
4246                    set_string_variable ("method_log", method_log);
4247                  }
4248
4249
4250                CL->lalign_n_top=lalign_n_top;
4251                sprintf ( CL->multi_thread, "%s", multi_core);
4252
4253                sprintf ( CL->lib_list, "%s", lib_list);
4254                sprintf (CL->rna_lib, "%s", rna_lib);
4255 /* Important: This is where the library is compiled!!!!*/
4256
4257                if ((CL->S)->nseq>1 && !do_convert)
4258                  {
4259                    CL=read_n_constraint_list (list_file,n_list,NULL, mem_mode,weight,type, le, CL, seq_source);
4260                    //CL=post_process_constraint_list (CL); //needed when constraints are added, for instance the RNA modes
4261                  }
4262                else if ( do_convert && out_lib[0])
4263                  {
4264                    if ( infile[0])
4265                      {sprintf (list_file[0], "%s", name2type_name(infile));
4266                      CL=read_n_constraint_list (list_file,1,NULL, mem_mode,weight,type, le, CL, seq_source);
4267                      }
4268                    else
4269                      {
4270                      CL=read_n_constraint_list (list_file,n_list,NULL, mem_mode,weight,type, le, CL, seq_source);
4271                      }
4272                  }
4273                if ( CL->M)clean_aln=0;
4274
4275                if ( is_number (weight))set_weight4constraint_list (CL, atoi(weight));
4276
4277                free_pair_wise ();//Free ststic memory allocated in some of the pairwise functions
4278
4279
4280                //Shrink: re-run slow_pair using the library, remove everything
4281
4282
4283                /*If the List is empty*/
4284                if ( (CL->S)->nseq>1 && CL->ne==0 && !CL->M &&!(do_convert && n_list>0))
4285                  {
4286                    fprintf ( stderr, "\n******************ERROR*****************************************\n");
4287
4288                    fprintf ( stderr, "\nYou have not provided any method or enough Sequences[FATAL]");
4289                    fprintf ( stderr, "\nIf you have used the '-in' Flag, ADD the methods you wish to use:");
4290                    fprintf ( stderr, "\n\t-in <your sequences> Mlalign_id_pair Mfast_pair\n");
4291                    fprintf ( stderr, "\nAnd make sure you provide at least TWO sequences\n");
4292                    for ( a=0; a< argc; a++)fprintf ( stderr, "%s ", argv[a]);
4293                    fprintf ( stderr, "\n*****************************************************************\n");
4294                    myexit(EXIT_FAILURE);
4295                  }
4296
4297
4298                CL->normalise=do_normalise;
4299
4300                if ( type && type[0])sprintf ( (CL->S)->type, "%s", type);
4301                CL->extend_jit=(do_extend>0)?1:0;
4302
4303                CL->extend_threshold=(do_extend==1)?0:do_extend;
4304                CL->do_self=do_self;
4305                sprintf (CL->extend_clean_mode,   "%s", clean_mode);
4306                sprintf (CL->extend_compact_mode, "%s", compact_mode);
4307                if ( CL->extend_jit && CL->extend_threshold !=0)filter_constraint_list (CL,WE,CL->extend_threshold);
4308                CL->pw_parameters_set=1;
4309
4310
4311
4312                CL->nomatch=nomatch;
4313                set_int_variable ("nomatch", nomatch);
4314                /*Gep and Gop*/
4315                if ( !gep &&  !gop && CL->M)
4316                    {
4317                     CL->gop=get_avg_matrix_mm ( CL->M, (strm3((CL->S)->type,"PROTEIN", "Protein", "protein")?AA_ALPHABET:"gcuta"))*10;
4318                     CL->gep=CL->gop/10;
4319                     fprintf ( CL->local_stderr, "\nAUTOMATIC PENALTIES: gapopen=%d gapext=%d", CL->gop, CL->gep);
4320                    }
4321                else if ( !CL->M && cosmetic_penalty && !gep && !gop)
4322                    {
4323                     CL->gep=0;
4324                     CL->gop=cosmetic_penalty;
4325                    }
4326                else
4327                    {
4328                      CL->gep=gep;
4329                      CL->gop=gop;
4330                      fprintf ( CL->local_stderr, "\nMANUAL PENALTIES: gapopen=%d gapext=%d", CL->gop, CL->gep);
4331                    }
4332
4333                /*Frame Penalties*/
4334                CL->f_gep=f_gep;
4335                CL->f_gop=f_gop;
4336
4337
4338                CL->maximise=maximise;
4339
4340                if (strm(retrieve_seq_type(),"DNA")|| strm(retrieve_seq_type(),"RNA") )
4341                    CL->ktup=MAX(2,ktup);
4342                else
4343                    CL->ktup=ktup;
4344
4345                CL->use_fragments=diag_mode;
4346                CL->fasta_step=fasta_step;
4347                CL->diagonal_threshold=diag_threshold;
4348
4349                sprintf ( CL->matrix_for_aa_group, "%s", sim_matrix);
4350                sprintf ( CL->dp_mode, "%s", dp_mode);
4351                CL->TG_MODE=tg_mode;
4352
4353                sprintf ( CL->evaluate_mode, "%s", evaluate_mode);
4354                fprintf (le, "\n\n\tLibrary Total Size: [%d]\n", CL->ne);
4355
4356
4357                CL=choose_extension_mode (extend_mode, CL);
4358                CL->max_n_pair=max_n_pair;
4359
4360                processed_lib=0;
4361                //use the L, vener touch it again
4362
4363
4364               if (CL->ne>0 && out_lib[0]!='\0' && !strm (out_lib, "no"))
4365                  {
4366
4367                    if (strstr (out_lib_mode, "extended"))
4368                      {
4369                        char emode[1000];
4370
4371                        //Do the processing before saving the extended lib*/
4372                        processed_lib=1;
4373                        if ( filter_lib) CL=filter_constraint_list (CL,CL->weight_field, filter_lib);
4374                        for (a=0; a<relax_lib; a++)CL=relax_constraint_list (CL);
4375                        for (a=0; a<shrink_lib; a++)CL=shrink_constraint_list (CL);
4376                        sprintf ( emode, "lib_%s", out_lib_mode);
4377
4378                        OUT=vfopen (out_lib, "w");
4379                        OUT=save_extended_constraint_list(CL,emode,OUT);
4380                      }
4381                    else
4382                      {
4383                        OUT=save_constraint_list ( CL, 0, CL->ne, out_lib, NULL, "ascii",CL->S);
4384                      }
4385                    vfclose (OUT);
4386                    CL->local_stderr=display_output_filename (le, "TCLIB","tc_lib_format_01",out_lib, CHECK);
4387                  }
4388
4389
4390               if ( lib_only)return EXIT_SUCCESS;
4391
4392               //fprintf ( stderr, "AVG LINK: %3f", constraint_list2connectivity (CL); exit (0);
4393               if (!processed_lib)
4394                 {
4395                   if ( filter_lib) CL=filter_constraint_list (CL,CL->weight_field, filter_lib);
4396                   if (atoigetenv ("EXTEND4TC")==1)CL=extend_constraint_list(CL);
4397                   for (a=0; a<relax_lib; a++)CL=relax_constraint_list (CL);
4398                   for (a=0; a<shrink_lib; a++)CL=shrink_constraint_list (CL);
4399                 }
4400
4401               CL=evaluate_constraint_list_reference (CL);
4402               sprintf ( CL->distance_matrix_mode, "%s", distance_matrix_mode);
4403               sprintf ( CL->distance_matrix_sim_mode, "%s", distance_matrix_sim_mode);
4404
4405               sprintf ( CL->tree_mode, "%s", tree_mode);
4406               //Re-estimate the distance matrix with consistency//
4407                if ( strm ("cscore", distance_matrix_mode))
4408                  {
4409                    CL->DM=cl2distance_matrix ( CL,NOALN,distance_matrix_mode, distance_matrix_sim_mode,1);
4410                  }
4411               /*WEIGHT CONSTRAINT LIST*/
4412
4413               if ( !do_convert)
4414                 {
4415
4416                   CL->DM=cl2distance_matrix (CL, NOALN, NULL, NULL,0);
4417
4418                   CL=weight_constraint_list(CL, seq_weight);
4419
4420                   if (output_seq_weights (CL->W, outseqweight))
4421                     CL->local_stderr=display_output_filename( CL->local_stderr,"WEIGHT","tc_weight",outseqweight, CHECK);
4422                   le=display_weights(CL->W, le);
4423                 }
4424
4425
4426
4427               /*Prepare quadruplets*/
4428               if ( nseq_for_quadruplet && !strm(seq_name_for_quadruplet[0], "all"))
4429                 {
4430                   CL->nseq_for_quadruplet=nseq_for_quadruplet;
4431                   CL->seq_for_quadruplet=vcalloc ((CL->S)->nseq, sizeof (int));
4432                   for (a=0; a< CL->nseq_for_quadruplet; a++)
4433                     {
4434                       printf ( "\nquad: %s", seq_name_for_quadruplet[a]);
4435                       if ( (b=name_is_in_list (seq_name_for_quadruplet[a],(CL->S)->name,(CL->S)->nseq, 100))!=-1)CL->seq_for_quadruplet[b]=1;
4436                       else add_warning ( stderr, "\nWARNING: Sequence %s is not in the set and cannot be used for quadruplet extension\n",seq_name_for_quadruplet[a]);
4437                     }
4438                 }
4439               else if ( nseq_for_quadruplet && strm(seq_name_for_quadruplet[0], "all"))
4440                 {
4441
4442                   CL->nseq_for_quadruplet=(CL->S)->nseq;
4443                   CL->seq_for_quadruplet=vcalloc ((CL->S)->nseq, sizeof (int));
4444                   for (a=0; a< CL->nseq_for_quadruplet; a++)
4445                     {
4446                       CL->seq_for_quadruplet[a]=1;
4447                     }
4448                 }
4449
4450 /*******************************************************************************************************/
4451 /*                                                                                                     */
4452 /*                           Prepare The Alignment                                                     */
4453 /*                                                                                                     */
4454 /*******************************************************************************************************/
4455
4456               if ( do_align )
4457                    {
4458
4459
4460                    A=seq2aln  ((CL->S),NULL,1);
4461                    ungap_array(A->seq_al,A->nseq);
4462
4463                    /*Chose the right Mode for evaluating Columns*/
4464
4465                    if ( A->nseq==1);
4466                    else if ( strm ( msa_mode, "seq_aln"))
4467                      {
4468                        A=seq_aln (A,(CL->S)->nseq, CL);
4469                      }
4470                    else if ( strm ( msa_mode, "sorted_aln"))
4471                      {
4472                        A=sorted_aln (A, CL);
4473                      }
4474                    else if ( strm ( msa_mode, "full_sorted_aln"))
4475                      {
4476                        full_sorted_aln (A, CL);
4477                        output_constraints (out_lib, "sim", A);
4478                        CL->local_stderr=display_output_filename (le, "TCLIB","tc_lib_format_01",out_lib, CHECK);
4479                        return EXIT_SUCCESS;
4480                      }
4481
4482                    else if ( strm ( msa_mode, "profile_aln"))
4483                      {
4484                        A=iterative_tree_aln (A, 0, CL);
4485                        A=profile_aln (A, CL);
4486                      }
4487                    else if ( strm ( msa_mode, "iterative_aln"))
4488                      {
4489                        A=iterative_tree_aln (A, 0, CL);
4490                        A=iterative_aln (A,10, CL);
4491                      }
4492                     else if ( strm ( msa_mode, "iterative_tree_aln"))
4493                      {
4494                        A=iterative_tree_aln (A,1, CL);
4495                      }
4496                     else if ( strm ( msa_mode, "dpa_aln"))
4497                       {
4498                         A=dpa_aln (A, CL);
4499                       }
4500                     else if ( strm ( msa_mode, "new_dpa_aln"))
4501                       {
4502                         A=new_dpa_aln (A, CL);
4503                       }
4504                     else if ( strm ( msa_mode, "delayed_tree_aln"))
4505                      {
4506                        A=make_delayed_tree_aln (A,2, CL);
4507                      }
4508                    else if ( strm ( msa_mode, "groups"))
4509                      {
4510                        A=seq2aln_group (A,dpa_maxnseq, CL);
4511                        out_aln_format[0]="conc_aln";
4512                        n_out_aln_format=1;
4513                      }
4514                    else if ( strm ( msa_mode, "upgma"))
4515                      {
4516                        A=upgma_tree_aln (A, A->nseq, CL);
4517                      }
4518                    else if ( strm ( msa_mode, "graph"))
4519                         {
4520                           fprintf ( stderr, "\nDO GRAPH ALIGNMENT");
4521                           A=graph_aln ( A, CL, (CL->S));
4522                         }
4523                    else if ( strm ( msa_mode, "tsp"))
4524                         {
4525                           fprintf ( stderr, "\nDO TSP ALIGNMENT");
4526                           A=tsp_aln ( A, CL, (CL->S));
4527                         }
4528                    else if ( strm ( msa_mode, "precomputed"))
4529                      {
4530                        if (infile[0]) {free_aln (A);A=main_read_aln ( infile, declare_aln(CL->S));}
4531                        else{fprintf ( stderr, "\nERROR: distance_matrix_mode=aln requires an aln passed via the -infile flag [FATAL:%s]", PROGRAM);crash ("");}
4532
4533                        sprintf ( CL->dp_mode, "precomputed_pair_wise");
4534                        sprintf ( CL->distance_matrix_mode, "aln");
4535                        CL->tree_aln=A=reorder_aln ( A, (CL->S)->name,(CL->S)->nseq);
4536
4537                        pc=tree_file;
4538                        if ( strm (tree_file, "default") || !check_file_exists (tree_file))
4539                          T=make_tree ( A,CL,gop, gep,(CL->S),pc, maximise);
4540                        else if ( strm (tree_file, "no"))
4541                          T=make_tree ( A,CL,gop, gep,(CL->S),NULL, maximise);
4542                        else
4543                          {
4544                            T=read_tree (pc,&tot_node,(CL->S)->nseq,  (CL->S)->name);
4545                          }
4546
4547                        SNL=tree_aln ((T[3][0])->left,(T[3][0])->right,A,(CL->S)->nseq, CL);
4548                      }
4549                    else if ( strm ( msa_mode, "tree"))
4550                      {
4551                        if ( strm (CL->distance_matrix_mode, "aln"))
4552                          {
4553                            if (infile[0]) {free_aln (A);A=main_read_aln ( infile, declare_aln(CL->S));}
4554                            else{fprintf ( stderr, "\nERROR: distance_matrix_mode=aln requires an aln passed via the -infile flag [FATAL:%s]", PROGRAM);crash ("");}
4555                            CL->tree_aln=A;
4556                          }
4557                        pc=tree_file;
4558                        if ( strm (tree_file, "default") || !check_file_exists (tree_file))
4559                          T=make_tree ( A,CL,gop, gep,(CL->S),pc,maximise);
4560                        else if ( strm (tree_file, "no"))
4561                          T=make_tree ( A,CL,gop, gep,(CL->S),NULL, maximise);
4562                        else
4563                          {
4564                            fprintf ( le, "\nREAD PRECOMPUTED TREE: %s\n", pc);
4565                            T=read_tree (pc,&tot_node,(CL->S)->nseq,  (CL->S)->name);
4566                          }
4567                        SNL=tree_aln ((T[3][0])->left,(T[3][0])->right,A,(CL->S)->nseq, CL);
4568                        A->nseq=(CL->S)->nseq;
4569                      }
4570
4571                    else
4572                      {
4573                        fprintf ( stderr, "\nERROR: msa_mode %s is unknown [%s:FATAL]\n", msa_mode, PROGRAM);
4574                        crash ("");
4575                      }
4576
4577                    }
4578                else if ( (do_evaluate || do_convert))
4579                    {
4580
4581
4582                    A=(infile[0])?main_read_aln ( infile, declare_aln(CL->S)):NULL;
4583
4584                    if (!A)A=seq2aln((CL->S), NULL,0);
4585
4586
4587                    A->S=CL->S;
4588                    A->nseq=(CL->S)->nseq;
4589
4590
4591                    }
4592                else if ( do_genepred)
4593                  {
4594                    Alignment *A1, *A2;
4595                    A1=seq2aln(CL->S, NULL, 1);
4596                    A1->S=CL->S;
4597                    A2=coffee_seq_evaluate_output (A1, CL);
4598                    if (!A2->score_res)myexit(0);
4599                    for ( b=0; b< n_out_aln_format; b++)
4600                      {
4601                        Alignment *OUT;
4602
4603                        OUT=copy_aln (A2,NULL);
4604                        output_format_aln (out_aln_format[b],OUT,NULL, tot_out_aln[b]);
4605                        le=display_output_filename( le,"MSA",out_aln_format[b], tot_out_aln[b], CHECK);
4606                        free_aln (OUT);
4607                      }
4608                    return EXIT_SUCCESS;
4609                  }
4610
4611               else if (do_domain)
4612                    {
4613                      CL->moca=vcalloc ( 1, sizeof ( Moca));
4614                      if (strm ( "cfasta_pair_wise", dp_mode))sprintf (CL->dp_mode, "%s","domain_pair_wise");
4615                      (CL->moca)->moca_start=domain_start;
4616                      (CL->moca)->moca_len  =domain_len;
4617                      (CL->moca)->moca_scale=(domain_scale==0)?-(CL->normalise/20):domain_scale;
4618                      (CL->moca)->moca_interactive=domain_interactive;
4619
4620
4621
4622                      if (!cosmetic_penalty && !gep && !gop)
4623                        {
4624                          CL->gop=-200;
4625                          CL->gep=-100;
4626                        }
4627
4628                      CL=prepare_cl_for_moca (CL);
4629                      aln_list=moca_aln (CL);
4630                      free_int ( CL->packed_seq_lu, -1);
4631                      CL->packed_seq_lu=NULL;
4632
4633                      a=0;
4634                      while ( aln_list[a])
4635                        {
4636                        for ( b=0; b< n_out_aln_format; b++)
4637                           {
4638
4639                             output_format_aln (out_aln_format[b],aln_list[a],EA=fast_coffee_evaluate_output(aln_list[a], CL), tot_out_aln[b]);
4640                             le=display_output_filename( le,"MSA",out_aln_format[b], tot_out_aln[b], CHECK);
4641                           }
4642                        a++;
4643                        }
4644                    return EXIT_SUCCESS;
4645                    }
4646               else if ( do_extended_matrix)
4647                 {
4648                   A=seq2aln(CL->S, NULL, 1);
4649                   A->CL=CL;
4650                   for ( a=0; a< n_out_aln_format; a++)
4651                     {
4652                       output_format_aln (out_aln_format[a],A,EA, tot_out_aln[a]);
4653                       le=display_output_filename( le,"MSA",out_aln_format[a], tot_out_aln[a], CHECK);
4654                     }
4655
4656                   return EXIT_SUCCESS;
4657                 }
4658
4659
4660 /*******************************************************************************************************/
4661 /*                                                                                                     */
4662 /*                           PREPARE THE ALIGNMENT FOR OUTPUT                                          */
4663 /*                                                                                                     */
4664 /*******************************************************************************************************/
4665
4666               if (A)
4667                   {
4668                     /*
4669                     for ( a=0; a< A->nseq; a++)
4670                       {
4671                            for ( b=0; b< A->len_aln ; b++)
4672                              if ( A->seq_al[a][b]=='O' || A->seq_al[a][b]=='o')A->seq_al[a][b]='-';
4673                          }
4674                     */
4675
4676
4677
4678
4679                     if ( check_file_exists(outorder))
4680                         {
4681                           Sequence *OS;
4682                           OS=get_fasta_sequence (outorder, NULL);
4683                           if ( prf_in_seq (CL->S))A->expanded_order=OS->name;
4684                           else A=reorder_aln ( A,OS->name,A->nseq);
4685                         }
4686                       else if ( strm(outorder, "aligned") && T)
4687                         {
4688                           A=reorder_aln ( A,A->tree_order,A->nseq);
4689
4690                         }
4691                       else
4692                         {
4693
4694                           A=reorder_aln ( A, (CL->S)->name,(CL->S)->nseq);
4695                           A=reorder_aln ( A, initial_order,(CL->S)->nseq);
4696
4697                         }
4698
4699                       A->output_res_num=strm3 ( output_res_num, "on", "On", "ON");
4700
4701                       if ( strm2 (residue_case, "keep", "retain"))A->residue_case=KEEP_CASE;
4702                       else if (strm3 (residue_case, "upper", "Upper", "UPPER"))A->residue_case=UPPER_CASE;
4703                       else if (strm3 (residue_case, "lower", "Lower", "LOWER"))A->residue_case=LOWER_CASE;
4704                       else A->residue_case=1;
4705
4706
4707
4708
4709
4710
4711                       if ( iterate)
4712                         {
4713                           A=iterate_aln (A, iterate, CL);
4714                           A=ungap_aln(A);
4715                         }
4716
4717                       if ( clean_aln)
4718                         {
4719                           EA=main_coffee_evaluate_output(A, CL,clean_evaluate_mode);
4720                           A=clean_maln(A, EA,clean_threshold,clean_iteration);
4721                           free_aln (EA);
4722                           A=ungap_aln(A);
4723                         }
4724
4725                       //overaln
4726                       if (clean_overaln)
4727                         {
4728                           char *over_aln_tmp;
4729                           over_aln_tmp=vtmpnam(NULL);
4730                           output_format_aln ("overaln", A, NULL, over_aln_tmp);
4731                           A=main_read_aln (over_aln_tmp,A);
4732                         }
4733
4734                       EA=main_coffee_evaluate_output(A, CL, evaluate_mode);
4735
4736                       //correct ascii file
4737                       if (clean_overaln)
4738                         {
4739                           EA=overlay_alignment_evaluation (A,EA);
4740                         }
4741
4742
4743                       if (A->A)A=A->A;
4744                       if (!strm2(out_aln, "stdout", "stderr") && le==stderr && !do_convert)output_format_aln ("aln",A,NULL,"stdout");
4745
4746
4747                       A->CL=CL;
4748                       for ( a=0; a< n_out_aln_format; a++)
4749                         if ( !strstr ( out_aln_format[a], "expand"))output_format_aln (out_aln_format[a],A,EA, tot_out_aln[a]);
4750                       for ( a=0; a< n_out_aln_format; a++)
4751                         if ( strstr (out_aln_format[a], "expand"))output_format_aln (out_aln_format[a],A,EA, tot_out_aln[a]);
4752
4753
4754
4755                       fprintf (le, "\n\nOUTPUT RESULTS");
4756                       if ((CL->S)->nseq>2)
4757                         le=display_output_filename (le, "GUIDE_TREE","newick", tree_file, CHECK);
4758
4759                       for ( a=0; a< n_out_aln_format; a++)
4760                         le=display_output_filename( le,"MSA",out_aln_format[a], tot_out_aln[a], CHECK);
4761                       if (CL->ne>0 && out_lib[0]!='\0' && !strm (out_lib, "no"))
4762                         CL->local_stderr=display_output_filename (le, "TCLIB","tc_lib_format_01",out_lib, CHECK);
4763
4764                       if (!strm (ph_tree_file, "NO") && A->nseq>2)
4765                         {
4766                           NT_node T;
4767                           FILE *tfp;
4768                           char **tmode;
4769                           tmode=declare_char (2, 100);
4770                           sprintf (tmode[0], "nj");
4771                           T=tree_compute (A, 1, tmode);
4772                           tfp=vfopen (ph_tree_file, "w");
4773                           tfp=print_tree (T, "newick", tfp);
4774                           vfclose (tfp);
4775                           le=display_output_filename (le, "PHYLOGENIC_TREE","newick", ph_tree_file, CHECK);
4776                         }
4777
4778                   }
4779
4780               if (split)
4781                 {
4782
4783                   if (trim && n_seq_to_keep)
4784                     {
4785                       if (n_seq_to_keep==1 && check_file_exists (seq_to_keep[0]))
4786                         {
4787
4788                           SEQ_TO_KEEP=read_sequences (seq_to_keep[0]);
4789                         }
4790                       else
4791                         {
4792
4793                           SEQ_TO_KEEP=declare_sequence ( 1, 1,n_seq_to_keep);
4794                           for ( a=0; a< n_seq_to_keep; a++)sprintf ( SEQ_TO_KEEP->name[a], "%s", seq_to_keep[a]);
4795                         }
4796                     }
4797
4798                   sprintf ( CL->dp_mode, "precomputed_pair_wise");
4799                   sprintf ( CL->distance_matrix_mode, "aln");
4800
4801
4802
4803                   CL->tree_aln=A=reorder_aln ( A, (CL->S)->name,(CL->S)->nseq);
4804                   CL->S=aln2seq ( A);
4805
4806                   if (!T)
4807                     {
4808
4809                       pc=tree_file;
4810                       if ( strm (tree_file, "default") || !check_file_exists (tree_file))
4811                         T=make_tree ( A,CL,gop, gep,(CL->S),pc, maximise);
4812                       else if ( strm (tree_file, "no"))
4813                         T=make_tree ( A,CL,gop, gep,(CL->S),NULL, maximise);
4814                       else
4815                         {
4816                           T=read_tree (pc,&tot_node,(CL->S)->nseq,  (CL->S)->name);
4817                         }
4818                     }
4819
4820                   SNL=tree_aln ((T[3][0])->left,(T[3][0])->right,A,(CL->S)->nseq, CL);
4821
4822
4823                   for ( a=0, b=0; a<A->nseq; a++)b+=(SNL[a])?1:0;
4824                   fprintf ( le, "\n\nSPLIT DATASET: %d Groups\n", b);
4825                   /*Display Group Names*/
4826
4827                   if ( trim && SEQ_TO_KEEP)
4828                     {
4829                       for ( a=0; a< SEQ_TO_KEEP->nseq; a++)
4830                         {
4831
4832                           trim_subS=extract_one_seq(SEQ_TO_KEEP->name[a],0,0,A,KEEP_NAME);
4833                           trim_S=add_sequence (trim_subS,trim_S,0);
4834                         }
4835                     }
4836                   for ( a=0, b=0; a<A->nseq; a++)
4837                     {
4838
4839                       if ( SNL[a])
4840                         {
4841                           b++;
4842                           fprintf ( le, "\n\tSPLIT_GROUP %d ; Nseq %d ; Score %d ; List ",b, (SNL[a])->nseq, (int)(SNL[a])->score);
4843                           for ( c=0; c< (SNL[a])->nseq; c++)
4844                             {
4845                               fprintf ( le, "%s ",(CL->S)->name[(SNL[a])->lseq[c]]);
4846                             }
4847
4848                           SPLIT_ALN=extract_sub_aln (A, (SNL[a])->nseq,(SNL[a])->lseq);
4849                           SPLIT_ALN->S=A->S;
4850                           ungap_aln (SPLIT_ALN);
4851
4852                           if (!trim)
4853                             {
4854                               sprintf ( split_format, "%s", "clustalw");
4855                               sprintf ( split_name, "%s.split.%d.%s", F->name, b,split_format);
4856                               fprintf ( le, " ; File %s",  split_name);
4857                               output_format_aln (split_format,SPLIT_ALN,NULL,split_name);
4858                               le=display_output_filename( le,"SPLIT_SEQ",split_format,split_name, CHECK);
4859                             }
4860                           else if (trim)
4861                             {
4862                               t=aln2most_similar_sequence(SPLIT_ALN, "idmat");
4863                               trim_subS=extract_one_seq(SPLIT_ALN->name[t],0,0,SPLIT_ALN,KEEP_NAME);
4864                               trim_S=add_sequence (trim_subS,trim_S,0);
4865                               fprintf ( le, "\n\tTRIM_SEQ: Kept sequence %s",SPLIT_ALN->name[t]);
4866                             }
4867                           free_aln (SPLIT_ALN);
4868                           fprintf (le, "\n");
4869                         }
4870                     }
4871
4872                   if (trim)
4873                       {
4874
4875
4876                        SPLIT_ALN=seq2aln (trim_S,NULL, KEEP_GAP);
4877                        ungap_aln (SPLIT_ALN);
4878                        sprintf ( trim_format, "%s", "fasta_aln");
4879                        if ( strm (trimfile, "default"))sprintf ( trimfile, "%s.trim.%s", F->name,trim_format);
4880
4881                        output_format_aln (trim_format,SPLIT_ALN,NULL,trimfile);
4882                        le=display_output_filename( le,"TRIM_SEQ",trim_format,trimfile, CHECK);
4883                       }
4884                 }
4885
4886               if (remove_template_file){S=vremove_seq_template_files(S);}
4887               else
4888                 {
4889                   S=display_seq_template_files (S);
4890                 }
4891
4892               //fLUSH OUT THE NAME OF ALL THE FILES THAT HAVE BEEN PRODUCED
4893
4894               le=display_output_filename (le, NULL, NULL, NULL, FLUSH);
4895
4896
4897               fprintf (le, "\n\n");
4898
4899               free_char (list_file, -1);
4900               free_Alignment (A);
4901               free_Alignment (EA);
4902
4903
4904               S=free_constraint_list (CL);
4905               free_sequence (S, S->nseq);
4906
4907
4908
4909               vremove ( "core");
4910
4911               vfree_all();
4912
4913               le=t_coffee_tip (le, tip);
4914               le=print_command_line ( le);
4915               //le=print_mem_usage (le, PROGRAM);
4916               //le=print_cpu_usage(le, PROGRAM);
4917               le=print_program_information (le, NULL);
4918
4919
4920               if (full_log && full_log[0])log_function(full_log);
4921
4922               return EXIT_SUCCESS;
4923         }
4924
4925 /*Specialized set of Parameters*/
4926 char *get_defaults (char *buf, char *type)
4927 {
4928   return NULL;
4929 }
4930 char *get_precomputed_defaults(char *buf, char *type)
4931    {
4932
4933      if (buf==NULL)buf=vcalloc (1000, sizeof (char));
4934
4935      buf=strcat (buf," -msa_mode=precomputed ");
4936      buf=strcat (buf," -seq_weight=no ");
4937      buf=strcat (buf," -evaluate_mode no ");
4938      buf=strcat (buf," -in Xpam250mt ");
4939      return buf;
4940    }
4941 char *get_evaluate_defaults(char *buf, char *type)
4942    {
4943
4944      if (buf==NULL)buf=vcalloc (1000, sizeof (char));
4945
4946      buf=strcat (buf," -quiet=stdout ");
4947      /*buf=strcat (buf," -seq_weight=no ");*/
4948      buf=strcat (buf," -output score_ascii html ");
4949      buf=strcat (buf," -iterate 0 ");
4950
4951      buf=strcat (buf," -evaluate ");
4952
4953
4954
4955      return buf;
4956    }
4957 char *get_genome_defaults(char *buf, char *type)
4958    {
4959
4960      if (buf==NULL)buf=vcalloc (1000, sizeof (char));
4961
4962      buf=strcat (buf," -seq_weight=no ");
4963      buf=strcat (buf," -dp_mode sim_pair_wise_lalign ");
4964      buf=strcat (buf," -output glalign ");
4965      buf=strcat (buf," -iterate 0 ");
4966      buf=strcat (buf," -distance_matrix_mode ktup ");
4967      buf=strcat (buf," -evaluate_mode t_coffee_slow ");
4968      buf=strcat (buf," -gapopen 100 -gapext 20 -nomatch 30 ");
4969      buf=strcat (buf," -clean_aln 0 ");
4970      buf=strcat (buf,"-output clustalw,score_ascii ");
4971
4972
4973      return buf;
4974    }
4975 char *get_dali_defaults(char *buf, char *type)
4976    {
4977
4978      if (buf==NULL)buf=vcalloc (1000, sizeof (char));
4979
4980      buf=strcat (buf,"-cosmetic_penalty=-50 ");
4981      buf=strcat (buf,"-distance_matrix_mode=slow ");
4982      buf=strcat (buf,"-output clustalw,score_ascii ");
4983      buf=strcat (buf,"-evaluate_mode=non_extended_t_coffee ");
4984      buf=strcat (buf,"-clean_aln 0 ");
4985
4986      return buf;
4987    }
4988
4989 char *get_very_fast_defaults(char *buf, char *type)
4990    {
4991
4992      if (buf==NULL)buf=vcalloc (1000, sizeof (char));
4993
4994      buf=strcat (buf,"-in Xblosum62mt ");
4995      buf=strcat (buf,"-distance_matrix_mode ktup ");
4996      buf=strcat (buf,"-maxnseq 10000 ");
4997      buf=strcat (buf,"-dpa_maxnseq 0 ");
4998      buf=strcat (buf,"-dp_mode fasta_pair_wise ");
4999      buf=strcat (buf,"-extend_mode matrix ");
5000      buf=strcat (buf,"-gapopen -10 ");
5001      buf=strcat (buf,"-gapext -1 ");
5002      buf=strcat (buf,"-iterate 0 ");
5003      /*buf=strcat (buf,"-in ");*/
5004
5005      return buf;
5006    }
5007
5008 char *get_low_memory_defaults(char *buf, char *type)
5009    {
5010      if (buf==NULL)buf=vcalloc (1000, sizeof (char));
5011
5012      if (NO_METHODS_IN_CL)buf=strcat (buf,"-distance_matrix_mode=idscore -method lalign_id_pair slow_pair -dp_mode=linked_pair_wise ");
5013      else buf=strcat (buf,"-distance_matrix_mode=idscore -dp_mode=linked_pair_wise ");
5014      return buf;
5015    }
5016 char *get_dna_defaults(char *buf, char *type)
5017 {
5018
5019   return buf;
5020 }
5021 char *get_cdna_defaults(char *buf, char *type)
5022 {
5023   buf=strcat (buf,"-distance_matrix_mode=idscore -dp_mode=fasta_cdna_pair_wise ");
5024   return buf;
5025 }
5026 char *get_3dcoffee_defaults(char *buf, char *type)
5027    {
5028      if (buf==NULL)buf=vcalloc (1000, sizeof (char));
5029
5030      buf=strcat (buf,"-in Msap_pair  -template_file SELF_P_ -profile_template_file SELF_P_");
5031      /*buf=strcat (buf,"-in ");*/
5032
5033      return buf;
5034    }
5035 char *get_expresso_defaults(char *buf, char *type)
5036    {
5037
5038      if (buf==NULL)buf=vcalloc (1000, sizeof (char));
5039
5040      buf=strcat (buf,"-method sap_pair  -template_file EXPRESSO -profile_template_file EXPRESSO");
5041
5042      /*buf=strcat (buf,"-in ");*/
5043
5044      return buf;
5045    }
5046 char *get_procoffee_defaults(char *buf, char *type)
5047    {
5048
5049      if (buf==NULL)buf=vcalloc (1000, sizeof (char));
5050
5051      buf=strcat (buf,"-in Mpromo_pair -extend_seq   ");
5052      /*buf=strcat (buf,"-in ");*/
5053
5054      return buf;
5055    }
5056 char *get_blastr_defaults(char *buf, char *type)
5057    {
5058
5059      if (buf==NULL)buf=vcalloc (1000, sizeof (char));
5060
5061      buf=strcat (buf,"-in Mblastr_pair -extend_seq   ");
5062      /*buf=strcat (buf,"-in ");*/
5063
5064      return buf;
5065    }
5066 char *get_psicoffee_defaults(char *buf, char *type)
5067    {
5068
5069      if (buf==NULL)buf=vcalloc (1000, sizeof (char));
5070
5071      buf=strcat (buf,"-in Mproba_pair -template_file BLAST   ");
5072      /*buf=strcat (buf,"-in ");*/
5073
5074      return buf;
5075    }
5076 char *get_accurate_defaults ( char *buf, char *type)
5077 {
5078
5079   if ( strm (type, "PROTEIN")) return get_accurate4PROTEIN_defaults(buf, type);
5080   else if ( strm (type, "DNA")) return get_accurate4DNA_defaults(buf, type);
5081   else if ( strm (type, "RNA")) return get_accurate4RNA_defaults(buf, type);
5082   else return get_defaults(buf, type);
5083 }
5084 char *get_accurate4PROTEIN_defaults(char *buf, char *type)
5085    {
5086      if (buf==NULL)buf=vcalloc (1000, sizeof (char));
5087      if (NO_METHODS_IN_CL)buf=strcat (buf,"-in Mbest_pair4prot -template_file BLAST -template_file EXPRESSO  ");
5088      else buf=strcat (buf,"-template_file BLAST -template_file EXPRESSO  ");
5089      buf=strcat (buf,"-output aln, expanded_fasta_aln ");
5090
5091      return buf;
5092    }
5093
5094
5095
5096
5097 char *get_accurate4DNA_defaults(char *buf, char *type)
5098 {
5099   return get_low_memory_defaults (buf,type);
5100 }
5101 char *get_accurate4RNA_defaults(char *buf, char *type)
5102 {
5103   return get_rcoffee_defaults (buf,type);
5104 }
5105 char *get_t_coffee_defaults(char *buf, char *type)
5106 {
5107   return buf;
5108 }
5109 char *get_fmcoffee_defaults(char *buf, char *type)
5110    {
5111      //Fast Mcoffee
5112      if (buf==NULL)buf=vcalloc (1000, sizeof (char));
5113
5114      if (NO_METHODS_IN_CL) buf=strcat (buf,"-in Mkalign_msa  Mmuscle_msa Mmafft_msa -multi_core methods_relax_msa");
5115
5116      /*buf=strcat (buf,"-in ");*/
5117
5118      return buf;
5119    }
5120
5121 char *get_mcoffee_defaults(char *buf, char *type)
5122    {
5123
5124      if (buf==NULL)buf=vcalloc (1000, sizeof (char));
5125
5126
5127      if (NO_METHODS_IN_CL)   buf=strcat (buf,"-in Mclustalw2_msa Mt_coffee_msa Mpoa_msa Mmuscle_msa Mmafft_msa Mdialignt_msa Mpcma_msa Mprobcons_msa -multi_core methods_relax_msa  ");
5128      /*buf=strcat (buf,"-in ");*/
5129      return buf;
5130    }
5131 char *get_dmcoffee_defaults(char *buf, char *type)
5132    {
5133
5134      if (buf==NULL)buf=vcalloc (1000, sizeof (char));
5135
5136      if (NO_METHODS_IN_CL)buf=strcat (buf,"-in Mkalign_msa Mt_coffee_msa Mpoa_msa Mmuscle_msa Mmafft_msa Mdialignt_msa Mprobcons_msa Mamap_msa -multi_core methods_relax_msa");
5137      /*buf=strcat (buf,"-in ");*/
5138
5139      return buf;
5140    }
5141 char *get_rcoffee_consan_defaults(char *buf, char *type)
5142    {
5143
5144      if (buf==NULL)buf=vcalloc (1000, sizeof (char));
5145
5146      check_program_is_installed (RNAPLFOLD_4_TCOFFEE,NULL, NULL,RNAPLFOLD_ADDRESS, INSTALL_OR_DIE);
5147          if (NO_METHODS_IN_CL)buf=strcat (buf,"-in Mconsan_pair -multi_core templates_relax_msa -dp_mode myers_miller_pair_wise -extend_mode rna2 -template_file RCOFFEE -transform dna2rna -type DNA -relax_lib 0");
5148      else buf=strcat (buf,"-dp_mode myers_miller_pair_wise -extend_mode rna2 -template_file RCOFFEE -transform dna2rna -type DNA -relax_lib 0");
5149      /*buf=strcat (buf,"-in ");*/
5150
5151      return buf;
5152    }
5153 char *get_rmcoffee_defaults(char *buf, char *type)
5154    {
5155
5156      if (buf==NULL)buf=vcalloc (1000, sizeof (char));
5157
5158      check_program_is_installed (RNAPLFOLD_4_TCOFFEE,NULL, NULL,RNAPLFOLD_ADDRESS, INSTALL_OR_DIE);
5159      if (NO_METHODS_IN_CL)buf=strcat (buf,"-in Mprobcons_msa Mmafft_msa Mmuscle_msa -extend_mode rna2 -template_file RCOFFEE -transform dna2rna -check_type -type DNA -relax_lib 0");
5160      else buf=strcat (buf,"-extend_mode rna2 -template_file RCOFFEE -transform dna2rna -check_type -type DNA -relax_lib 0");
5161      /*buf=strcat (buf,"-in ");*/
5162
5163      return buf;
5164    }
5165
5166 //    if (NO_METHODS_IN_CL)buf=strcat (buf,"-in Mbest_pair4prot -template_file BLAST -template_file EXPRESSO  ");
5167    char *get_best4RNA_defaults(char *buf, char *type)
5168    {
5169
5170            if (buf==NULL)buf=vcalloc (1000, sizeof (char));
5171
5172            check_program_is_installed (RNAPLFOLD_4_TCOFFEE,NULL, NULL,RNAPLFOLD_ADDRESS, INSTALL_OR_DIE);
5173            buf=strcat (buf," -extend_mode rna2 -template_file PDB,RNA -in Mbest_pair4rna -transform dna2rna -relax_lib 0");
5174            /*buf=strcat (buf,"-in ");*/
5175
5176            return buf;
5177    }
5178
5179 char *get_rcoffee_defaults(char *buf, char *type)
5180    {
5181
5182      if (buf==NULL)buf=vcalloc (1000, sizeof (char));
5183
5184      check_program_is_installed (RNAPLFOLD_4_TCOFFEE,NULL, NULL,RNAPLFOLD_ADDRESS, INSTALL_OR_DIE);
5185      buf=strcat (buf," -extend_mode rna2 -template_file RCOFFEE -transform dna2rna -check_type -type DNA -relax_lib 0");
5186      /*buf=strcat (buf,"-in ");*/
5187
5188      return buf;
5189    }
5190 char *get_genepredx_defaults(char *buf, char *type)
5191    {
5192
5193      if (buf==NULL)buf=vcalloc (1000, sizeof (char));
5194
5195      buf=strcat (buf, "-method tblastx_msa -evaluate_mode sequences  -genepred  -relax_lib 0 -output fasta_seq,exons,texons,wexons -seq_weight no -check_type -type DNA -out_lib");
5196      return buf;
5197    }
5198 char *get_genepredpx_defaults(char *buf, char *type)
5199    {
5200
5201      if (buf==NULL)buf=vcalloc (1000, sizeof (char));
5202
5203      buf=strcat (buf, "-method tblastpx_msa -evaluate_mode sequences  -genepred  -relax_lib 0 -output fasta_seq,exons,texons,wexons -seq_weight no -check_type -type DNA -out_lib");
5204      return buf;
5205    }
5206
5207 char *get_repeat_defaults(char *buf, char *type)
5208    {
5209
5210      if (buf==NULL)buf=vcalloc (1000, sizeof (char));
5211
5212      buf=strcat (buf,"-in slow_pair -matrix idmat -out_lib -profile_comparison profile -profile_mode channel_profile_profile -dp_mode myers_miller_pair_wise ");
5213      /*buf=strcat (buf,"-in ");*/
5214      return buf;
5215    }
5216
5217
5218 int check_configuration4program()
5219    {
5220      return 1;
5221
5222    }
5223
5224 /*Chose the right Mode for comparing residues*/
5225
5226 void test ()
5227 {
5228   char command[1000];
5229   char *c2;
5230
5231   c2=vcalloc ( 100, sizeof (char));
5232
5233   sprintf (command, "cat hmgt_mouseVsnrl3d.blast_result |blast_aln2fasta_aln.pl | fasta_aln2fasta_aln_unique_name.pl > my_test");
5234
5235   fprintf ( stderr, "C1: %d, C2:%d", is_dynamic_memory (c2), is_dynamic_memory (c2));
5236
5237
5238   myexit (0);
5239 }
5240
5241 int run_other_pg ( int argc, char *argv[])
5242 {
5243   //make minimum initialization
5244
5245
5246   if ( strm (argv[0], "seq_reformat") || strm (argv[0], "saltt"))
5247     {
5248       return seq_reformat (argc, argv);
5249     }
5250   else if ( strm (argv[0], "aln_compare"))
5251     {
5252       return aln_compare (argc, argv);
5253     }
5254   else if ( strm (argv[0], "analyse_pdb") || strm (argv[0], "apdb") || strm (argv[0], "irmsd") || strm (argv[0], "trmsd"))
5255     {
5256       return apdb ( argc, argv);
5257     }
5258   else if ( strm (argv[0], "quantile"))
5259     {
5260       return quantile ( argc, argv);
5261     }
5262   else if ( strstr ( argv[0], "unpack_"))
5263     {
5264       unpack_all_perl_script (argv[0]+strlen ("unpack_"));
5265     }
5266         else if ( strstr ( argv[0], "fastal"))
5267         {
5268                 return fastal_main(argc, argv);
5269         }
5270   else
5271     {
5272       return my_system_cl (argc, argv);
5273     }
5274   return EXIT_FAILURE;
5275 }
5276
5277 FILE * t_coffee_tip (FILE *fp,char *mode)
5278 {
5279   static char **tip;
5280   static int n;
5281   int a;
5282   if ( !tip)
5283     {
5284       tip=declare_char ( 100, 300);
5285       sprintf ( tip[n++],"Get the most accurate protein alignments with: t_coffee <yourseq> -special_mode accurate [Slow]\n");
5286       sprintf ( tip[n++],"Change the Width of your MSA with the environement variable ALN_LINE_LENGTH (all formats)");
5287       sprintf ( tip[n++],"Align 2 or more profiles with -profiles= aln1, aln2");
5288       sprintf ( tip[n++],"-special_mode=expresso to fetch your structures automatically");
5289       sprintf ( tip[n++],"-special_mode=psicoffee to expand your sequences");
5290       sprintf ( tip[n++],"-special_mode=accurate The best we can do [slow]");
5291
5292       sprintf ( tip[n++],"-special_mode=3dcoffee to combine sequences and structures");
5293       sprintf ( tip[n++],"-special_mode=mcoffee to combine alternative msa methods");
5294       sprintf ( tip[n++],"-special_mode=dmcoffee to combine alternative msa methods on debian");
5295
5296       sprintf ( tip[n++],"-usetree=<file> to use your own guide tree");
5297       sprintf ( tip[n++],"-infile=<aln> -special_mode=evaluate to evaluate your own alignment");
5298       sprintf ( tip[n++],"-other_pg seq_reformat to access seq_reformat");
5299       sprintf ( tip[n++],"-other_pg extract_from_pdb to use our pdb retriever");
5300       sprintf ( tip[n++],"All the latest versions on www.tcoffee.org");
5301       sprintf ( tip[n++],"-version to check for updates");
5302       sprintf ( tip[n++],"-output=html will produce a colored output");
5303       sprintf ( tip[n++],"-outorder=aligned will order the sequences according to the guide tree in newick");
5304       sprintf ( tip[n++],"-special_mode=quickaln will produce fast/low accuracy alignments");
5305       sprintf ( tip[n++],"-other_pg seq_reformat -in <aln> -action +trim %%50 Will reduce the redundancy of your MSA");
5306       sprintf ( tip[n++],"-tip=all to see all the tips, tip=no will prevent them all");
5307       sprintf ( tip[n++],"-other_pg unpack_all will unpack all the perl scripts within t_coffee");
5308     }
5309
5310   if ( strm (mode, "none"))return fp;
5311
5312   fprintf ( fp, "\n# TIP :See The Full Documentation on www.tcoffee.org\n");
5313
5314   if (strm ( mode, "all"))
5315     {
5316       for ( a=0; a< n; a++)
5317         {
5318           fprintf (fp, "# TIP %d: %s\n", a+1,tip[a]);
5319         }
5320     }
5321   else if ( strm ( mode, "one"))
5322     {
5323       int b;
5324       vsrand(0);
5325       b=(rand()%(n-1))+1;
5326       fprintf (fp, "# TIP %2s:  %s","1", tip[0]);
5327       fprintf (fp, "# TIP %2d:  %s\n", b+1, tip[b]);
5328
5329     }
5330
5331   fprintf ( fp, "\n");
5332   return fp;
5333 }
5334
5335
5336
5337 Sequence* prepare_master (char *seq, Sequence *S, Constraint_list *CL, char *dmode)
5338  {
5339    int a,b,s1, n, i;
5340    FILE *fp;
5341
5342    CL->master=vcalloc (S->nseq+1, sizeof(int));
5343
5344    if ( S->nseq==2 || strm (seq, "no") || strm (seq, "default"))
5345      {
5346        for (a=0; a<S->nseq; a++)CL->master[a]=1;
5347        return NULL;
5348      }
5349    else if ( check_file_exists (seq))
5350      {
5351        Sequence *L;
5352        L=main_read_seq (seq);
5353        for (a=0; a< L->nseq; a++)
5354          if ( (b=name_is_in_list (L->name[a], S->name,S->nseq, 100))!=-1)CL->master[b]=1;
5355      }
5356    else
5357      {
5358
5359        if ( strstr (seq, "_P_"))
5360          {
5361            for (a=0; a<S->nseq; a++)
5362              {
5363                if (seq_has_template (S, a, "_P_"))CL->master[a]=1;
5364              }
5365          }
5366        if ( is_number (seq) || strstr (seq, "_N_"))
5367          {
5368            int nseq;
5369            char **name;
5370            Alignment *A=NULL, *SA=NULL;
5371            if ( strstr (seq, "_N_")){nseq=atoi (strstr(seq, "_N_")+strlen ("_N_"));}
5372            else nseq=atoi (seq);
5373            if ( nseq<0)
5374              nseq=((float)S->nseq*((float)nseq/(float)100.0)*(float)-1);
5375
5376            nseq=MIN(nseq,S->nseq);
5377            if ( nseq>=S->nseq)
5378              {
5379                for (a=0; a<(CL->S)->nseq; a++)CL->master[a]=1;
5380              }
5381            else
5382              {
5383
5384                char tmode[1000];
5385                int **sim;
5386
5387                A=(strm (dmode, "msa"))?(very_fast_aln (seq2aln (S, NULL, RM_GAP), 0, NULL)):(seq2aln (S, NULL, RM_GAP));
5388                sim=(strm (dmode, "ktup") && CL->DM)?(CL->DM)->similarity_matrix:NULL;
5389
5390                sprintf (tmode, "_aln_n%d", nseq);
5391                SA=simple_trimseq (A, NULL, tmode, NULL, NULL);
5392                nseq=SA->nseq;
5393                name=SA->name;
5394                for (a=0; a<nseq;a++)
5395                  {
5396                    if (nseq==(CL->S)->nseq)CL->master[a]=1;
5397                    else if ((b=name_is_in_list (name[a], S->name,S->nseq, 100))!=-1)CL->master[b]=1;
5398                  }
5399                free_aln (A);
5400                free_aln (SA);
5401              }
5402          }
5403        if ( strstr (seq, "_LONG_"))
5404          {
5405            int ml=0;
5406            int ls=0;
5407            for (a=0; a< (CL->S)->nseq; a++)
5408              {
5409                int l=strlen ((CL->S)->seq[a]);
5410                if (l>ml){ml=l;ls=a;}
5411              }
5412            CL->master[ls]=1; //keep the longest seqquence
5413          }
5414      }
5415
5416
5417    fprintf ( CL->local_stderr, "\n");
5418    for (b=0,a=0; a<S->nseq; a++)
5419      {
5420        if ( CL->master[a])
5421          {
5422            fprintf (CL->local_stderr, "\tMaster_sequence: %s\n", S->name[a]);
5423            b++;
5424          }
5425      }
5426    if ( b==0)
5427      {
5428        printf_exit (EXIT_FAILURE, stderr, "ERROR: %s is neither a file nor a method nor a number for -master [FATAL:%s]\n",seq,PROGRAM);
5429      }
5430
5431    if (b!=(CL->S)->nseq)
5432      {
5433        Sequence *T, *MS;
5434        T=duplicate_sequence (CL->S);
5435        for(a=0; a<T->nseq; a++)
5436          {
5437            if (!CL->master[a]){vfree (T->seq[a]); T->seq[a]=NULL;}
5438          }
5439        MS=duplicate_sequence (T);
5440        free_sequence (T, -1);
5441        return MS;
5442      }
5443    else
5444      return CL->S;
5445  }
5446 int set_methods_limits (char ** method,int nl,char **list, int n, int *maxnseq, int *maxlen)
5447 {
5448   int a,ns, ml, nm=0;
5449   char string[1000];
5450
5451   nl/=3;
5452   for (a=0; a<nl; a+=3)
5453     {
5454
5455       sprintf ( string, "M%s", method[a]);
5456       if ( name_is_in_list (string,list, n, 100)!=-1)
5457         {
5458
5459           ns=atoi(method[a+1]);
5460           ml=atoi(method[a+2]);
5461
5462           if (ns!=-1 && (maxnseq[0]==-1 || maxnseq[0]>ns))maxnseq[0]=ns;
5463           if (ml!=-1 && (maxlen[0]==-1 || maxlen[0]>ml))maxlen[0]=ml;
5464           nm++;
5465         }
5466     }
5467   return nm;
5468 }
5469
5470
5471
5472 char * get_seq_type_from_cl (int argc, char **argv)
5473 {
5474   char *buf, *r;
5475   char file[100];
5476   int a;
5477   int seq=0;
5478
5479   sprintf (file, "%d.tmp", rand()%10000);
5480   buf=vcalloc ( 1000, sizeof (char));
5481   sprintf ( buf, "%s ", get_string_variable ("t_coffee"));
5482   for (a=1, seq=0; a<argc; a++)
5483     {
5484       if ( check_file_exists (argv[a]))seq=1;
5485     }
5486   if (!seq) return "";
5487
5488   for (a=1; a< argc; a++)
5489     {
5490       buf=strcat (buf, argv[a]);
5491       buf=strcat (buf, " ");
5492     }
5493
5494   buf=strcat (buf, " -type_only >");
5495   buf=strcat (buf, file);
5496
5497   my_system ( buf);
5498
5499   r=file2string (file);
5500   vremove (file);
5501   return r;
5502 }
5503 /******************************COPYRIGHT NOTICE*******************************/
5504 /*© Centro de Regulacio Genomica */
5505 /*and */
5506 /*Cedric Notredame */
5507 /*Fri Feb 18 08:27:45 CET 2011 - Revision 596. */
5508 /*All rights reserved.*/
5509 /*This file is part of T-COFFEE.*/
5510 /**/
5511 /*    T-COFFEE is free software; you can redistribute it and/or modify*/
5512 /*    it under the terms of the GNU General Public License as published by*/
5513 /*    the Free Software Foundation; either version 2 of the License, or*/
5514 /*    (at your option) any later version.*/
5515 /**/
5516 /*    T-COFFEE is distributed in the hope that it will be useful,*/
5517 /*    but WITHOUT ANY WARRANTY; without even the implied warranty of*/
5518 /*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the*/
5519 /*    GNU General Public License for more details.*/
5520 /**/
5521 /*    You should have received a copy of the GNU General Public License*/
5522 /*    along with Foobar; if not, write to the Free Software*/
5523 /*    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA*/
5524 /*...............................................                                                                                      |*/
5525 /*  If you need some more information*/
5526 /*  cedric.notredame@europe.com*/
5527 /*...............................................                                                                                                                                     |*/
5528 /**/
5529 /**/
5530 /*      */
5531 /******************************COPYRIGHT NOTICE*******************************/