--- /dev/null
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <stdarg.h>
+#include <string.h>
+#include <ctype.h>
+#include <time.h>
+#include "io_lib_header.h"
+#include "util_lib_header.h"
+#include "dp_lib_header.h"
+#include "define_header.h"
+#include "dev1_lib_header.h" //JM_STRAT
+
+#define ACTION(x) ((n_actions>=(x+1))?action_list[x]:NULL)
+#define ACTION2(x,y) ((n_actions>=(x+1))?action_list[x]:y)
+#define ATOI_ACTION(x) ((ACTION(x)!=NULL)?(atoi(ACTION(x))):0)
+
+/**************************************************************************************************/
+/***************************** SEQ_REFORMAT ******************************************/
+/**************************************************************************************************/
+int output_transitions(char *outfile, Alignment *A);
+static int output_age_matrix ( char *outfile, int val);
+int SeqGCGCheckSum(char *seq, int len);
+static Sequence *seq2year ( Sequence *S, int modulo);
+static Sequence* output_n_pavie_age_channel (Sequence *S, char *name, int n);
+static Sequence* output_pavie_age_channel (Sequence *S, char *name, int modulo);
+
+static int output_seq2struc(char *outfile, Alignment *A);
+void output_conservation_statistics ( char *file, Alignment *A);
+/**************************************************************************************************/
+/***************************** SEQ_REFORMAT ******************************************/
+/**************************************************************************************************/
+int seq_reformat ( int argc, char **in_argv)
+ {
+
+ Sequence_data_struc *D1=NULL;
+ Sequence_data_struc *D2=NULL;
+ Sequence_data_struc *D_ST=NULL;
+ Action_data_struc *RAD;
+
+
+
+ int a, b;
+
+ char *in_format;
+ char *in2_format;
+ char *out_format;
+ char *in_file;
+ char *in2_file;
+ char *out_file;
+ char *out2_file;
+ char *struc_in_format;
+ char *struc_out_format;
+ char *struc_in_file;
+ char *struc_out_file;
+ char**action_list;
+ char **action;
+ char *rename_file;
+ char *cache;
+ char ***rename_list=NULL;
+ int code=CODE;
+ char **argv;
+
+ int n_actions=0;
+ int print_format=0;
+ /*INITIALIZATIONS*/
+
+ RAD=vcalloc ( 1, sizeof ( Action_data_struc));
+ RAD->keep_case=1;
+ declare_name (cache);sprintf ( cache, "use");
+ declare_name(in_file);
+ declare_name(in2_file);
+ declare_name(out_file);
+ declare_name(out2_file);
+ declare_name(struc_in_format);
+ declare_name(struc_out_format);
+ declare_name(RAD->coor_file);
+
+ declare_name(struc_in_file);
+ declare_name(struc_out_file);
+ declare_name(in_format);
+ declare_name(in2_format);
+ declare_name(out_format);
+ declare_name(rename_file);
+
+
+ argv=break_list ( in_argv, &argc, "=;, \n");
+
+ action_list=declare_char ( 100, 100);
+
+/*END INITIALIZATION*/
+
+ addrandinit ( (unsigned long) 500);
+
+ if ( argc==1 || strm6 ( argv[1], "h", "-h", "help", "-help", "-man", "?"))
+ {
+
+ fprintf ( stdout, "\n%s (%s,%s,%s [%s])\n",PROGRAM, VERSION,AUTHOR, DATE, URL);
+ fprintf ( stdout, "\n*********** MINIMUM SYNTAX *****************");
+ fprintf ( stdout, "\nseq_reformat -in <in_file> -output <out_format>");
+ fprintf ( stdout, "\nSome File formats are automatically recognised");
+ fprintf ( stdout, "\nSee Format section");
+ fprintf ( stdout, "\n");
+ fprintf ( stdout, "\n*********** MAIN FLAGS ******************");
+ fprintf ( stdout, "\n-in name........Name of the file read");
+
+
+ fprintf ( stdout, "\n-input format......Name of the format read, see Input Format Section");
+ fprintf ( stdout, "\n...................Automatic detection, except for seqs of numbers");
+ fprintf ( stdout, "\n...................-input number_aln | number_fasta");
+ fprintf ( stdout, "\n-in2 fname......Second alignment");
+ fprintf ( stdout, "\n-input2 format.....See -input");
+ fprintf ( stdout, "\n-exon_boundaries obj file");
+ fprintf ( stdout, "\n-out fname......Output file (defualt is STDOUT");
+ fprintf ( stdout, "\n-output format.....Output Format, default is fasta_aln");
+ fprintf ( stdout, "\n-struc_in name...File containing a coded aln");
+ fprintf ( stdout, "\n-struc_in_f format.See -input and output format section");
+ fprintf ( stdout, "\n-struc_out fname..Name of the output structure");
+ fprintf ( stdout, "\n-struc_out_f symbol");
+ fprintf ( stdout, "\n-keep_case=on|off..keep case, On by default");
+ fprintf ( stdout, "\n-action +ac1 +ac2..See the action section");
+ fprintf ( stdout, "\n-rename <file>.....Rename the sequences following <file> indications");
+ fprintf ( stdout, "\n...................File Format: One couple <name1><space><name2>/line");
+ fprintf ( stdout, "\n...................Rename order <name1> into <name2>");
+ fprintf ( stdout, "\n...................code file: -output code_name");
+ fprintf ( stdout, "\n-code <file> Rename file <name1> to <name2>");
+ fprintf ( stdout, "\n-decode <file> Rename file <name2> to <name1>");
+ fprintf ( stdout, "\n-no_warning........Suppresses all warnings");
+ fprintf ( stdout, "\n-cache.............use,ignore,update,local, DirectoryName");
+
+
+ fprintf ( stdout, "\n");
+
+ fprintf ( stdout, "\n*********** REFORMAT ACTIONS *****************");
+ fprintf ( stdout, "\n +Xaction.............Specifies which file undergoes the action");
+ fprintf ( stdout, "\n +Xaction.............X=1: -in");
+ fprintf ( stdout, "\n +Xaction.............X=2: -in2");
+ fprintf ( stdout, "\n +Xaction.............X=3: -struc_in");
+ fprintf ( stdout, "\n +name2unique_name....replace duplicated name with name_#");
+ fprintf ( stdout, "\n +swap_header........,swapp comments: replace comments/name in 1 by in 2");
+ fprintf ( stdout, "\n +swap_lib_header.F...Replace the sequences in the tc_lib (-in) with those in F");
+ fprintf ( stdout, "\n .....................F is a legal FASTA file");
+
+
+ fprintf ( stdout, "\n +translate[0-2]......Translate on Frame 0, 1, 2 ");
+ fprintf ( stdout, "\n +translate[3]........longuest ORF on direct strand");
+ fprintf ( stdout, "\n +translate[4]........longuest ORF on direct+complementary strand");
+
+
+ fprintf ( stdout, "\n +add_scale..<offset>.addscale below aln");
+
+ fprintf ( stdout, "\n +rm_gap n ...........Removes col with n%% gap [n=100]");
+ fprintf ( stdout, "\n +rmgap_col SEQ1:SEQ2.Removes column with a gap in SEQ [#] ");
+
+ fprintf ( stdout, "\n +backtranslate.......Random Backtranslation");
+ fprintf ( stdout, "\n +complement..........Produces the reverse complement");
+
+ fprintf ( stdout, "\n +reorder.............Reorders sequences of <in> according to <in2>");
+ fprintf ( stdout, "\n .........random......Random_order");
+ fprintf ( stdout, "\n .........tree........Tree Order (in2)");
+ fprintf ( stdout, "\n +reorder_column.....Reorders sequences of <in> according to <in2>");
+ fprintf ( stdout, "\n .........random......Random_order");
+ fprintf ( stdout, "\n .........tree..mode..Tree Order (comuted with mode: sarmat, idmat, blosum62mt...");
+ fprintf ( stdout, "\n +aln2random_aln SCR..Randomize the aln, S: swap sequences names");
+ fprintf ( stdout, "\n .....................Swap residues within colums");
+ fprintf ( stdout, "\n .....................Swap residues across the aln");
+ fprintf ( stdout, "\n +aln2sample......N......");
+ fprintf ( stdout, "\n +aln2bootstrap...N......");
+
+
+ fprintf ( stdout, "\n +chain...............Identifies all the intermediate sequences from <-in>");
+ fprintf ( stdout, "\n .....................needed to join every sequence pair in <-in2>");
+
+ fprintf ( stdout, "\n +aln2cons mat_name..Ouputs a consensus sequence");
+ fprintf ( stdout, "\n .....................The consensus is determined using mat");
+ fprintf ( stdout, "\n .....................By Default, mat=blosum62mt, name=Cons");
+ fprintf ( stdout, "\n +aln2resindex........Prints the sequence index of each residue in -in for each -in2 sequence");
+ fprintf ( stdout, "\n +collapse_aln <new name> <seq1> <seq2...> | file name");
+ fprintf ( stdout, "\n .....................Replaces a group of sequences with its consensus");
+ fprintf ( stdout, "\n .....................The replacement sequence is named <new_seq>");
+ fprintf ( stdout, "\n .....................List of sequences can be provided via a file");
+ fprintf ( stdout, "\n .....................File:>new_name seq1 seq2 seq3....");
+ fprintf ( stdout, "\n +original_seqnos.....Keep original seqnos [SWITCH]");
+ fprintf ( stdout, "\n +seqnos..............Print Seqnos [SWITCH]");
+ fprintf ( stdout, "\n +code_dna_aln........Undocumented") ;
+ fprintf ( stdout, "\n +grep..[NAME|SEQ|COMMENT]..[KEEP|REMOVE]..[string]......");
+ fprintf ( stdout, "\n .....................Keeps or Removes Sequences matching string");
+ fprintf ( stdout, "\n +extract_block <seq> <start> <end> | <seq> <pos> |<filename>");
+ fprintf ( stdout, "\n .....................Extract column pos OR [start to end[");
+ fprintf ( stdout, "\n .....................<filename> Format");
+ fprintf ( stdout, "\n .......................seq start end | seq pos");
+ fprintf ( stdout, "\n .......................# for comments");
+ fprintf ( stdout, "\n .......................! seq offset_value (0 by default)");
+ fprintf ( stdout, "\n .....................Can extract as many positions as needed");
+ fprintf ( stdout, "\n .....................seq=cons: measure positions on the full aln");
+ fprintf ( stdout, "\n +cat_aln.............Concatenates the alignments input via -in and -in2");
+ fprintf ( stdout, "\n +cat_aln.............-if no -in2, -in is expected to be a list of alignments to concatenate");
+ fprintf ( stdout, "\n +orthologous_cat..<mode>: mode=voronoi or nothing");
+ fprintf ( stdout, "\n ......................-in: sequences from different species");
+ fprintf ( stdout, "\n ..................... -in2: list of species in fasta");
+ fprintf ( stdout, "\n ..................... sequence must be named: <species>_<genename>");
+ fprintf ( stdout, "\n ..................... all paralogues will be concatenated");
+
+ fprintf ( stdout, "\n +aln2replicate N name");
+ fprintf ( stdout, "\n ..................... Generates N replicates in Fasta");
+ fprintf ( stdout, "\n ..................... Voronoi weights can be used");
+
+ fprintf ( stdout, "\n +msalist2cat_pwaln.min..max");
+ fprintf ( stdout, "\n .....................extract all pw projections and conctaenates those\n");
+ fprintf ( stdout, "\n .....................where id>=min and id<=max\n");
+ fprintf ( stdout, "\n .....................min and max can be omitted (min=0, max=100)\n");
+
+ fprintf ( stdout, "\n +seq2blast <matrix>..gather all possible homologues from NR (EBI BLAST)");
+ fprintf ( stdout, "\n +seq2msa <matrix>....makes a standard progressive alignment using matrix");
+ fprintf ( stdout, "\n +realign_block <c1> <c2> <pg>");
+ fprintf ( stdout, "\n .....................Realign column c1 to c2 (non inc.) with pg)");
+ fprintf ( stdout, "\n .....................pg reads fasta and outputs fasta");
+ fprintf ( stdout, "\n .....................pg -infile=<infile> -outfile=<outfile>");
+ fprintf ( stdout, "\n +extract_seq seq_name (start end seq_name start end...) | filename");
+ fprintf ( stdout, "\n .....................seq_name='*': every seq");
+ fprintf ( stdout, "\n .....................start='*' : real start");
+ fprintf ( stdout, "\n .....................end='*' : real end");
+ fprintf ( stdout, "\n .....................filename: fasta format");
+ fprintf ( stdout, "\n +extract_seq_list name1 name2");
+ fprintf ( stdout, "\n .....................Extracts entire sequences");
+ fprintf ( stdout, "\n +remove_seq sn1 sn2..Removes sequences sn1, sn2...");
+ fprintf ( stdout, "\n +remove_seq empty....Removes empty sequences (gap only)");
+ fprintf ( stdout, "\n +remove_seq unique...Remove all multiple occurences except the first");
+ fprintf ( stdout, "\n +thread_profile_on_msa <file>");
+ fprintf ( stdout, "\n .....................Threads a list of profiles on corresponding seq");
+ fprintf ( stdout, "\n .....................File: >seqname _R_ <msa file> [nlines]");
+
+ fprintf ( stdout, "\n +thread_dna_on_prot_aln");
+ fprintf ( stdout, "\n .....................-in DNA.seq and -in2 AA.aln");
+ fprintf ( stdout, "\n +thread_struc_on_aln");
+ fprintf ( stdout, "\n .....................-in structure and -in2 aln");
+ fprintf ( stdout, "\n +use_cons............Use the consensus for n[SWITCH]");
+ fprintf ( stdout, "\n +upper.n|[n1-n2].....n omitted sets everything to upper case");
+ fprintf ( stdout, "\n .....................To use n: provide a number_aln via:");
+ fprintf ( stdout, "\n .....................-struc_in <number_file> -struc_in_f number_aln");
+ fprintf ( stdout, "\n .....................if use_cons is set n, is read on the cons");
+ fprintf ( stdout, "\n .....................n: will upper every residue with a value of n in struc_in");
+ fprintf ( stdout, "\n .....................[n1-n2]: upper residues between n1 and n2");
+ fprintf ( stdout, "\n +lower n|[n1-n2]....See +upper");
+ fprintf ( stdout, "\n +switchcase n|[n1-n2]See +upper");
+ fprintf ( stdout, "\n +color_residue <seq> <pos> <color> | file");
+ fprintf ( stdout, "\n .....................File: seq_name pos color");
+ fprintf ( stdout, "\n .....................color: 0-9");
+ fprintf ( stdout, "\n +edit_residue <seq> <pos> <edit> | file");
+ fprintf ( stdout, "\n .....................File: seq_name pos color");
+ fprintf ( stdout, "\n .....................edit: upper|lower|symbol");
+
+
+
+ fprintf ( stdout, "\n +keep n|[n1-n2]....Only keep residues that have a score between n1 and n2");
+
+ fprintf ( stdout, "\n +invert..............Inverts the sequences: CAT => TAC");
+ fprintf ( stdout, "\n +rotate name Rotate an MSA, names each sequence name_col#");
+ fprintf ( stdout, "\n +convert n|[n1-n2] s1 s2 ....");
+ fprintf ( stdout, "\n +merge_annotation.... ");
+
+ fprintf ( stdout, "\n .....................Converts residues with your alignment");
+ fprintf ( stdout, "\n .....................similar to upper");
+ fprintf ( stdout, "\n .....................s1: ABCDe turns every ABCD into e");
+ fprintf ( stdout, "\n .....................s1: #e turns any residue into e");
+ fprintf ( stdout, "\n aln2short_aln L C S..Turns sequences into shorter sequences");
+ fprintf ( stdout, "\n .....................L: list of residues to keep");
+ fprintf ( stdout, "\n .....................S: Size of Streches replaced by symbol C");
+
+
+ fprintf ( stdout, "\n +random n l..........Generates N random sequences of len l");
+ fprintf ( stdout, "\n .....................You must provide a file with -in");
+ fprintf ( stdout, "\n +count n|[n1-n2] s1 s2....");
+ fprintf ( stdout, "\n .....................Counts residues with your alignment");
+ fprintf ( stdout, "\n .....................similar to convert");
+ fprintf ( stdout, "\n +print_format........prints the format name");
+ fprintf ( stdout, "\n +keep_name...........Keep the original sequence name on extraction");
+
+ fprintf ( stdout, "\n +remove_aa pos Ml Ncycle Random_len");
+ fprintf ( stdout, "\n .....................Randomly modifies an alignment");
+ fprintf ( stdout, "\n .....................pos=0: chosen randomly");
+ fprintf ( stdout, "\n .....................MaxLen of the deletions, Ncycle: number of cycles");
+ fprintf ( stdout, "\n .....................Random_len: 0 sets the len to maxlen, 1 to a random value");
+ fprintf ( stdout, "\n +remove_nuc.x........Remove Position 1, 2 or 3 of every codon");
+ fprintf ( stdout, "\n +evaluate matrix..gop..gep");
+ fprintf ( stdout, "\n .....................Make a similarity evaluation with matrix");
+ fprintf ( stdout, "\n .....................use -output=score_ascii, or score_html.");
+ fprintf ( stdout, "\n .....................You can filter on the values");
+ fprintf ( stdout, "\n +evaluate matrix..gop..gep");
+ fprintf ( stdout, "\n .....................Make an SP evaluation with matrix");
+ fprintf ( stdout, "\n .....................Uses Natural Gap penalties");
+ fprintf ( stdout, "\n .....................gop and gep must be negative");
+ fprintf ( stdout, "\n .....................use -output=color_ascii, color_html to get a color display");
+
+ fprintf ( stdout, "\n.....+evaluate_lat........Make a lateral evaluation with matrix");
+ fprintf ( stdout, "\n +msa_weight proc.....Computes weights using the procedure");
+ fprintf ( stdout, "\nRNA analysis Post Processing___________________________________________________");
+ fprintf ( stdout, "\n +aln2alifold.........Turns the MSA into a consensus structure");
+ fprintf ( stdout, "\n +add_alifold.........adds an alifold consensus structure");
+
+ fprintf ( stdout, "\n +alifold2analyze.mode..mode=stat_cache_list_aln_color_html_ps_usegap");
+ fprintf ( stdout, "\n .......................stat: compile Number of compensated mutations");
+ fprintf ( stdout, "\n .......................cache: ascii-code compensated mutations on aln");
+ fprintf ( stdout, "\n .......................html: color-code compensated mutations on aln");
+ fprintf ( stdout, "\n .......................aln: mark compensated mutations on stockholm aln");
+ fprintf ( stdout, "\n .......................usegap: do not ignore positions with gaps");
+
+ fprintf ( stdout, "\n +RNAfold_cmp.........compares the sec struc of in1 and in2 (computes them with alifold if missing)");
+
+ fprintf ( stdout, "\nMSA Post Processing___________________________________________________");
+ fprintf ( stdout, "\n +force_aln filename|seq1 res1 seq2 res2");
+ fprintf ( stdout, "\n .....................Forces residue 1 of seq1 to be aligned with res2 of seq 2");
+ fprintf ( stdout, "\n .....................In a file, there must be one pair of interaction/line");
+ fprintf ( stdout, "\n +sim_filter[_aln_Ix_iy_Cz_cw <seq>");
+ fprintf ( stdout, "\n ....................._<unaln or aln>, aln is assumed");
+ fprintf ( stdout, "\n ....................._I max identity to seq");
+ fprintf ( stdout, "\n ....................._i min identity to seq");
+ fprintf ( stdout, "\n ....................._C max cov on seq");
+ fprintf ( stdout, "\n ....................._c min cov on seq");
+ fprintf ( stdout, "\n +trim[_aln_%%%%50_n111_N50_T_Fn_fS_pS_max_sim_P0_K0] [string2]");
+ fprintf ( stdout, "\n ....................._<seq or aln>, aln is assumed");
+ fprintf ( stdout, "\n ....................._%%%%<max/min_percent_similarity>");
+ fprintf ( stdout, "\n ....................._max Or _min <keep sequences for which sim is the max or the min [Def: _max>");
+ fprintf ( stdout, "\n ....................._cov Or _sim Filter according to the coverage [Def: _sim]");
+ fprintf ( stdout, "\n ....................._n<max_number_of_sequence> ");
+ fprintf ( stdout, "\n ....................._N<percent_of_sequences_to_keep>");
+ fprintf ( stdout, "\n ....................._T Reorder the sequences according to a tree BEFORE triming");
+ fprintf ( stdout, "\n ....................._Fn Keep only sequences that have AT LEAST ONE residue aligned");
+ fprintf ( stdout, "\n ......................in the n first and n last columns. ");
+ fprintf ( stdout, "\n ....................._O<min sim> Remove outlayers that have less than min average sim with other sequences");
+ fprintf ( stdout, "\n ....................._Kn Forces the n top sequences to be kept");
+ fprintf ( stdout, "\n ....................._P_ Print a summary in stderr");
+
+
+ fprintf ( stdout, "\n .....................Keeping Sequences: Sequences provided via -in2 will be kept");
+
+ fprintf ( stdout, "\n .....................Keeping Sequences: Sequences whose name contains <string> in field fS will be kept");
+ fprintf ( stdout, "\n ....................._f<NAME|SEQ|COMMENT> designates a field");
+ fprintf ( stdout, "\n .....................<string> is a Perl regular expression");
+ fprintf ( stdout, "\n +aln2unalign Mode Penalty Threshold");
+ fprintf ( stdout, "\n .....................Identifies all the streches less conserved than than the average");
+ fprintf ( stdout, "\n .....................Mode: lower|number|unalign Act on all the resiues withs score<Thres");
+ fprintf ( stdout, "\n .....................Penalty: FSA penalty align2unalign, Def=90");
+ fprintf ( stdout, "\n .....................Threshold: Fraction of unaligned residues(0-9) Def=2");
+
+ fprintf ( stdout, "\n +clean_cdna..........Undocumented");
+ fprintf ( stdout, "\n +clean_maln..........Undocumented");
+ fprintf ( stdout, "\nTree Analysis___________________________________________________");
+
+
+ fprintf ( stdout, "\n +tree_prune..........Prune the tree -in using the sequences provided via -in2");
+ fprintf ( stdout, "\n +tree_cmp............Compares the tree -in and the tree -in2");
+ fprintf ( stdout, "\n +tree_cmp_list......Compares the tree -in and the tree_list -in2");
+ fprintf ( stdout, "\n .....................Sets the support as boostrap value in the -in tree");
+
+ fprintf ( stdout, "\n .....................-in and -in2 can contain different taxons");
+ fprintf ( stdout, "\n +tree_scan.P1..P2.....scans alignment <-in> with tree <-in2>)");
+ fprintf ( stdout, "\n ......................+tree_scan help to get P1 information");
+ fprintf ( stdout, "\n ......................+aln2tree help to get P2 information");
+
+ fprintf ( stdout, "\n .....................-in and -in2 can contain different taxons");
+ fprintf ( stdout, "\n +tree2node.......... Reports the node list along with the split");
+ fprintf ( stdout, "\n ..................... splits can be described with the seq order ");
+ fprintf ( stdout, "\n ..................... provided via -in3=<sequence> ");
+
+ fprintf ( stdout, "\n +treelist2groups.N....count all topologies within a list of trees");
+ fprintf ( stdout, "\n .....................-in is in fasta format with each name being a newick file");
+ fprintf ( stdout, "\n .....................-in2 can be a list of sequences used to trim the trees");
+ fprintf ( stdout, "\n ......................N can be used to unresolve the trees with Depth N");
+ fprintf ( stdout, "\n +treelist2lti.N.C.....Reports the average stability of each sequence neighborhood");
+ fprintf ( stdout, "\n ......................Species can be selected via -in2 [Fasta file with Taxon names]");
+ fprintf ( stdout, "\n ......................OR the sequences observed in C%% of the files are kept [Def: C=100]");
+
+
+ fprintf ( stdout, "\n +treelist2seq.C.......Reports the species observed in C%% of the trees");
+ fprintf ( stdout, "\n +treelist2splits......List and counts all the splits in a list of trees");
+ fprintf ( stdout, "\n ......................splits can be restricted to a list of sequences provided via -in2");
+ fprintf ( stdout, "\n +treelist2dmat.......outputs a distance matrix for a list of trees");
+
+ fprintf ( stdout, "\n +tree_compute n s....Computes a tree using the MSA provided with -in");
+ fprintf ( stdout, "\n ....................n:0-9, controls the way the MSA is filtered");
+ fprintf ( stdout, "\n ....................s:pam250mt|blosum62mt|categories|enthropy");
+ fprintf ( stdout, "\n ....................s:controls the column evaluation in MSA");
+ fprintf ( stdout, "\n +change_distances.f.f:float, sets all the distances to f in the tree");
+ fprintf ( stdout, "\n +change_bootstrap n..:n=0 removes all the bootstrap values");
+ fprintf ( stdout, "\n .....................:n!=0 adds a the value n to every node");
+ fprintf ( stdout, "\n +tree2dpatree........Replaces tree distances with the minimum %%ID in");
+ fprintf ( stdout, "\n .....................the depending subgroup. The ID is measured on an");
+ fprintf ( stdout, "\n .....................-in=TREE -in2=ALN");
+ fprintf ( stdout, "\n +unroot..............Removes the root in the input tree");
+ fprintf ( stdout, "\n +tree2group.N.I.P....Reports all the tree subgroup with at most Nseq");
+ fprintf ( stdout, "\n .....................and at min I%% identity. Output format can be read by");
+ fprintf ( stdout, "\n .....................collapse_tree. New groups are named P_1, P_2...");
+ fprintf ( stdout, "\n +collapse_tree.F.....Collapses trees. F is either a file or a list");
+ fprintf ( stdout, "\n .....................<new name> <seq1> <seq2>...");
+ fprintf ( stdout, "\n +aln2tree............Computes a tree");
+ fprintf ( stdout, "\n ..ktupN|aln|sarmat ktupN: match size N to estimate distances");
+ fprintf ( stdout, "\n .....................aln: Measures distances on aln");
+ fprintf ( stdout, "\n .....................sarmat: expects in to be a SAR matrix of O and I");
+ fprintf ( stdout, "\n ..nj | cw............Runs Neighbor Joining OR Cw to compute Tree");
+ fprintf ( stdout, "\n ..dpa................Turns the tree into a daptree (+tree2dpatree)");
+ fprintf ( stdout, "\n +node_sort..<name>...Sort leafs of tree n1, by node distance");
+
+
+ fprintf ( stdout, "\nMatrix Analysis___________________________________________________");
+ fprintf ( stdout, "\n +aln2mat_diaa........computes a dinucleotide matrix on a list of aln");
+ fprintf ( stdout, "\n +aln2mat.............computes a log odd matrix");
+
+ fprintf ( stdout, "\n +seq2lat_mat.........computes a transition matrix on seq provided via -in");
+
+ fprintf ( stdout, "\nStructure Analysis___________________________________________________");
+ fprintf ( stdout, "\n +struc2contacts.A.B D.Displays in capitals all the residues of A");
+ fprintf ( stdout, "\n ......................Less than D Angs from a residue of B");
+ fprintf ( stdout, "\n ......................A and B are pdb file, D is a distance in Angs");
+ fprintf ( stdout, "\n +seq2contacts.A.D.....Identifies all the residues in contact with ligands");
+ fprintf ( stdout, "\n ......................Ligands are in the FASTA header of struc in");
+ fprintf ( stdout, "\n ......................>Name _S_ [Target Struc] [Ligand1] [Chain] ...");
+ fprintf ( stdout, "\n ......................Output: number_fasta: 0=no contact, 1=ligand 1...");
+ fprintf ( stdout, "\n ......................9: residues in contact with more than 1 ligand");
+ fprintf ( stdout, "\n ......................Use -output=color_html/ascii to display result");
+ fprintf ( stdout, "\n +struc2nb...D.........Display a list of all the residues D appart");
+ fprintf ( stdout, "\n +rm_template...V......Removes _[S|G|R]_[template] to sequence names");
+ fprintf ( stdout, "\n ......................V: omitted | sequences <=> Output sequences");
+ fprintf ( stdout, "\n ......................V: template <=> Output templates");
+
+ fprintf ( stdout, "\n +add_template.F.......Add _[S|G|R]_[template] to sequence names");
+ fprintf ( stdout, "\n ......................F can either be a fasta file or an executable");
+ fprintf ( stdout, "\n ......................F: File: >name _S_ template");
+ fprintf ( stdout, "\n ......................F: executable: pg -infile=<seq> -outfile=<tagged>");
+ fprintf ( stdout, "\nMatrix Comparison___________________________________________________");
+ fprintf ( stdout, "\n +mat2cmp...............Returns the correlation coefficient between two matrices");
+ fprintf ( stdout, "\n .......................-in mat1 -input matrix, -in2 mat2 -input2 matrix");
+ fprintf ( stdout, "\n*********** INPUT FORMATS: Alignments *****************");
+ fprintf ( stdout, "\n AUTOMATIC RECOGNITION");
+ fprintf ( stdout, "\n perl_xxx:............. runs xxx onto the input file");
+ fprintf ( stdout, "\n xxxx <file> > outfile..xxx reads any formats, outputs fasta");
+ fprintf ( stdout, "\n amps_aln saga_aln ");
+ fprintf ( stdout, "\n clustal_aln fasta_aln msf_aln ");
+ fprintf ( stdout, "\n dali_aln gotoh_aln pima_aln");
+ fprintf ( stdout, "\n dialign_aln matrix conc_aln");
+ fprintf ( stdout, "\n NON AUTOMATIC RECOGNITION (use the -input file to specify the format");
+ fprintf ( stdout, "\n number_aln newick_tree");
+ fprintf ( stdout, "\n");
+ fprintf ( stdout, "\n*********** INPUT FORMATS: Sequences *****************");
+ fprintf ( stdout, "\n fasta_seq dali_seq pir_seq");
+ fprintf ( stdout, "\n barton_list_tc amps_sd_scores EST_fasta");
+ fprintf ( stdout, "\n gor_seq gor_struc number_fasta[*]");
+ fprintf ( stdout, "\n swissprot tc_lib pdb_struc");
+ fprintf ( stdout, "\n");
+ fprintf ( stdout, "\n*********** INPUT FORMATS: Structures *****************");
+ fprintf ( stdout, "\n rna_number");
+ fprintf ( stdout, "\n alifold");
+ fprintf ( stdout, "\n*********** OUTPUT FORMATS: Alignments ******************");
+ fprintf ( stdout, "\n compressed_aln saga_aln clustal_aln");
+ fprintf ( stdout, "\n phylip_aln msf_aln fasta_aln ");
+ fprintf ( stdout, "\n pir_aln ");
+ fprintf ( stdout, "\n color_html,color_ps......colored using the struc_in file ");
+ fprintf ( stdout, "\n color_protogene..........colors codons");
+ fprintf ( stdout, "\n color_exoset.............mixes conservation (gray) and introns (RGB)");
+ fprintf ( stdout, "\n color_pdf pw_lib_saga_aln tdna_aln");
+ fprintf ( stdout, "\n thread_dna_on_prot_aln");
+ fprintf ( stdout, "\n");
+ fprintf ( stdout, "\n*********** OUTPUT FORMATS: sequence ******************");
+ fprintf ( stdout, "\n fasta_seq fasta_seq1 gotoh_seq");
+ fprintf ( stdout, "\n gor_seq cache_id");
+ fprintf ( stdout, "\n tblastx_db1 tblastx_db2 tblastx_db3");
+ fprintf ( stdout, "\n*********** OUTPUT FORMATS: weights ******************");
+ fprintf ( stdout, "\n constraints saga_pw_sd_weights nseq\n");
+ fprintf ( stdout, "\n");
+ fprintf ( stdout, "\n*********** OUTPUT Formats: special ****************");
+ fprintf ( stdout, "\n len name statistics<_hnrglNL>");
+ fprintf ( stdout, "\n sim............outputs a similarity matrix based on an id comparison of -in");
+ fprintf ( stdout, "\n sim_sarmat.....in is sar matrix");
+ fprintf ( stdout, "\n sim_idscore....makes dp alignment of the sequences using Blosum62mt");
+ fprintf ( stdout, "\n sim_idscoreDNA.makes dp alignment of the sequences using idmat");
+ fprintf ( stdout, "\n sim............if -in2 is set: in1 vs in2, idscore");
+
+ fprintf ( stdout, "\n code_name......Outputs a compact list of names for code/decode");
+
+
+
+ fprintf ( stdout, "\n");
+
+
+ fprintf ( stdout, "\n");
+ return EXIT_SUCCESS;
+ }
+
+ argv=standard_initialisation (argv, &argc);
+
+
+ for ( a=1; a< argc; a++)
+ {
+ if (a==1 && argv[1][0]!='-')
+ {
+ sprintf( in_file, "%s", argv[a]);
+ }
+ else if ( strcmp ( argv[a], "-in_f")==0 ||strm(argv[a],"-input") )
+ {
+ if ( strcmp ( argv[a], "-in_f")==0) fprintf ( stdout,"\nWARNING: %s deprecated, use -input instead", argv[a]);
+
+ sprintf ( in_format, "%s", argv[a+1]);
+ a++;
+ }
+
+ else if ( strcmp ( argv[a], "-cache")==0 )
+ {
+ sprintf (cache, "%s", argv[a+1]);
+
+ a++;
+ }
+
+
+ else if ( strcmp ( argv[a], "-exon_boundaries")==0 )
+ {
+
+ set_string_variable ("exon_boundaries", argv[a+1]);
+ a++;
+ }
+ else if ( strcmp ( argv[a], "-overaln_threshold")==0 )
+ {
+
+ set_int_variable ("overaln_threshold", atoi(argv[a+1]));
+ a++;
+ }
+ else if ( strcmp ( argv[a], "-overaln_target")==0 )
+ {
+
+ set_int_variable ("overaln_target", atoi(argv[a+1]));
+ a++;
+ }
+ else if ( strcmp ( argv[a], "-overaln_P1")==0 )
+ {
+
+ set_int_variable ("overaln_P1", atoi(argv[a+1]));
+ a++;
+ }
+ else if ( strcmp ( argv[a], "-overaln_P2")==0 )
+ {
+
+ set_int_variable ("overaln_P2", atoi(argv[a+1]));
+ a++;
+ }
+ else if ( strcmp ( argv[a], "-overaln_P3")==0 )
+ {
+
+ set_int_variable ("overaln_P3", atoi(argv[a+1]));
+ a++;
+ }
+ else if ( strcmp ( argv[a], "-overaln_P4")==0 )
+ {
+
+ set_int_variable ("overaln_P4", atoi(argv[a+1]));
+ a++;
+ }
+
+ else if ( strcmp ( argv[a], "-in2_f")==0||strm(argv[a],"-input2") )
+ {
+ if ( strcmp ( argv[a], "-in_f")==0) fprintf ( stdout,"\nWARNING: %s deprecated, use -input2 instead", argv[a]);
+
+ sprintf ( in2_format, "%s", argv[a+1]);
+ a++;
+ }
+ else if ( strcmp ( argv[a], "-seqnos")==0)
+ {
+ sprintf (action_list[n_actions++], "seqnos");
+ }
+
+ else if ( strcmp( argv[a], "-action")==0)
+ {
+ while ((a+1)<argc && argv[a+1][0]!='-')
+ {
+ sprintf (action_list[n_actions++], "%s", argv[a+1]);
+ a++;
+ }
+ }
+ else if ( strcmp ( argv[a], "-keep_case")==0)
+ {
+ if(!NEXT_ARG_IS_FLAG)RAD->keep_case=1;
+ else RAD->keep_case=(strm3(argv[a], "on","ON","On"))?1:0;
+
+ }
+
+ else if ( strcmp ( argv[a], "-conv")==0)
+ {
+ if ( strncmp ( argv[a+1],"set",3)==0)RAD->symbol_list=make_symbols (argv[++a],&(RAD->n_symbol));
+ else
+ {
+ RAD->symbol_list=declare_char (STRING, STRING);
+ while(!NEXT_ARG_IS_FLAG)
+ {
+ sprintf ( RAD->symbol_list[RAD->n_symbol], "%s", argv[++a]);
+ RAD->n_symbol++;
+ }
+ }
+ }
+ else if ( strcmp ( argv[a], "-struc_in_f")==0 ||strcmp ( argv[a], "-input3")==0 )
+ {
+ sprintf ( struc_in_format, "%s", argv[a+1]);
+ a++;
+ }
+ else if ( strcmp ( argv[a], "-out_f")==0 ||strm(argv[a],"-output") )
+ {
+ if ( strcmp ( argv[a], "-out_f")==0) fprintf (stdout, "\nWARNING: %s deprecated, use -output instead", argv[a]);
+ sprintf ( out_format, "%s", argv[a+1]);
+ a++;
+ }
+ else if ( strm ( argv[a], "-struc_out_f") || strm ( argv[a], "-output_struc") )
+ {
+ sprintf ( struc_out_format, "%s", argv[a+1]);
+ a++;
+ }
+ else if ( strcmp (argv[a],"-in")==0)
+ {
+ sprintf( in_file, "%s", argv[a+1]);
+ a++;
+ }
+ else if ( strcmp (argv[a],"-rename")==0)
+ {
+ sprintf( rename_file, "%s", argv[a+1]);
+ a++;
+ }
+ else if ( strcmp (argv[a],"-code")==0)
+ {
+ code=CODE;
+ sprintf( rename_file, "%s", argv[a+1]);
+ a++;
+ }
+ else if ( strcmp (argv[a],"-decode")==0)
+ {
+ code=DECODE;
+ sprintf( rename_file, "%s", argv[a+1]);
+ a++;
+ }
+ else if ( strcmp (argv[a],"-in2")==0)
+ {
+ sprintf( in2_file, "%s", argv[a+1]);
+ a++;
+ }
+ else if ( strcmp (argv[a],"-coor")==0)
+ {
+ sprintf( RAD->coor_file, "%s", argv[a+1]);
+ a++;
+ }
+ else if (strcmp (argv[a],"-out")==0)
+ {
+ sprintf (out_file, "%s", argv[a+1]);
+ a++;
+ }
+ else if (strcmp (argv[a],"-out2")==0)
+ {
+ sprintf (out2_file, "%s", argv[a+1]);
+ a++;
+ }
+ else if ( strcmp (argv[a],"-struc_in")==0 || strcmp (argv[a],"-in3")==0 )
+ {
+ sprintf( struc_in_file, "%s", argv[a+1]);
+ a++;
+ }
+ else if (strcmp (argv[a],"-struc_out")==0)
+ {
+ sprintf (struc_out_file, "%s", argv[a+1]);
+ a++;
+ }
+ else if ( strcmp ( argv[a], "-rm_gap")==0)
+ {
+ RAD->rm_gap=1;
+ }
+ else if ( strcmp ( argv[a], "-print_format")==0)
+ {
+ print_format=1;
+ }
+ else if ( strcmp ( argv[a], "-no_warning")==0)
+ {
+ set_warning_mode (NO);
+ }
+
+ else
+ {
+ fprintf ( stdout, "\nUNKNOWN OPTION: %s", argv[a]);
+ myexit(EXIT_FAILURE);
+ }
+ }
+/****************************************************************/
+/* */
+/* Data Preparation */
+/* */
+/* */
+/****************************************************************/
+
+ prepare_cache (cache);
+/****************************************************************/
+/* */
+/* INPUT SEQ/ALN */
+/* */
+/* */
+/****************************************************************/
+
+
+ if ( strm (out_format, "hasch"))
+ {
+ fprintf ( stdout, "%d\n", (int)hash_file(in_file));
+ return EXIT_SUCCESS;
+ }
+
+ if ( rename_file[0])
+ {
+ rename_list=read_rename_file ( rename_file,code);
+ }
+
+
+ if ((D1=read_data_structure (in_format, in_file,RAD))!=NULL)
+ {
+ in_format=(in_format && in_format[0])?in_format:identify_seq_format(in_file);
+
+ if (print_format)fprintf ( stdout, "\nFILE:%s FORMAT:%s\n", in_file, in_format);
+ }
+ else if ( in_file[0])
+ {
+ fprintf ( stdout, "\nFORMAT of file %s Not Supported[FATAL:%s]\n", in_file, PROGRAM);
+ myexit(EXIT_FAILURE);
+ }
+
+ if ((D2=read_data_structure (in2_format, in2_file,RAD))!=NULL){if (print_format)fprintf ( stderr, "\nFILE:%s FORMAT:%s\n", in2_file, (in2_format&&in2_format[0])?in2_format:identify_seq_format(in2_file));}
+
+ else if (!D2 && in2_file[0])
+ {
+ fprintf ( stderr, "\nFORMAT of file %s Not Supported [FATAL:%s]\n", in2_file, PROGRAM);
+ myexit(EXIT_FAILURE);
+ }
+
+/*STRUCTURE INPUT*/
+
+
+ if ((D_ST=read_data_structure (struc_in_format, struc_in_file,RAD)))
+ {
+
+ if ( D_ST->CL)
+ {
+ Constraint_list *CL;
+ int *entry;
+
+ CL=D_ST->CL;
+
+ while ((entry=extract_entry (CL)))
+ {
+ if ( D_ST->S)(D_ST->S)->seq[entry[SEQ1]][entry[R1]-1]=entry[WE];
+ }
+ thread_seq_struc2aln (D_ST->A, D_ST->S);
+ }
+ else if ( name_is_in_list ("cons", ((D_ST)->A)->name, ((D_ST)->A)->nseq, 100));
+ else
+ {
+ D_ST->A=copy_aln ( D1->A, D_ST->A);
+
+ thread_seq_struc2aln (D_ST->A, D_ST->S);
+ }
+ }
+ else if ((strcmp (struc_in_format, "rna_number")==0) && in_file[0])
+ {
+ D_ST->RNA_ST=read_rna_struc_number((D1->A),struc_in_file);
+ }
+ else if ( struc_in_format[0] && struc_in_file[0])
+ {
+
+ fprintf ( stderr, "\nSTRUC %s UNKNOWN[FATAL]", struc_in_format);
+ myexit(EXIT_FAILURE);
+ }
+ else
+ {
+ D_ST=vcalloc ( 1, sizeof (Sequence_data_struc));
+ }
+
+ action=declare_char(100, 100);
+ for ( a=0; a< n_actions;)
+ {
+ if (action_list[a][0]!='+')
+ {
+ fprintf ( stderr, "\nWARNING: Action %s Unknown. Actions start with a +", action_list[a]);
+ myexit (EXIT_FAILURE);
+ }
+ else
+ {
+ b=0;
+ sprintf ( action[b++], "%s", action_list[a++]+1);
+ while ( a<n_actions && action_list[a][0]!='+')sprintf ( action[b++], "%s", action_list[a++]);
+ modify_data( D1, D2, D_ST, action,b, RAD);
+ }
+ }
+
+ if (rename_list)
+ {
+ if (D1)D1->A= rename_seq_in_aln(D1->A, rename_list);
+ if (D2)D2->A=rename_seq_in_aln (D2->A, rename_list);
+ if (D_ST)D_ST->A=rename_seq_in_aln (D_ST->A,rename_list);
+
+ if (D1)D1->T =rename_seq_in_tree (D1->T, rename_list);
+ if (D2)D2->T =rename_seq_in_tree (D2->T, rename_list);
+ if (D_ST)D_ST->T=rename_seq_in_tree (D_ST->T,rename_list);
+ }
+
+
+ if ( !out_format[0] && ! struc_out_format[0])sprintf ( out_format, "%s", (in_format && in_format[0])?in_format:"fasta_aln");
+ main_output ( D1, D2, D_ST, out_format, out_file);
+ main_output ( D1, D2, D_ST, struc_out_format, struc_out_file);
+ return EXIT_SUCCESS;
+ }
+
+
+
+
+/**************************************************************************************************/
+/***************************** FORMAT GUESSING ******************************************/
+/**************************************************************************************************/
+Sequence_data_struc *read_data_structure ( char *in_format, char *in_file, Action_data_struc *RAD)
+
+ {
+ Sequence_data_struc *D;
+ char **seq_name=NULL, **sequences=NULL;
+ int nseq=0, a;
+
+
+ D=vcalloc ( 1, sizeof (Sequence_data_struc));
+
+
+ if (!in_file[0])return NULL;
+ if (!in_format[0])
+ {
+ in_format=identify_seq_format(in_file);
+ }
+ if (!in_format[0])return NULL;
+
+
+
+ D->A=declare_Alignment(NULL);
+ if ( RAD->keep_case)(D->A)->residue_case=KEEP_CASE;
+
+ D->rm_gap=RAD->rm_gap;
+ sprintf ( D->format, "%s", in_format);
+ sprintf ( D->file, "%s", in_file);
+
+
+
+
+ if ( strm2(in_format,"saga_aln","clustal_aln"))
+ {
+ read_aln (in_file, D->A);
+ D->S=aln2seq(D->A);
+
+ }
+
+ else if ( strm (in_format, "treefile_list"))
+ {
+
+ D->S=get_tree_file_list(in_file);
+ D->A=seq2aln(D->S, D->A,NO_PAD);
+ }
+ else if ( strm (in_format, "file_list") || strm (in_format, "list"))
+ {
+ D->S=get_file_list(in_file);
+ D->A=seq2aln(D->S, D->A,KEEP_GAP);
+ }
+ else if ( strm (in_format, "fasta_tree"))
+ {
+
+ D->S=get_fasta_tree (in_file, NULL);
+ D->A=seq2aln(D->S, D->A,NO_PAD);
+
+ }
+ else if ( strm (in_format, "tree_list") || strm (in_format, "treelist"))
+ {
+ char **line;
+ FILE *seq;
+ int n=0;
+ char *seq_file;
+ FILE *fp;
+
+ seq_file=vtmpnam(NULL);
+ seq=vfopen (seq_file, "w");
+ line=file2lines (in_file);
+ fp=vfopen (seq_file, "w");
+ for ( n=1; n<atoi(line[0]); n++)
+ {
+ fprintf ( fp, ">Tree_%d\n%s\n", n,line[n]);
+ }
+ vfclose (fp);
+
+ free_char (line, -1);
+ return read_data_structure ( "fasta_tree",seq_file,RAD);
+ }
+
+ else if (strm (in_format, "matrix"))
+ {
+ D->M=read_matrice (in_file);
+ }
+ else if (strm4 (in_format, "newick_tree", "newick", "nh", "new_hampshire"))
+ {
+ D->T=main_read_tree (in_file);
+ D->S=tree2seq(D->T, NULL);
+ D->A=seq2aln (D->S,D->A, 0);
+ }
+ else if (strm (in_format, "blast_aln"))
+ {
+ if (read_blast_aln (in_file, D->A))
+ {
+ D->S=aln2seq(D->A);
+ }
+ else
+ {
+ return NULL;
+ }
+ }
+ else if ( strm( in_format,"number_aln"))
+ {
+ read_number_aln (in_file, D->A);
+ D->S=aln2seq(D->A);
+ }
+ else if ( strm( in_format,"stockholm_aln"))
+ {
+ read_stockholm_aln (in_file, D->A);
+ D->S=aln2seq(D->A);
+ }
+ else if ( strm( in_format,"gotoh_aln"))
+ {
+ read_gotoh_aln (in_file, D->A);
+ D->S=aln2seq(D->A);
+ }
+
+ else if ( strm ( in_format, "msf_aln"))
+ {
+ read_msf_aln (in_file, D->A);
+ D->S=aln2seq(D->A);
+ }
+ else if ( strm ( in_format, "amps_aln"))
+ {
+ read_amps_aln (in_file, D->A);
+ D->S=aln2seq(D->A);
+ }
+ else if ( strm (in_format, "excel_seq"))
+ {
+ D->S=perl_reformat2fasta ("excel2fasta.pl",in_file);
+ (D->S)->contains_gap=0;
+ D->A=seq2aln(D->S, D->A,RAD->rm_gap);
+ }
+ else if ( strm (in_format, "pavie_seq"))
+ {
+ D->S=perl_reformat2fasta ("pavie2fasta.pl",in_file);
+ (D->S)->contains_gap=0;
+ D->A=seq2aln(D->S, D->A,RAD->rm_gap);
+ }
+ else if ( strncmp (in_format, "perl_",5 )==0)
+ {
+ D->S=perl_reformat2fasta (in_format+5,in_file);
+ (D->S)->contains_gap=0;
+ D->A=seq2aln(D->S, D->A,RAD->rm_gap);
+ }
+ else if ( strm (in_format, "number_fasta"))
+ {
+ D->S=get_fasta_sequence_num (in_file, NULL);
+ (D->S)->contains_gap=0;
+ D->A=seq2aln(D->S, D->A,RAD->rm_gap);
+ }
+ else if ( strm (in_format, "raw_fasta"))
+ {
+ D->S=get_fasta_sequence_raw (in_file, NULL);
+ (D->S)->contains_gap=0;
+ D->A=seq2aln(D->S, D->A,RAD->rm_gap);
+ }
+
+ else if ( strm2 (in_format, "fasta_aln", "fasta_seq"))
+ {
+
+ D->S=get_fasta_sequence (in_file, NULL);
+ if ( strcmp (in_format, "fasta_aln")==0)(D->S)->contains_gap=0;
+ D->A=seq2aln(D->S, D->A,RAD->rm_gap);
+ }
+ else if ( strm (in_format, "fasta_tree"))
+ {
+
+ D->S=get_fasta_tree (in_file, NULL);
+ D->A=seq2aln(D->S, D->A, NO_PAD);
+ }
+
+ else if ( strm (in_format, "pdb") || strm (in_format, "pdb_struc"))
+ {
+ D->S=get_pdb_sequence (in_file);
+ if ( D->S==NULL)
+ {
+ add_warning (stderr, "FAILED TO find PDB File %s", in_file);
+ myexit (EXIT_FAILURE);
+ }
+ D->A=seq2aln(D->S, D->A,RAD->rm_gap);
+ }
+ else if ( strm2(in_format, "pir_seq", "pir_aln"))
+ {
+ D->S=get_pir_sequence ( in_file,NULL );
+ seq2aln(D->S, D->A, RAD->rm_gap);
+ }
+ else if ( strm(in_format, "gor_seq") )
+ {
+ D->S=get_gor_sequence ( in_file,NULL );
+ seq2aln(D->S, D->A, RAD->rm_gap);
+ }
+ else if ( strm2 ( in_format, "dali_aln", "dali_seq"))
+ {
+ D->S=get_sequence_dali ( in_file);
+ seq2aln(D->S, D->A, RAD->rm_gap);
+ }
+ else if ( strm (in_format, "barton_list_tc"))
+ {
+ get_barton_list_tc_seq ( in_file);
+ }
+ else if ( strm (in_format, "amps_sd_scores"))
+ {
+ D->W=get_amps_sd_scores ( in_file);
+ }
+
+ else if ( strm ( in_format, "pima_aln"))
+ {
+ D->S=get_pima_sequence ( in_file);
+ seq2aln (D->S, D->A, RAD->rm_gap);
+ }
+ else if ( strm( in_format, "gor_struc"))
+ {
+ D->S=get_struc_gor ( in_file);
+ seq2aln(D->S, D->A, RAD->rm_gap);
+ }
+ else if ( strm( in_format, "dialign_aln"))
+ {
+ D->S=get_dialign_sequence ( in_file);
+ seq2aln (D->S, D->A, RAD->rm_gap);
+ }
+ else if ( strm( in_format, "tc_lib") || strm( in_format, "mocca_lib") || strm( in_format, "lib"))
+ {
+ read_seq_in_list (in_file,&nseq,&sequences,&seq_name);
+ D->S=fill_sequence_struc ( nseq, sequences, seq_name);
+ D->CL=declare_constraint_list ( D->S,NULL, NULL, 0,NULL, NULL);
+ D->CL=read_constraint_list_file(D->CL,in_file);
+ seq2aln (D->S, D->A, RAD->rm_gap);
+ free_char (sequences,-1);
+ free_char (seq_name, -1);
+ }
+ else if ( strm( in_format,"swissprot_seq"))
+ {
+ D->S=get_swissprot_sequence ( in_file,NULL);
+ seq2aln (D->S, D->A, RAD->rm_gap);
+ }
+ else if (strm (in_format, "alifold"))
+ {
+ D->S=read_alifold ( in_file);
+ seq2aln (D->S, D->A,0);
+ }
+ else
+ {
+ return NULL;
+ }
+
+ if ( D->A)
+ {
+ for ( a=0; a<(D->A)->nseq; a++)sprintf ( (D->A)->file[a], "%s", in_file);
+ }
+ if ( D->S)
+ {
+ for ( a=0; a<(D->A)->nseq; a++)sprintf ( (D->S)->file[a], "%s", in_file);
+ }
+
+ return D;
+ }
+Sequence *read_sequences (char *name)
+{
+ return main_read_seq (name);
+}
+Alignment * alifold2aln (char *file)
+{
+ Sequence *S;
+ S=read_alifold(file);
+ sprintf ( S->seq[0],"%s", S->seq[1]);
+ return seq2aln (S, NULL, 0);
+}
+Sequence * read_alifold (char *file)
+{
+ Sequence *S;
+ char **list;
+ int l;
+ S=declare_sequence (1,count_n_char_in_file (file),2);
+ list=file2lines (file);
+
+ S->seq[0]=list[1];
+ S->seq[1]=list[2];
+ substitute (S->seq[0], "\n", "\0");
+ substitute (S->seq[0], " ", "\0");
+ substitute (S->seq[0], "_", STOCKHOLM_STRING);
+ l=strlen (S->seq[0]);
+ substitute (S->seq[1], "\n", "\0");
+ substitute (S->seq[1], " ", "\0");
+ substitute (S->seq[1], ".", STOCKHOLM_STRING);
+ S->seq[1][l]='\0';
+ sprintf (S->name[0], "cons");
+ sprintf (S->name[1], "#=GC SS_cons");
+ return S;
+}
+
+
+
+
+
+
+Sequence * main_read_seq ( char *name)
+ {
+ char *format=NULL;
+ Sequence *S=NULL;
+ Alignment *A=NULL;
+ int a;
+
+
+ format=identify_seq_format (name);
+
+
+ if ( getenv4debug ("DEBUG_REFORMAT"))fprintf ( stderr, "\n\nFormat %s\n", format);
+
+
+ if (format &&strm(format, "fasta_seq"))
+ {
+ S= get_fasta_sequence ( name, NULL);
+ }
+ else if (format &&strm(format, "pir_seq")) S= get_pir_sequence ( name, NULL);
+ else if (format &&strm(format,"swissprot_seq"))S= get_swissprot_sequence (name, NULL);
+ else if (format && strstr (format, "aln"))
+ {
+ A=main_read_aln ( name, NULL);
+ S=aln2seq(A);
+ ungap_seq(S);
+ free_aln(A);
+ }
+ else if ( format && strstr (format, "tc_lib"))
+ {
+ int nseq,b;
+ char **sequences=NULL, **seq_name=NULL;
+
+ read_seq_in_list (name,&nseq,&sequences,&seq_name);
+ S=fill_sequence_struc ( nseq, sequences, seq_name);
+ for ( b=0; b< S->nseq; b++)sprintf ( S->file[b], "%s",name);
+ free_char (seq_name, -1);free_char (sequences, -1);
+ }
+ else
+ {
+ /*Use The ClustalW routine*/
+ S=cw_read_sequences (name);
+ }
+
+ for ( a=0; a<S->nseq; a++)sprintf ( S->file[a], "%s", name);
+ vfree(format);
+ ungap_seq(S);
+ S=clean_sequence ( S);
+ return S;
+ }
+
+Alignment * main_read_aln ( char *name, Alignment *A)
+ {
+ int a;
+
+ static char *format;
+ Sequence *S=NULL;
+ Sequence *IN_SEQ;
+
+
+ if ( !name)return NULL;
+ else if (!check_file_exists(name))
+ {
+ if ( !check_file_exists (name+1))return NULL;
+ else if ( name[0]=='A') name++;
+ else if ( name[0]=='S') name++;/*Line Added for the -convert flag of T-Coffee*/
+ }
+
+
+ if (!A)A=declare_aln(NULL);
+ format=identify_seq_format (name);
+
+ IN_SEQ=A->S;
+
+ if ((format && strm(format, "saga_aln" )) ||strm(format, "clustal_aln")||strm(format, "t_coffee_aln" ) )
+ {
+
+ read_aln ( name, A);
+
+ }
+ else if (format && strm (format, "conc_aln"))A=input_conc_aln (name,NULL);
+ else if (format &&strm(format, "msf_aln" ))read_msf_aln ( name, A);
+ else if (format &&strm(format, "blast_aln"))read_blast_aln (name, A);
+ else if (format &&(strm(format, "fasta_aln")))
+ {
+
+
+ S=get_fasta_sequence ( name, NULL);
+
+ S->contains_gap=0;
+ seq2aln (S, A, 0);
+ }
+ else if (format &&strm(format, "pir_aln"))
+ {
+ S=get_pir_sequence ( name, NULL);
+ S->contains_gap=0;
+ seq2aln (S, A, 0);
+ }
+ else if (format && strm(format, "fasta_seq") && A)
+ {
+ S=get_fasta_sequence ( name, NULL);
+
+ for ( a=1; a<S->nseq; a++)if ( strlen (S->seq[a-1])!=strlen (S->seq[a])){free_sequence (S, S->nseq); free_aln (A); return NULL;}
+ S->contains_gap=0;
+ seq2aln (S, A, 0);
+ }
+
+ else if (format && strm(format, "pir_seq") && A)
+ {
+ S=get_pir_sequence ( name, NULL);
+
+ for ( a=1; a<S->nseq; a++)if ( strlen (S->seq[a-1])!=strlen (S->seq[a])){free_sequence (S, S->nseq); free_aln (A); return NULL;}
+ S->contains_gap=0;
+ seq2aln (S, A, 0);
+ }
+ else
+ {
+ free_aln(A);
+ return NULL;
+ }
+
+
+ if ( check_list_for_dup( A->name, A->nseq))
+ {
+ fprintf ( stderr, "\nWARNING (main_read_aln): %s is duplicated in File %s ", check_list_for_dup( A->name, A->nseq), A->file[0]);
+ A=aln2unique_name_aln(A);
+ }
+
+ if (IN_SEQ)A->S=IN_SEQ;
+ else if (!A->S){A->S=aln2seq(A);}
+
+ A->S=ungap_seq(A->S);
+ A=fix_aln_seq(A, A->S);
+ compress_aln (A);
+ for ( a=0; a< A->nseq; a++) sprintf ( A->file[a], "%s", name);
+
+ A=clean_aln (A);
+ return A;
+ }
+
+
+char * identify_aln_format ( char *file)
+ {
+ /*This function identify known sequence and alignmnent formats*/
+ return identify_seq_format (file);
+ }
+char * identify_seq_format ( char *file)
+ {
+ char *format=NULL;
+ /*This function identify known sequence and alignmnent formats*/
+
+ if ( format==NULL)format=vcalloc ( 100, sizeof (char));
+ else format[0]='\0';
+
+
+
+ if ( !check_file_exists(file))
+ {
+ fprintf (stderr, "ERROR: %s Does Not Exist [FATAL:%s]\n",file, PROGRAM);
+ myexit (EXIT_FAILURE);
+ }
+ else if ( is_stockholm_aln (file))sprintf (format, "stockholm_aln");
+ else if ( is_blast_file (file))sprintf ( format, "blast_aln");
+ else if ( is_pdb_file(file))sprintf ( format, "pdb_struc");
+ else if ( format_is_msf (file))sprintf ( format, "msf_aln");
+ else if ( format_is_fasta_seq(file))sprintf ( format, "fasta_seq");
+ else if ( format_is_fasta_aln(file))sprintf ( format, "fasta_aln");
+ else if ( format_is_pir_aln (file))sprintf ( format, "pir_aln");
+ else if ( format_is_pir_seq (file))sprintf ( format, "pir_seq");
+ else if ( format_is_oligo (file))sprintf ( format, "oligo_aln");
+ else if ( format_is_swissprot (file))sprintf ( format, "swissprot_seq");
+ else if ( format_is_saga (file))sprintf ( format, "clustal_aln");
+ else if ( format_is_conc_aln (file))sprintf ( format, "conc_aln");
+ else if ( is_lib (file))sprintf ( format, "tc_lib");
+ else if ( is_lib_02 (file))sprintf ( format, "tc_lib_02");
+ else if ( is_newick(file))sprintf ( format, "newick_tree");
+
+ else
+ {
+ //add_warning ( stderr, "\nThe Format of File: %s was not recognized [SERIOUS:%s]",file, PROGRAM);
+ ;
+ }
+ return format;
+ }
+char **identify_list_format ( char **list, int n)
+ {
+ int a;
+ char *name;
+ char *string;
+ char mode;
+
+
+
+ declare_name (name);
+ for ( a=0; a< n; a++)
+ {
+
+ sprintf (name, "%s", list[a]);
+ string=list[a];
+ if ((mode=identify_format ( &string))!='?')
+ {
+ sprintf ( name, "%s", string);
+ sprintf ( list[a], "%c%s", mode,name);
+ }
+ else
+ {
+ fprintf ( stderr, "\nERROR: %s not recognised [FATAL:%s]", name, PROGRAM);
+ }
+
+ }
+
+ vfree(name);
+ return list;
+ }
+
+char * name2type_name ( char *name)
+{
+ /*turns <file> into <Sfile>, <Afile>...*/
+ char *new_name;
+ char mode;
+
+ new_name=vcalloc ( strlen (name)+2, sizeof (char));
+ sprintf ( new_name, "%s", name);
+ if (is_in_set (name[0], "ALSMXPRW") && !check_file_exists(name))
+ {
+ sprintf ( new_name, "%s", name);
+ }
+ else
+ {
+ mode=identify_format (&new_name);
+ sprintf ( new_name, "%c%s", mode,name);
+ }
+ return new_name;
+}
+
+char identify_format (char **fname)
+ {
+ char mode='?';
+ mode=fname[0][0];
+
+ if ((is_in_set (mode, "ALMSPR") && check_file_exists(fname[0]+1)) ||(mode=='X' && is_matrix ( fname[0]+1)) ||(mode=='M' && is_method(fname[0]+1)) )
+ {
+
+ fname[0]++;
+ }
+ else if (mode=='W' && !check_file_exists(fname[0])){fname[0]++;}
+ else
+ {
+
+ /*WARNING: Order matters => internal methods can be confused with files, must be checked last*/
+ if (is_lib(fname[0]))mode='L';
+ else if (is_pdb_file(fname[0]))mode='P';
+ else if (is_seq(fname[0]))mode='S';
+ else if (is_aln(fname[0]))mode='A';
+ else if (is_matrix(fname[0]))mode='X';
+ else if (is_method(fname[0]))mode='M';
+ else mode='?';
+ }
+ return mode;
+ }
+
+
+
+int is_pdb_name ( char *name)
+ {
+ char command[1000];
+ int result;
+ char *result_file;
+ static char **buf_names;
+ static int *buf_result;
+ static int nbuf;
+ FILE *fp;
+
+
+ /*Use the look up*/
+ if ( !buf_names)
+ {
+ buf_names=declare_char (1000, 100);
+ buf_result=vcalloc (1000, sizeof (int));
+ }
+ if ( (result=name_is_in_list ( name, buf_names,nbuf,100))!=-1)return buf_result[result];
+
+
+
+ result_file=vtmpnam (NULL);
+
+ sprintf ( command, "extract_from_pdb -is_pdb_name \'%s\' > %s", name, result_file);
+ if ( getenv4debug ("DEBUG_EXTRACT_FROM_PDB"))fprintf ( stderr, "\n[DEBUG_EXTRACT_FROM_PDB:is_pdb_name] %s\n", command);
+ my_system ( command);
+
+ fp=vfopen ( result_file, "r");
+ fscanf ( fp, "%d", &result);
+ vfclose (fp);
+ vremove ( result_file);
+
+ sprintf ( buf_names[nbuf], "%s", name);
+ result=buf_result[nbuf++]=(result==1)?1:0;
+
+ return result;
+
+ }
+
+char* get_pdb_id ( char *file)
+{
+ /*receives the name of a pdb file*/
+ /*reads the structure id in the header*/
+ /*returns the pdb_id*/
+ char *tmp_name;
+ char command[10000];
+ char cached [1000];
+ char fname[1000];
+ FILE *fp;
+ char *id;
+ char buf[1000];
+
+
+ tmp_name=vtmpnam(NULL);
+
+ sprintf ( cached, "%s/%s", get_cache_dir(),file);
+ if ( check_file_exists(cached))sprintf ( fname, "%s", cached);
+ else sprintf ( fname, "%s", file);
+
+ sprintf ( command, "extract_from_pdb -get_pdb_id %s > %s",fname, tmp_name);
+
+ if ( getenv4debug ("DEBUG_EXTRACT_FROM_PDB"))fprintf ( stderr, "\n[DEBUG_EXTRACT_FROM_PDB:get_pdb_id] %s\n", command);
+ my_system ( command);
+
+ buf[0]='\0';
+ fp=vfopen (tmp_name, "r");
+ fscanf ( fp, "\n%s\n", buf);
+ vfclose (fp);
+
+ if ( getenv4debug ("DEBUG_EXTRACT_FROM_PDB"))fprintf ( stderr, "\n[DEBUG_EXTRACT_FROM_PDB:get_pdb_id]DONE\n");
+
+ id=vcalloc ( strlen (buf)+1, sizeof (char));
+ sprintf ( id, "%s", buf);
+
+
+
+ return id;
+}
+
+
+char* get_pdb_struc(char *in_name, int start, int end)
+ {
+ char *name1,*name2;
+ char command[LONG_STRING];
+ char *name;
+
+
+
+
+ name=vcalloc ( STRING, sizeof (char));
+ sprintf ( name, "%s", in_name);
+
+ if ( (name1=is_pdb_struc(name))==NULL && (name[0]=='P' && ((name1=is_pdb_struc (name+1))==NULL)))
+ {
+ fprintf ( stderr, "\nERROR Could not download structure %s [FATAL:%s]\n", name, PROGRAM);crash("");
+ }
+ else if ( (start==0) && (end==0))return name1;
+ else
+ {
+ declare_name(name2);
+ sprintf ( name2, "%s_%d_%d.pdb", name, start, end);
+ sprintf ( command, "extract_from_pdb -infile \'%s\' -chain FIRST -coor %d %d > %s%s",check_file_exists(name1),start, end, get_cache_dir(),name2);
+ if ( getenv4debug ("DEBUG_EXTRACT_FROM_PDB"))fprintf ( stderr, "\n[DEBUG_EXTRACT_FROM_PDB:get_pdb_struc] %s\n", command);
+ my_system (command);
+
+ if ( is_pdb_file(name2))return name2;
+ else
+ {
+ fprintf ( stderr, "\nERROR Could not extract segment [%d %d] from structure %s [FATAL:%s]\n",start, end, name, PROGRAM);crash("");
+ }
+ myexit (EXIT_FAILURE);
+ }
+
+ return NULL;
+ }
+
+char* seq_is_pdb_struc ( Sequence *S, int i)
+{
+
+ if (!S){return NULL;}
+ else if ( !S->T[i]){return NULL;}
+ else if ( !((S->T[i])->P)){return NULL;}
+ else return ((S->T[i])->P)->template_file;
+}
+char* is_pdb_struc ( char *name)
+ {
+ /*Receives a name
+ checks if this is the name of a local file that contains PDB data
+ checks if this is the name of a file from a local db
+ put the file in the cache
+ checks if this is a file from a remote db (extract_from_pdb
+ return NULL if everything fails
+ */
+
+ static char *file_name1;
+ static char *file_name2;
+
+ static char **buf_names;
+ static char **buf_result;
+ static int nbuf, s;
+
+
+ char *r=NULL;
+ char command[1000];
+
+
+ if ( !name || name[0]=='\0')return NULL;
+
+
+ /*Use the look up*/
+ if ( !buf_names)
+ {
+
+ buf_names=vcalloc ( 1000, sizeof (char*));
+ buf_result=vcalloc ( 1000, sizeof (char*));
+ file_name1=vcalloc ( 1000, sizeof (char));
+ file_name2=vcalloc ( 1000, sizeof (char));
+ }
+ if ( (s=name_is_in_list ( name, buf_names,nbuf,-1))!=-1)return buf_result[s];
+
+
+ r=NULL;
+ sprintf ( file_name1, "%s", name);
+ sprintf ( file_name2, "%s.pdb", name);
+
+
+ if (is_pdb_file(file_name1)){r=file_name1;}
+ else if (is_pdb_file(file_name2)){r=file_name2;}
+ else if (is_pdb_name (name))
+ {
+ printf_system ("extract_from_pdb -netfile \'%s\' > %s/%s 2>/dev/null",name, get_cache_dir(), file_name2);
+ if ( is_pdb_file(file_name2))r=file_name2;
+ else r=NULL;
+
+ }
+
+
+ /*Fill the buffer*/
+ buf_names[nbuf]=vcalloc ( strlen (name)+1, sizeof (char));
+ sprintf ( buf_names[nbuf], "%s", name);
+ if ( r)
+ {
+ buf_result[nbuf]=vcalloc ( strlen (r)+1, sizeof (char));
+ sprintf (buf_result[nbuf], "%s", r);
+ }
+ else buf_result[nbuf]=NULL;
+ nbuf++;
+
+ return r;
+ }
+
+char *fix_pdb_file ( char *in)
+{
+ char *empty;
+
+ empty=vcalloc(1, sizeof(char));
+
+ if ( !in || !check_file_exists (in))return empty;
+ else if ( is_pdb_file(in))return in;
+ else
+ {
+ char command[10000];
+ char *tmp;
+ char *tmp2;
+ tmp=vtmpnam (NULL);
+ tmp2=vcalloc (strlen (tmp)+1, sizeof (char));
+ sprintf (tmp2, "%s", tmp);
+ sprintf ( command, "extract_from_pdb %s > %s", check_file_exists(in), tmp2);
+ my_system (command);
+ if ( is_pdb_file (tmp))return tmp2;
+ else return empty;
+
+ }
+}
+
+int is_sap_file ( char *name)
+ {
+ FILE *fp;
+ if (!name);
+ if (!check_file_exists(name))return 0;
+
+ if ((fp=find_token_in_file (name, NULL, "Percent"))!=NULL)
+ {
+ if ((fp=find_token_in_file (name,fp, "Percent"))!=NULL)
+ {
+ vfclose (fp);
+ return 1;
+ }
+ else
+ {
+ return 0;
+ }
+ }
+ else
+ {
+ return 0;
+ }
+ }
+
+
+int is_blast_file ( char *name)
+ {
+ if ( !check_file_exists(name) ) return 0;
+ else if (token_is_in_file (name, "<SequenceSimilaritySearchResult>"))
+ {
+ return BLAST_XML;
+ }
+ else
+ {
+ if (token_is_in_file (name, "Lambda") && token_is_in_file (name, "Altschul,"))
+ {
+ return BLAST_TXT;
+ }
+ else
+ {
+ return 0;
+ }
+ }
+ return 0;
+ }
+int is_simple_pdb_file ( char *name)
+{
+ FILE *fp;
+ if ((fp=find_token_in_file (name, NULL, "SIMPLE_PDB_FORMAT"))!=NULL){vfclose (fp);return 1;}
+ return 0;
+}
+
+
+int is_pdb_file ( char *name)
+ {
+ FILE *fp;
+ int ispdb=0;
+
+ if ( name==NULL) return 0;
+ if (!check_file_exists (name))return 0;
+
+ if ((fp=find_token_in_file (name, NULL, "\nHEADER"))!=NULL)
+ {vfclose (fp);
+ ispdb++;
+ }
+ if ((fp=find_token_in_file (name, NULL, "\nSEQRES"))!=NULL)
+ {
+ vfclose (fp);
+ ispdb++;
+ }
+
+ if ((fp=find_token_in_file (name, NULL, "\nATOM"))!=NULL)
+ {
+ vfclose (fp);
+ ispdb++;
+ }
+ else
+ {
+ ispdb=0;
+ }
+
+
+ if ( ispdb>=2)return 1;
+ else return 0;
+ }
+int is_seq ( char *name)
+ {
+ char *format;
+
+ if ( !check_file_exists(name))return 0;
+
+ format= identify_seq_format(name);
+ if(!format || format[0]=='\0'){vfree (format);return 0;}
+ else if (strstr(format, "seq")){vfree (format);return 1;}
+ else return 0;
+ }
+int is_aln ( char *name)
+ {
+ char *format;
+ if ( !check_file_exists (name))return 0;
+
+ format= identify_seq_format(name);
+ if ( !format || format[0]=='\0'){vfree (format);return 0;}
+ else if (strstr(format, "aln")){vfree (format); return 1;}
+ else return 0;
+ }
+
+int is_matrix (char *name)
+ {
+ int **m;
+
+ if ((m=read_matrice (name))!=NULL){free_int (m, -1); return 1;}
+ return 0;
+ }
+int is_newick (char *name)
+ {
+ int c;
+ FILE *fp;
+
+
+ fp=vfopen (name, "r");
+ if ( (c=fgetc(fp))!='('){vfclose (fp); return 0;}
+
+
+ while ( (c=fgetc(fp))!=EOF)
+ {
+ if ( c==';'){vfclose (fp); return 1;}
+ }
+ vfclose (fp);
+ return 0;
+ }
+
+int is_clustalw_matrix ( char *name)
+{
+
+ FILE *fp;
+
+
+ if ( (fp=find_token_in_file (name, NULL, "CLUSTALW_MATRIX"))!=NULL){vfclose(fp);return 1;}
+ else return 0;
+}
+int is_pavie_matrix ( char *name)
+{
+
+ FILE *fp;
+
+
+ if ( (fp=find_token_in_file (name, NULL, "PAVIE_MATRIX"))!=NULL){vfclose(fp);return 1;}
+ else return 0;
+}
+int is_distance_matrix_file (char *name)
+{
+ FILE *fp;
+ if ( (fp=find_token_in_file (name, NULL, "TC_DISTANCE_MATRIX_FORMAT_01"))!=NULL){vfclose(fp);return 1;}
+ else return 0;
+}
+int is_similarity_matrix_file (char *name)
+{
+ FILE *fp;
+ if ( (fp=find_token_in_file (name, NULL, "TC_SIMILARITY_MATRIX_FORMAT_01"))!=NULL){vfclose(fp);return 1;}
+ else return 0;
+}
+int is_blast_matrix ( char *name)
+{
+
+ FILE *fp;
+
+
+ if ( (fp=find_token_in_file (name, NULL, "BLAST_MATRIX"))!=NULL){vfclose(fp);return 1;}
+ else return 0;
+}
+
+int is_single_seq_weight_file ( char *name)
+{
+
+
+ return token_is_in_file ( name, "SINGLE_SEQ_WEIGHT_FORMAT_01");
+
+}
+int is_stockholm_aln (char *file)
+{
+ FILE *fp;
+
+ if ((fp=find_token_in_file_nlines (file, NULL, "STOCKHOLM",2)))
+ {
+ vfclose (fp);
+ return 1;
+ }
+ return 0;
+}
+
+int is_lib ( char *name)
+{
+ return is_lib_01(name);
+}
+
+int is_lib_02 ( char *name)
+{
+
+ return token_is_in_file ( name, "TC_LIB_FORMAT_02");
+
+}
+
+int is_lib_01 (char *name)
+ {
+
+
+ if ( token_is_in_file ( name, "TC_LIB_FORMAT_01")) return 1;
+ else if (token_is_in_file ( name, "T-COFFEE_LIB_FORMAT_01"))return 1;
+ else if (token_is_in_file (name, "SEQ_1_TO_N"))return 1;
+ else return 0;
+ }
+int is_lib_list ( char *name)
+{
+ if ( !check_file_exists (name))return 0;
+ if ( token_is_in_file ( name, "TC_LIB_LIST_FORMAT_01")) return 1;
+ return 0;
+}
+int is_method ( char *file)
+ {
+ char new_file[200];
+
+
+ sprintf ( new_file, "%s", file);
+ if ( (token_is_in_file(new_file, "TC_METHOD_FORMAT_01"))){return 1;}
+ if ( is_in_pre_set_method_list(new_file))
+ {
+
+ vremove ( new_file);
+ return 1;
+ }
+ else
+ {
+
+ return 0;
+ }
+ }
+
+/*******************************************************************************************/
+/* */
+/* */
+/* SEQUENCE FORMAT IDENTIFIERS */
+/* */
+/***************************************************************************************** */
+int type_is_exon_boundaries(char **seq, int n)
+{
+ int a, l, b;
+ for (a=0; a<n; a++)
+ {
+ l=strlen (seq[a]);
+ for (b=0; b<l; b++)
+ if ( strchr ("bojBOJ", seq[a][b]))return 1;
+ }
+ return 0;
+}
+
+int format_is_oligo(char *file)
+ {
+ char *buf=NULL;
+ FILE *fp;
+ int r=0;
+
+ fp=vfopen ( file, "r");
+ buf=vfgets(buf,fp);
+ vfclose ( fp);
+
+
+ if ( strm (buf, "ALPHABET"))r=1;
+
+ vfree (buf);
+
+ return r;
+ }
+int format_is_msf ( char *file)
+ {
+ char buf[1000];
+ FILE *fp;
+
+
+
+ if ( (fp=find_token_in_file_nlines (file,NULL,"MSF:", 30))!=NULL){vfclose (fp);return 1;}
+ else
+ {
+ return 0;
+ }
+
+ fp=vfopen ( file, "r");
+ fscanf (fp , "%s", buf);
+ vfclose ( fp);
+
+ if ( strm (buf, "MSF:"))return 1;
+ return 0;
+ }
+
+//Fasta and PIR
+int format_is_fasta_aln ( char *file)
+
+ {
+ if ( format_is_fasta(file) && !format_is_fasta_seq(file))return 1;
+ else return 0;
+ }
+
+
+int format_is_fasta_seq ( char *file)
+ {
+ int a, l1, l2,l;
+ Sequence *S;
+
+ if ( format_is_fasta (file))
+ {
+ S=get_fasta_sequence (file, NULL);
+ if (!S) return 0;
+ else if ( !S->seq[0]){free_sequence (S, S->nseq); return 1;}
+ l=strlen ( S->seq[0]);
+ for ( a=0; a< S->nseq; a++)if(strlen(S->seq[a])!=l){free_sequence (S, S->nseq);return 1;}
+ for ( a=0; a< S->nseq; a++)
+ {
+ l1=strlen ( S->seq[a]);
+ ungap (S->seq[a]);
+ l2=strlen ( S->seq[a]);
+ if ( l1!=l2)
+ {
+ free_sequence (S, S->nseq);
+ return 0;
+ }
+ }
+ free_sequence (S, S->nseq);
+ return 1;
+ }
+ else
+ {
+ return 0;
+ }
+ }
+
+int format_is_fasta ( char *file)
+ {
+ Sequence *S;
+
+ if ( !check_file_exists(file))return 0;
+
+ if ( get_first_non_white_char (file)!='>')return 0;
+ if ( !(S=get_fasta_sequence (file, NULL)))return 0;
+ free_sequence (S, -1);
+ if ( format_is_pir(file)) return 0;
+ return 1;
+ }
+
+int format_is_pir_aln ( char *file)
+
+ {
+ if ( format_is_pir(file) && !format_is_pir_seq(file))return 1;
+ else return 0;
+ }
+
+int format_is_pir_seq ( char *file)
+ {
+ int a, l1, l2;
+ Sequence *S;
+
+
+ if ( format_is_pir (file))
+ {
+ S=get_pir_sequence (file, NULL);
+ for ( a=0; a< S->nseq; a++)
+ {
+ l1=strlen ( S->seq[a]);
+ ungap (S->seq[a]);
+ l2=strlen ( S->seq[a]);
+ if ( l1!=l2)
+ {
+ free_sequence (S, S->nseq);
+ return 0;
+ }
+ }
+ return 1;
+ }
+ else
+ {
+ return 0;
+ }
+ }
+
+
+int format_is_pir ( char *file)
+ {
+ Sequence *S;
+ int pir_name=1, star_end=1, a;
+
+ S=get_fasta_sequence (file, NULL);
+ if (!S)return 0;
+ else if (!S->seq[0])return 0;
+
+ pir_name=1; star_end=1;
+ for (a=0; a< S->nseq; a++)
+ {
+ int l;
+ if (!is_pir_name(S->name[a]))pir_name=0;
+ l=strlen (S->seq[a]);
+ if (!l || (l && S->seq[a][l-1]!='*'))
+ star_end=0;
+ }
+ free_sequence(S,-1);
+ if ( pir_name && star_end) return 1;
+ else return 0;
+ }
+int is_pir_name (char *name)
+{
+ if ( strstr (name, "P1;"))return 1;
+ if ( strstr (name, "F1;"))return 1;
+ if ( strstr (name, "DL;"))return 1;
+ if ( strstr (name, "DC;"))return 1;
+ if ( strstr (name, "RL;"))return 1;
+ if ( strstr (name, "RC;"))return 1;
+ if ( strstr (name, "XX;"))return 1;
+ return 0;
+}
+
+
+int format_is_conc_aln (char *file)
+{
+ FILE *fp;
+ if ( (fp=find_token_in_file (file, NULL, "CONC_MSF_FORMAT_01"))){vfclose (fp); return 1;}
+ return 0;
+}
+int format_is_saga ( char *file)
+ {
+ FILE *fp;
+ int **list;
+ int n_blocks;
+ int n_seq;
+ int a, b;
+
+ if ( (fp=find_token_in_file (file, NULL, "SAGA"))){vfclose (fp); return 1;}
+ else if ((fp=find_token_in_file (file, NULL, "CLUSTAL"))){vfclose (fp); return 1;}
+ else if ((fp=find_token_in_file (file, NULL, "ClustalW"))){vfclose (fp); return 1;}
+ else if ((fp=find_token_in_file (file, NULL, "clustalw"))){vfclose (fp); return 1;}
+ else if ((fp=find_token_in_file (file, NULL, "clustal"))){vfclose (fp); return 1;}
+ else if ((fp=find_token_in_file (file, NULL, "T-COFFEE_MSA"))){vfclose (fp); return 1;}
+ else if ((fp=find_token_in_file (file, NULL, "INTERLEAVED_MSA"))){vfclose (fp); return 1;}
+
+ else return 0;
+
+ if (1==1);
+ else if ((fp=find_token_in_file (file, NULL, "T-COFFEE"))){vfclose (fp); return 1;}
+ else if ((fp=find_token_in_file (file, NULL, "SAGA_FORMAT"))){vfclose (fp); return 1;}
+ else if ((fp=find_token_in_file (file, NULL, "GARP"))){vfclose (fp); return 1;}
+ else if ((fp=find_token_in_file (file, NULL, "INTERLEAVED"))){vfclose (fp); return 1;}
+
+ else
+ {
+ list=get_file_block_pattern (file,&n_blocks,100);
+ if (n_blocks<=2){free_int (list, -1);return 0;}
+ else
+ {
+ n_seq=list[1][0];
+ for ( a=1; a< n_blocks-1; a++)
+ {
+ if ( list[a][0]!=n_seq){free_int (list, -1);return 0;}
+ else
+ {
+ for ( b=1; b<=list[a][0]; b++)
+ if ( list[a][b]!=2){free_int (list, -1);return 0;}
+ }
+ }
+ }
+ return 1;
+ }
+
+ return 0;
+ }
+
+
+int format_is_swissprot (char *name)
+ {
+ FILE *fp;
+
+ if ( !check_file_exists(name))return 0;
+
+
+
+
+ if ( (fp=find_token_in_file_nlines (name,NULL,"\nID ",10))!=NULL\
+ &&(fp=find_token_in_file (name,NULL,"\nSQ "))!=NULL )
+ {
+
+ vfclose (fp);return 1;
+ }
+ else
+ {
+ return 0;
+ }
+ }
+
+/*******************************************************************************************/
+/* */
+/* */
+/* OUTPUT STUFF */
+/* */
+/***************************************************************************************** */
+int output_format_aln ( char *format, Alignment *inA, Alignment *inEA,char *name)
+ {
+ Sequence_data_struc *D1=NULL;
+ Sequence_data_struc *D2=NULL;
+ Alignment *A=NULL;
+ Alignment *EA=NULL;
+
+
+ A =copy_aln (inA, NULL);
+ A->CL=inA->CL;
+ EA=copy_aln (inEA,NULL);
+ A =expand_aln(A);
+ EA=expand_number_aln(inA,EA);
+
+
+ if (A && A->expanded_order )A=reorder_aln ( A, A->expanded_order,A->nseq);
+ if (EA && EA->expanded_order)EA=reorder_aln ( EA, EA->expanded_order,EA->nseq);
+
+
+ D1=vcalloc ( 1, sizeof (Sequence_data_struc));
+ D1->A=A;
+ if (EA)
+ {
+ D2=vcalloc ( 1, sizeof (Sequence_data_struc));
+ D2->A=EA;
+ }
+
+ main_output ( D1, NULL,D2, format, name);
+
+ vfree(D1);
+ vfree(D2);
+ free_aln (A);
+ free_aln (EA);
+ return 1;
+ }
+int main_output (Sequence_data_struc *D1, Sequence_data_struc *D2, Sequence_data_struc *DST, char *out_format, char *out_file)
+
+ {
+ FILE *fp;
+ int value;
+ Alignment *BUF_A;
+ int expanded=0;
+
+ if ( !out_format[0])return 0;
+ if ( D1 && D1->rm_gap)ungap_aln ((D1->A));
+
+ if ( (strstr (out_format, "expanded_")))
+ {
+ if (!D1) return 1;
+ out_format+=strlen ("expanded_");
+ BUF_A=copy_aln (D1->A, NULL);
+ (D1->A)=thread_profile_files2aln ((D1->A), NULL, NULL);
+ expanded=1;
+ }
+
+ if ( strm (out_format, ""))return 0;
+ else if ( ( strm (out_format, "aln2lib")))
+ {
+ int a, b, c;
+ int r1,r2,s1, s2,s;
+ Constraint_list *CL;
+ FILE *fp;
+ Alignment *IN;
+ int **pos;
+
+ if (!D1)return 1;
+ IN=D1->A;
+ CL=(D1->A)->CL;
+ pos=aln2pos_simple(IN, IN->nseq);
+ fp=vfopen (out_file, "w");
+ fp=save_list_header (fp,CL);
+
+
+ for ( b=0; b< IN->nseq-1; b++)
+ {
+ for ( c=b+1; c< IN->nseq; c++)
+ {
+ s1=IN->order[b][0];
+ s2=IN->order[c][0];
+ fprintf ( fp, "#%d %d\n", s1+1, s2+1);
+ for ( a=0; a< IN->len_aln; a++)
+ {
+ r1=pos[b][a];
+ r2=pos[c][a];
+
+ if ( s1==s2 && !CL->do_self)continue;
+
+ if ( s1< s2)s=(CL->evaluate_residue_pair)( CL, s1, r1, s2, r2);
+ else s=(CL->evaluate_residue_pair)( CL, s2, r2, s1, r1);
+
+ s=(s!=UNDEFINED)?s:0;
+ if ( r1>0 && r2>0)
+ {
+ fprintf (fp, "\t%5d %5d %5d \n", r1, r2, s);
+ }
+ }
+ }
+ }
+ vfclose (save_list_footer (fp, CL));
+ }
+ else if ( strncmp (out_format, "score",5)==0 || strm (out_format, "html"))
+ {
+ Alignment *BUF;
+
+ if (!D1)return 1;
+ if ( !DST)
+ {
+ fprintf ( stderr,"\n[You Need an evaluation File: Change the output format or use +evaluate][FATAL:%s]\n", PROGRAM);
+ myexit(EXIT_FAILURE);
+ }
+ if ( !strm ("html", out_format))while ( out_format[0]!='_' && out_format[0]!='\0' )out_format++;
+
+ D1->S=aln2seq(D1->A);
+ BUF=copy_aln (DST->A, NULL);
+ DST->A=aln2number (DST->A);
+
+ if ( strstr ( out_format, "html" ))output_reliability_html ( D1->A, DST->A, out_file);
+ else if( strm ( out_format, "_ps" ))output_reliability_ps ( D1->A, DST->A, out_file);
+ else if( strm ( out_format, "_pdf" ))output_reliability_pdf ( D1->A, DST->A, out_file);
+ else if( strm ( out_format, "_ascii" ))output_reliability_ascii ( D1->A, DST->A, out_file);
+ else if( strm ( out_format, "_seq" ))output_seq_reliability_ascii ( D1->A, DST->A, out_file);
+ else
+ {
+ DST->A=BUF;
+ main_output (DST, NULL, NULL, out_format+1, out_file);
+ }
+ }
+ else if (strm (out_format, "sec_html") || strm (out_format, "_E_html"))
+ {
+ Alignment *ST, *A;
+ Sequence *S;
+
+ int a, b,c,i, ns=0;
+ char *buf;
+ if (!D1)return 1;
+ A=D1->A;
+
+
+ S=A->S;
+ ST=copy_aln (A, NULL);
+ for (a=0; a<ST->nseq; a++)
+ {
+ i=name_is_in_list (ST->name[a],S->name, S->nseq, 100);
+ if ( i!=-1)
+ {
+ buf=seq2E_template_string(S, i);
+ if ( buf==NULL)continue;
+ else ns++;
+ for (c=0,b=0; b<ST->len_aln; b++)
+ {
+ int r1, s;
+ r1=ST->seq_al[a][b];
+ if ( r1!='-')
+ {
+ s=tolower (buf[c]);
+ if (s=='e')r1='0';
+ else if (s=='h')r1='9';
+ else if (s=='c')r1='5';
+ c++;
+ }
+ ST->seq_al[a][b]=r1;
+ }
+ }
+ }
+
+ if (!ns)
+ {
+ add_warning ( stderr, "Cannot output tm_html:_E_ template file (sec. struc.) is required for this output ", PROGRAM);
+ }
+ output_color_html ( A, ST, out_file);
+ }
+ else if (strm (out_format, "tm_html") || strm (out_format, "_T_html"))
+ {
+ Alignment *ST, *A;
+ Sequence *S;
+
+ int a, b,c,i, ns=0;
+ char *buf;
+ if (!D1)return 1;
+ A=D1->A;
+ A->output_tm = 1;
+
+ S=A->S;
+ ST=copy_aln (A, NULL);
+ for (a=0; a<ST->nseq; a++)
+ {
+ i=name_is_in_list (ST->name[a],S->name, S->nseq, 100);
+ if ( i!=-1)
+ {
+ buf=seq2T_template_string(S, i);
+ if ( buf==NULL)continue;
+ else ns++;
+ for (c=0,b=0; b<ST->len_aln; b++)
+ {
+ int r1, s;
+ r1=ST->seq_al[a][b];
+ if ( r1!='-')
+ {
+ s=tolower (buf[c]);
+ if (s=='o')r1='0';
+ else if (s=='h')r1='9';
+ else if (s=='i')r1='5';
+ c++;
+ }
+ ST->seq_al[a][b]=r1;
+ }
+ }
+ }
+
+ if (!ns)
+ {
+ add_warning ( stderr, "Cannot output tm_html:_T_ template file (trans. Memb. ) is required for this output ", PROGRAM);
+ }
+ output_color_html ( A, ST, out_file);
+ }
+
+ else if (strm (out_format, "color_exoset"))
+ {
+ Alignment *ST, *EX, *A;
+ Constraint_list *CL;
+ int a, b, n;
+ char *buf;
+
+ if ( !DST->A)
+ {
+ printf_exit ( EXIT_FAILURE, stderr, "\nYou must provide an obj file via the -struc_in flag [FATAL:%s]", PROGRAM);
+ }
+ EX=DST->A;
+ A=D1->A;
+
+ CL=declare_constraint_list ( DST->S,NULL, NULL, 0,NULL, read_matrice("pam250mt"));
+
+ ST=copy_aln (A, NULL);
+ buf=vcalloc ( EX->len_aln+1, sizeof (int));
+
+ for ( a=0; a< A->nseq; a++)
+ {
+ int i;
+
+ i=name_is_in_list (A->name[a],EX->name, EX->nseq, -1);
+ if ( i==-1)continue;
+
+ sprintf ( buf, "%s", EX->seq_al[i]);
+ ungap (buf);
+
+ for (n=0,b=0; b<A->len_aln; b++)
+ {
+ if (!is_gap(A->seq_al[a][b]))
+ {
+ if ( buf[n]=='o')
+ ST->seq_al[a][b]='0';
+ else if ( buf[n]=='j')
+ ST->seq_al[a][b]='1';
+ else if ( buf[n]=='b')
+ ST->seq_al[a][b]='2';
+ n++;
+ }
+ }
+ }
+ vfree (buf);
+
+ output_color_html ( A, ST, out_file);
+ return EXIT_SUCCESS;
+ }
+
+ else if (strm (out_format, "color_protogene"))
+ {
+ int n, a, b;
+ DST->A=copy_aln (D1->A, NULL);
+ for (n=1,a=0; a< (D1->A)->len_aln; a++, n++)
+ {
+ for ( b=0; b<(D1->A)->nseq; b++)
+ {
+ if (is_gap((D1->A)->seq_al[b][a]));
+ else if ( n<=3)(DST->A)->seq_al[b][a]=2;
+ else if ( n>3)(DST->A)->seq_al[b][a]=9;
+ }
+
+ if ( n==6)n=0;
+ }
+ output_color_html ( D1->A, DST->A, out_file);
+ return EXIT_SUCCESS;
+
+ }
+ else if ( strncmp (out_format, "color",5)==0)
+ {
+ Alignment *BUF;
+
+ if (!D1)return 1;
+
+ if ( !DST)
+ {
+ fprintf ( stderr,"\n[You Need an evaluation File: Change the output format or use +evaluate][FATAL:%s]\n", PROGRAM);
+ myexit(EXIT_FAILURE);
+ }
+ while ( out_format[0]!='_' && out_format[0]!='\0' )out_format++;
+
+ BUF=copy_aln (DST->A, NULL);
+
+
+
+
+ if ( strm ( out_format, "_html" ))output_color_html ( D1->A, DST->A, out_file);
+ else if( strm ( out_format, "_ps" ))output_color_ps ( D1->A, DST->A, out_file);
+ else if( strm ( out_format, "_pdf" ))output_color_pdf ( D1->A, DST->A, out_file);
+ else if( strm ( out_format, "_ascii" ))output_color_ascii ( D1->A, DST->A, out_file);
+ else
+ {
+ DST->A=BUF;
+ return main_output (DST, NULL, NULL, out_format+1, out_file);
+ }
+ return EXIT_SUCCESS;
+ }
+ else if ( strm4 ( out_format, "tc_aln","t_coffee_aln", "t_coffee", "tcoffee"))
+ {
+ if (!D1)return 1;
+ vfclose (output_aln ( D1->A, vfopen (out_file, "w")));
+ }
+ else if ( strm ( out_format, "analyse_pdb"))
+ {
+ if (!D1)return 1;
+ if ( !DST)
+ {
+ fprintf ( stderr,"\n[You Need an evaluation File: Change the output format][FATAL:%s]\n", PROGRAM);
+ myexit(EXIT_FAILURE);
+ }
+ analyse_pdb ( D1->A,DST->A, "stdout");
+ (DST->A)=aln2number (DST->A);
+ output_reliability_ps ( D1->A, DST->A, out_file);
+ }
+ else if ( strm4 ( out_format, "lower0", "lower1", "lower2", "lower3") || strm4(out_format, "lower4", "lower5", "lower6", "lower7") || strm4 (out_format,"lower8", "lower9", "align_pdb", "malign_pdb") )
+ {
+ if (!D1)return 1;
+ if ( !DST)
+ {
+ fprintf ( stderr,"\n[You Need an evaluation File: Change the output format][FATAL:%s]\n", PROGRAM);
+ myexit(EXIT_FAILURE);
+ }
+
+
+
+ (DST->A)=aln2number (DST->A);
+ if ( strm (out_format, "align_pdb"))value=0;
+ else if ( strm (out_format, "malign_pdb"))value=5;
+ else value=atoi(out_format+5);
+
+ D1->A=filter_aln_upper_lower (D1->A, DST->A,0, value);
+ output_clustal_aln ( out_file, D1->A);
+ }
+ else if ( strnm (out_format, "repeat", 6))
+ {
+ int size;
+ int a, b, c;
+ Alignment *CONC;
+
+ if ( !D1)return 1;
+ size=atoi (out_format+6);
+ print_aln (D1->A);
+ CONC=declare_aln2 ( (D1->A)->nseq, ((D1->A)->len_aln+1)*size+1);
+
+ for ( a=0; a< (D1->A)->nseq; a++)(D1->A)->seq_al[a][(D1->A)->len_aln]='\0';
+ for ( c=0,a=0; a< (D1->A)->nseq;c++)
+ {
+
+ sprintf ( CONC->name[c], "%s", (D1->A)->name[a]);
+ for ( b=0; b<size; b++, a++)
+ {
+ strcat (CONC->seq_al[c], (D1->A)->seq_al[a]);
+ strcat (CONC->seq_al[c], "O");
+ }
+ }
+ CONC->nseq=c;CONC->len_aln=strlen (CONC->seq_al[0]);
+ output_clustal_aln ( out_file, CONC);
+ free_aln (CONC);
+ }
+
+ else if ( strnm (out_format, "upper", 5))
+ {
+
+ if (!D1)return 1;
+ if ( !DST)
+ {
+ fprintf ( stderr,"\n[You Need an evaluation File: Change the output format][FATAL:%s]\n", PROGRAM);
+ myexit(EXIT_FAILURE);
+ }
+
+
+ (DST->A)=aln2number (DST->A);
+
+ value=atoi(out_format+5);
+
+ D1->A=filter_aln_lower_upper (D1->A, DST->A,0, value);
+ output_clustal_aln ( out_file, D1->A);
+ }
+
+ else if ( strm4 ( out_format, "filter0", "filter1", "filter2", "filter3"))
+ {
+ if (!D1)return 1;
+ if ( !DST)
+ {
+ fprintf ( stderr,"\n[You Need an evaluation File: Change the output format][FATAL:%s]\n", PROGRAM);
+ myexit(EXIT_FAILURE);
+ }
+
+ (DST->A)=aln2number (DST->A);
+
+ D1->A=filter_aln (D1->A, DST->A, atoi(out_format+6));
+ output_clustal_aln ( out_file, D1->A);
+ }
+
+ else if ( strm3 ( out_format, "phylip_aln", "phylip", "phy"))
+ {
+ if (!D1)return 1;
+ output_phylip_aln ( out_file, D1->A);
+ }
+ else if ( strm ( out_format, "mocca_aln"))
+ {
+ if (!D1)return 1;
+ output_mocca_aln ( out_file, D1->A, DST->A);
+ }
+ else if ( strm ( out_format, "saga_pw_sd_weights") )
+ {
+ if (!D1)return 1;
+ output_pw_weights4saga ((D1->W),(D1->W)->PW_SD, out_file);
+ }
+ else if ( strm ( out_format, "saga_aln"))
+ {
+ if (!D1)return 1;
+ output_saga_aln (out_file, D1->A);
+ }
+ else if (strm2 ( out_format, "aln","clustal_tc")|| strm (out_format, "msa"))
+ {
+
+ if (!D1)return 1;
+ output_clustal_aln (out_file, D1->A);
+ }
+ else if (strm5 ( out_format, "strict_clustal","clustal_aln", "clustalw","clustal", "clustalw_aln") || strm (out_format,"number_aln"))
+ {
+ if (!D1)return 1;
+ output_strict_clustal_aln (out_file, D1->A);
+ }
+ else if ( strm ( out_format, "conc_aln"))
+ {
+ if (!D1)return 1;
+ output_conc_aln (out_file, D1->A);
+ }
+ else if ( strm2 ( out_format, "lalign_aln","lalign"))
+ {
+ if (!D1)return 1;
+ output_lalign (out_file, D1->A);
+ }
+ else if ( strm2 ( out_format, "glalign_aln","glalign"))
+ {
+ if (!D1)return 1;
+ output_glalign (out_file, D1->A, DST->A);
+ }
+
+ else if ( strm2 ( out_format, "fasta_aln","fasta" ) || strm (out_format, "blast_aln"))
+ {
+ if (!D1)return 1;
+ output_fasta_aln( out_file, D1->A);
+ }
+ else if ( strstr (out_format, "overaln"))
+ {
+
+ char *s, mode[100];
+ OveralnP *F;
+ int eb=0;
+ if (!D1) return 1;
+ F=vcalloc (1, sizeof (OveralnP));
+ ungap_aln (D1->A);
+ string_array_upper ((D1->A)->seq_al, (D1->A)->nseq);
+ if ( D2 && D2->A)
+ {
+ D1->A=mark_exon_boundaries (D1->A, D2->A);
+ eb=1;
+ }
+ else if ( (s=get_string_variable ("exon_boundaries")))
+ {
+ Sequence *S;
+ Alignment *EB;
+ EB=seq2aln(S=main_read_seq(s),NULL, 0);
+ D1->A=mark_exon_boundaries (D1->A, EB);
+ free_sequence (S, S->nseq); free_aln (EB);
+ eb=1;
+ }
+ if ( strstr (out_format, "lower")) sprintf (F->mode,"lower");
+ else if (strstr (out_format, "unalign2"))sprintf (F->mode, "unalign2");
+ else if (strstr (out_format, "unalign"))sprintf (F->mode, "unalign");
+ else sprintf (F->mode, "%s", ((s=get_string_variable ("overaln_mode")))?s:"lower");
+ if (!strm (F->mode, "lower") && !strm (F->mode, "unalign") && !strm (F->mode, "unalign2"))printf_exit (EXIT_FAILURE,stderr,"\nERROR: unknown overaln_mode in overaln output [%s] [FATAL:%s]", mode, PROGRAM);
+
+ if (int_variable_isset ("overaln_threshold"))F->t=get_int_variable ("overaln_threshold");
+ if (int_variable_isset ("overaln_target"))F->f=get_int_variable ("overaln_target");
+ if (int_variable_isset ("overaln_P1"))F->p1=get_int_variable ("overaln_P1");
+ if (int_variable_isset ("overaln_P2"))F->p2=get_int_variable ("overaln_P2");
+ if (int_variable_isset ("overaln_P3"))F->p3=get_int_variable ("overaln_P3");
+ if (int_variable_isset ("overaln_P4"))F->p4=get_int_variable ("overaln_P4");
+
+ if (eb)sprintf (F->model, "fsa2");
+ else sprintf (F->model, "fsa1");
+ D1->A=aln2clean_pw_aln (D1->A, F);
+
+ //if (eb)D1->A=aln2clean_pw_aln (D1->A, mode,t, f,p1,p2,p3, "fsa2");
+ //else D1->A=aln2clean_pw_aln (D1->A, mode,t, f,p1,p2,p3, "fsa1");
+
+ D1->S=aln2seq(D1->A);
+ output_clustal_aln (out_file, D1->A);
+ }
+ else if ( strm ( out_format, "est_prf" ))
+ {
+ if (!D1)return 1;
+ output_est_prf( out_file, D1->A);
+ }
+ else if ( strm ( out_format, "clean_est_fasta_seq" ))
+ {
+ if (!D1)return 1;
+ D1->A=clean_est(D1->A);
+ output_fasta_seq(out_file, D1->A);
+
+ }
+
+ else if ( strm3 ( out_format, "msf_aln", "gcg", "msf"))
+ {
+ if (!D1)return 1;
+ output_msf_aln( out_file, D1->A);
+ }
+ else if ( strm ( out_format, "rnalign"))
+ {
+ if (!D1)return 1;
+ output_rnalign (out_file, D1->A, DST->S);
+ }
+ else if ( strm ( out_format, "tblastx_db1"))
+ {
+ seq2tblastx_db (out_file,D1->S,1);
+ }
+ else if ( strm ( out_format, "tblastx_db") || strm (out_format, "tblastx_db3"))
+ {
+ seq2tblastx_db (out_file,D1->S,3);
+ }
+ else if ( strm ( out_format, "tblastx_db2"))
+ {
+ seq2tblastx_db (out_file,D1->S,2);
+ }
+ else if ( strm ( out_format, "fasta_seq") ||strm ( out_format, "list")||strm ( out_format, "file_list"))
+ {
+
+ if (!D1)return 1;
+ output_fasta_seq (out_file,D1->A);
+ }
+ else if (strm (out_format, "fasta_tree") )
+ {
+ if (!D1)return 1;
+ output_fasta_tree (out_file,D1->A);
+ }
+
+ else if ( strm ( out_format, "gotoh_seq"))
+ {
+ if (!D1)return 1;
+ output_gotoh_seq (out_file,D1->A);
+ }
+ else if ( strm (out_format, "fasta_seq1"))
+ {
+ if (!D1)return 1;
+ output_fasta_seq1 (out_file, D1->A);
+ }
+ else if ( strm2 (out_format, "pir_aln", "pir"))
+ {
+ if (!D1)return 1;
+ output_pir_aln (out_file, D1->A);
+ }
+ else if ( strm (out_format, "pir_seq"))
+ {
+ if (!D1)return 1;
+ output_pir_seq (out_file, D1->A);
+ }
+ else if ( strm (out_format, "gor_seq"))
+ {
+ if (!D1)return 1;
+ output_gor_seq (out_file, D1->A);
+ }
+ else if ( strm (out_format, "pir_seq1"))
+ {
+ if (!D1)return 1;
+ output_pir_seq1 (out_file, D1->A);
+ }
+ else if ( strm (out_format, "pw_lib_saga_aln"))
+ {
+ if (!D1)return 1;
+ output_pw_lib_saga_aln (out_file, D1->A);
+ }
+ else if ( strm (out_format, "lib"))
+ {
+ if (!D1)return 1;
+ output_lib (out_file, D1->A);
+ }
+ else if ( strm (out_format, "pdb_constraint_list"))
+ {
+ if (!D1)return 1;
+ output_constraints (out_file, "pdb",D1->A);
+ }
+ else if ( strm2 (out_format, "constraint_list","tc_lib"))
+ {
+
+ if (!D1)return 1;
+ else if (!D1->CL)output_constraints (out_file,"sim", D1->A);
+ else if (D1->CL) vfclose ( save_constraint_list ( D1->CL, 0, (D1->CL)->ne, out_file, NULL, "ascii",(D1->CL)->S));
+ }
+ else if ( strm2 (out_format, "extended_lib","extended_cosmetic"))
+ {
+ if (!D1)return 1;
+ output_constraints (out_file,out_format, D1->A);
+ }
+ else if ( strncmp (out_format, "extended_pair", 13)==0)
+ {
+ if (!D1)return 1;
+ output_constraints (out_file,out_format, D1->A);
+ }
+ else if ( strm (out_format, "cache_id"))
+ {
+ if (!D1)return 1;
+ cache_id (D1->A);
+ output_saga_aln (out_file, D1->A);
+ }
+ else if ( strm (out_format, "compress_aln"))
+ {
+ if (!D1)return 1;
+ compress_aln (D1->A);
+ output_saga_aln (out_file, D1->A);
+ }
+ else if (strm (out_format, "n_seq") ||strm (out_format, "nseq") )
+ {
+ if (!D1)return 1;
+ fp=vfopen ( out_file, "w");
+ fprintf ( fp, "%d\n", (D1->A)->nseq);
+ vfclose (fp);
+ }
+
+ else if ( strm ( out_format, "thread_dna_on_prot_aln"))
+ {
+ if (!D1)return 1;
+ D1->A=thread_dnaseq_on_prot_aln (D1->S, D2->A);
+ output_saga_aln ( out_file, D1->A);
+ }
+ else if ( strm ( out_format, "tdna_fasta_seq1"))
+ {if (!D1)return 1;
+ D1->A=translate_dna_aln (D1->A,0);
+ output_fasta_seq1 (out_file, D1->A);
+ }
+ else if (strm (out_format, "exons"))
+ {
+ Alignment *A;
+ //exons come in upper case
+ //output alternates them upper/lower
+ if (!D1)return 1;
+ A=copy_aln (D1->A, NULL);
+ A->seq_al=gene2exons(A->seq_al,A->nseq);
+ output_fasta_seq (out_file,A);
+ free_aln (A);
+ }
+ else if ( strm (out_format, "wexons"))
+ {
+ if (!D1)return 1;
+ output_wexons (out_file,D1->A);
+
+ }
+ else if ( strm (out_format, "texons"))
+ {
+ Alignment *A;
+ Sequence *S;
+ //exons come in upper case
+ //output alternate amino acids in upper/lower case
+ //amino acid has the case of its first nucleotide
+ if (!D1)return 1;
+ A=copy_aln (D1->A, NULL);
+ A->seq_al=gene2exons(A->seq_al,A->nseq);
+ S=aln2seq(A);
+ output_fasta_seqS (out_file,S=translate_dna_seqS(S,1,'X'));
+ }
+ else if ( strm (out_format, "sexons"))
+ {
+ Alignment *A;
+
+ //exons come in upper case
+ //output alternate amino acids in upper/lower case
+ //amino acid has the case of its first nucleotide
+ if (!D1)return 1;
+ A=copy_aln (D1->A, NULL);
+ output_fasta_seq ( out_file, D1->A);
+ }
+
+ else if ( strm ( out_format, "tdna_aln"))
+ {if (!D1)return 1;
+ D1->A=translate_dna_aln (D1->A,0);
+ output_saga_aln ( out_file, D1->A);
+ }
+ else if ( strm ( out_format, "cdna_fasta_seq1"))
+ {if (!D1)return 1;
+ D1->A= gene2prot(D1->A);
+ output_fasta_seq1 ( out_file, D1->A);
+ }
+ else if ( strm ( out_format, "mutate_cdna_aln"))
+ {if (!D1)return 1;
+ D1->A= mutate_cdna_aln ( D1->A);
+ output_clustal_aln ( out_file, D1->A);
+ }
+ else if ( strm ( out_format, "tdna_sp_aln"))
+ { if (!D1)return 1;
+ if ( !DST)
+ {
+ fprintf ( stderr,"\n[You Need an evaluation File: Change the output format][FATAL:%s]\n", PROGRAM);
+ myexit(EXIT_FAILURE);
+ }
+ (DST->A)=aln2number (DST->A);
+ D1->A=translate_splice_dna_aln (D1->A, DST->A);
+ output_saga_aln ( out_file, D1->A);
+ }
+ else if (out_format && out_format[0] && (strcmp ( out_format,"rna_graph_fasta")==0))
+ {
+ if (!D1)return 1;
+ sprintf ( (D1->A)->seq_al[0], "%s",(DST->S)->seq[0]);
+ (D1->A)->nseq=0;
+ output_fasta_seq (out_file, DST->A);
+ }
+ else if (strm ( out_format, "freq_mat"))
+ {
+ if (!D1)return 1;
+ output_freq_mat (out_file, D1->A);
+ }
+ else if (strm ( out_format, "maln_pval"))
+ {if (!D1)return 1;
+ output_maln_pval ( out_file, D1->A);
+ }
+ else if ( strm ( out_format, "model_aln"))
+ {
+ if (!D1)return 1;
+ output_model_aln ( out_file, D1->A);
+ }
+ else if (strncmp (out_format, "mult",4)==0)
+ {
+ if (!D1)return 1;
+ output_mult_fasta_seq ( out_file, D1->A, atoi(out_format+4));
+ }
+ else if (strm (out_format, "conservation"))
+ {
+ output_conservation_statistics (out_file, D1->A);
+ }
+ else if (strm (out_format, "len"))
+ {
+ if (!D1)return 1;
+ output_statistics (out_file, D1->A, "nrl");
+ }
+ else if ( strm (out_format, "name"))
+ {
+ if (!D1)return 1;
+ if ( D1->A)output_statistics (out_file, D1->A, "n");
+ if ( D1->T)
+ {
+ Sequence *TS;
+ TS=tree2seq(D1->T, NULL);print_array_char (vfopen(out_file, "w"), TS->name, TS->nseq, "\n");
+ }
+ }
+ else if ( strm (out_format, "code_name"))
+ {
+ char **nl=NULL;
+ int num, n=0;
+ Sequence *TS;
+ FILE *lfp;
+ if ( D1->A){n=(D1->A)->nseq, nl=(D1->A)->name;}
+ if ( D1->T){TS=tree2seq(D1->T, NULL);nl=TS->name;n=TS->nseq;}
+
+ lfp=vfopen (out_file, "w");
+ for ( num=0; num<n; num++)
+ fprintf (lfp, "\n%s C%d", nl[num], num+1);
+ fprintf (lfp, "\n");
+ vfclose (lfp);
+ }
+ else if ( strm ( out_format, "seq2struc"))
+ {
+ output_seq2struc (out_file, D1->A);
+ }
+ else if ( strstr ( out_format, "pavie_age_channel"))
+ {
+ output_n_pavie_age_channel ( D1->S,out_file, atoi((out_format+strlen ("pavie_age_channel"))));
+ return EXIT_SUCCESS;
+ }
+ else if ( strstr ( out_format, "age_matrix"))
+ {
+ output_age_matrix (out_file, atoi((out_format+10)));
+ }
+ else if ( strm ( out_format, "transitions"))
+ {
+ output_transitions (out_file, D1->A);
+ }
+
+ else if ( strncmp (out_format, "statistics",10)==0)
+ {
+ if (!D1)return 1;
+
+ output_statistics (out_file, D1->A,out_format+10);
+ }
+
+
+
+
+ else if ( strm4 (out_format, "newick_tree","newick","binary","nh"))
+ {
+ if (!D1)return 1;
+
+ /*D1->T=unroot_tree(D1->T);*/
+ vfclose (print_tree ((D1->T), out_format, vfopen ( out_file, "w")));
+ }
+ else if ( strncmp (out_format, "sarsim", 6)==0)
+ {
+ if (!D1)return 1;
+ compare_sar_sequence (D1->S, (D2 &&D2->S)?D2->S:D1->S, atoi(out_format+6));
+ return EXIT_SUCCESS;
+ }
+ else if ( strncmp (out_format, "sim",3)==0)
+ {
+ if (!D1)return 1;
+ output_similarities (out_file, D1->A,out_format);
+ }
+
+ else if ( strncmp (out_format, "cov",3)==0)
+ {
+ if (!D1)return 1;
+ output_similarities (out_file, D1->A,out_format);
+ }
+ else if ( strm (out_format, "stockholm_aln"))
+ {
+ output_stockholm_aln (out_file,D1->A, (D2)?D2->A:NULL);
+ }
+ else if ( strm (out_format, "pair_sim"))
+ {
+ if ( !D2)
+ {
+ fprintf ( stderr, "\n-output=pair_sim: provide aln1 via -in and aln2 via -in2 [FATAL:%s]\n", PROGRAM);
+ myexit (EXIT_FAILURE);
+ }
+ output_similarities_pw (out_file, D1->A,D2->A,out_format);
+ }
+ else if ( strm (out_format, "matrix") || strm (out_format, "blast_matrix"))
+ {
+ output_blast_mat (D1->M, out_file);
+ }
+ else if ( strm (out_format, "header_matrix"))
+ {
+ output_header_mat(D1->M, out_file);
+ }
+
+ else
+ {
+
+ fprintf ( stderr, "\n%s is an UNKNOWN OUTPUT FORMAT [FATAL:%s]\n",out_format, PROGRAM);
+ myexit (EXIT_FAILURE);
+
+ }
+
+ //Remove the expansion
+ if ( expanded)
+ {
+ free_aln (D1->A);
+ D1->A=BUF_A;
+ }
+ return 0;
+ }
+int is_in_format_list ( char *name)
+ {
+ if ( strcmp ( name, "saga_aln")==0)return 1;
+ if ( strcmp ( name, "number_aln")==0)return 1;
+ if ( strcmp ( name, "clustal_aln")==0)return 1;
+ if ( strcmp ( name, "fasta_aln")==0)return 1;
+ if ( strcmp ( name, "number_fasta")==0)return 1;
+ if ( strcmp ( name, "fasta_seq")==0)return 1;
+ if ( strcmp ( name, "pdb")==0)return 1;
+ if ( strcmp ( name, "msf_aln")==0)return 1;
+ if ( strcmp ( name, "dali_aln")==0)return 1;
+ if ( strcmp ( name, "dali_seq")==0)return 1;
+ if ( strcmp ( name, "barton_list_tc")==0)return 1;
+ if ( strcmp ( name, "est_prf")==0)return 1;
+
+ if ( strcmp ( name, "gotoh_aln")==0)return 1;
+ if ( strcmp ( name, "amps_aln")==0)return 1;
+ if ( strcmp ( name, "pir_aln")==0)return 1;
+ if ( strcmp ( name, "pir_seq")==0)return 1;
+ if ( strcmp ( name, "est_fasta")==0)return 1;
+ if ( strcmp ( name, "amps_sd_scores")==0)return 1;
+ if ( strcmp ( name, "pima_aln")==0)return 1;
+ if ( strcmp ( name, "dialign_aln")==0)return 1;
+ if ( strcmp ( name, "gor_seq")==0)return 1;
+ if ( strcmp ( name, "gor_struc")==0)return 1;
+ if ( strcmp ( name, "stockholm_aln")==0)return 1;
+
+ return 0;
+ }
+int is_struc_in_format_list ( char *name)
+ {
+ if ( strcmp ( name, "rna_number")==0)return 1;
+ if ( strcmp ( name, "fasta_seq")==0)return 1;
+ return 0;
+ }
+char *format_name2aln_format_name (char *name)
+ {
+ if ( strm (name, "gcg"))sprintf (name, "msf");
+ else if ( strm (name, "fasta"))sprintf (name, "fasta_aln");
+ return name;
+ }
+int is_out_format_list ( char *name)
+ {
+ return main_output (NULL, NULL, NULL, name, NULL);
+ }
+
+int is_struc_out_format_list ( char *name)
+ {
+ return main_output (NULL, NULL, NULL, name, NULL);
+ }
+
+/**************************************************************************************************/
+/*************************************REFORMAT UTIL*************************************************/
+/**************************************************************************************************/
+
+/*************************************REFORMAT IN**************************************************/
+/**************************************************************************************************/
+/*******************************************************************************************/
+/* */
+/* */
+/* READ COG FILE */
+/* */
+/***************************************************************************************** */
+
+/*******************************************************************************************/
+/* */
+/* */
+/* INPUT WEIGHTS */
+/* */
+/***************************************************************************************** */
+
+Weights* get_amps_sd_scores ( char *fname)
+ {
+ FILE *fp;
+ char *buf;
+ char *buf2;
+ int nseq;
+ Weights *W;
+ int a, b,e;
+ int c;
+ float array[20];
+
+ buf=vcalloc ( 1001, sizeof (char));
+ buf2=vcalloc ( 1001, sizeof (char));
+
+ fp=vfopen ( fname, "r");
+ set_fp_id ( fp, "Index");
+ buf=fgets ( buf, 1000, fp);
+ fscanf ( fp, "%s", buf2);
+
+ nseq=0;
+ while ( isalnum(buf2[0]) && !isalpha(buf2[0]))
+ {
+ nseq++;
+ buf=fgets ( buf, 1000, fp);
+ fscanf ( fp, "%s", buf2);
+ }
+ vfclose ( fp);
+
+ W=declare_weights (nseq);
+
+ fp=vfopen ( fname, "r");
+ set_fp_id ( fp, "Index");
+ buf=fgets ( buf, 1000, fp);
+ fscanf ( fp, "%s", buf2);
+
+ a=0;
+ while ( isalnum(buf2[0]) && !isalpha(buf2[0]))
+ {
+ fp=set_fp_after_char (fp, '>');
+ fscanf ( fp, "%s",W->seq_name[a]);
+ buf=fgets ( buf, 1000, fp);
+ fscanf ( fp, "%s", buf2);
+ a++;
+ }
+ buf=fgets ( buf, 1000, fp);
+ c=1;
+ while ( c!=0)
+ {
+ for ( e=0; e< 16; e++)
+ {
+ c=fscanf ( fp, "%f", &array[e]);
+ }
+ fscanf ( fp, "\n");
+ if ( c!=0)
+ {
+
+ a=(int)array[0]-1;
+ b=(int)array[1]-1;
+ W->PW_ID[b][a]=W->PW_ID[a][b]=array[9];
+ W->PW_SD[b][a]=W->PW_SD[a][b]=array[14];
+ }
+
+ }
+ vfclose ( fp);
+ sprintf ( W->comments, "SD WEIGHTS GENERATED WITH THE PROGRAM AMPS IN PAIRWISE MODE");
+ vfree ( buf);
+ return W;
+ }
+
+Weights *read_seq_weight (char **name, int nseq, char* seq_weight)
+ {
+ int a, p;
+ Weights *W;
+ float w;
+
+ FILE *fp;
+ char line[LONG_STRING];
+ char sname[MAXNAMES];
+
+
+ /*Read sequence weights:
+ * comment
+ name1 weight1
+ .....
+
+
+ NOTE:
+ weights must be between 0 and 1;
+
+ sequences not in S do not get any weight
+ sequences in S but not in file get a weight of 1
+ */
+ if ( !is_single_seq_weight_file (seq_weight))
+ {
+ fprintf ( stderr, "\nERROR: File %s is not in Format SINGLE_SEQ_WEIGHT_FORMAT_01 [FATA:%s]", seq_weight,PROGRAM);
+ myexit (EXIT_FAILURE);
+ return NULL;
+ }
+ else
+ {
+ W=declare_weights(nseq);
+ for ( a=0; a< nseq; a++)
+ {
+ sprintf ( W->seq_name[a], "%s", name[a]);
+ W->SEQ_W[a]=1;
+ }
+ sprintf ( W->mode, "%s", seq_weight);
+ fp=vfopen (seq_weight, "r");
+
+
+ while ( fgets( line,LONG_STRING-1, fp))
+ {
+ if ( line[0]=='*' ||line[0]=='#' || isblanc(line));
+ else
+ {
+ if (sscanf(line, "%s %f", sname, &w)!=2)continue;
+ if ( (p=name_is_in_list ( sname, W->seq_name, nseq, MAXNAMES-1))!=-1)
+ {
+ W->SEQ_W[p]=w;
+ }
+ }
+ }
+ vfclose (fp);
+ return W;
+ }
+ }
+
+
+/*******************************************************************************************/
+/* */
+/* */
+/* INPUT MISC */
+/* */
+/***************************************************************************************** */
+
+char *** read_rename_file ( char *fname, int code)
+{
+ int n;
+ FILE *fp;
+ char ***convert=NULL;
+
+ convert=declare_arrayN(3, sizeof (char),count_n_line_in_file(fname) +1,2,MAXNAMES+1);
+ fp=vfopen (fname, "r");
+ n=0;
+ if ( code==CODE) while ( fscanf ( fp, "%s %s\n", convert[n][0], convert[n][1])==2)n++;
+ else if (code==DECODE)while ( fscanf ( fp, "%s %s\n", convert[n][1], convert[n][0])==2)n++;
+ vfclose (fp);
+ return convert;
+}
+
+void get_barton_list_tc_seq ( char *in_file)
+ {
+ FILE *fp, *fp_make, *fp_length, *fp_long;
+ FILE *fp_small[9];
+
+ static char *buf;
+ int len_buf=10000;
+ char name[100];
+
+ char pwd[100];
+ int a,c,nseq;
+ int k=0;
+ int *length;
+ int longest=0;
+
+ c=0;
+ length=vcalloc ( 1000, sizeof(int));
+ if ( buf==NULL)buf=vcalloc ( len_buf, sizeof (char));
+ fp=vfopen (in_file, "r");
+ fp_long=vfopen ( "barton_seq_list_large", "w");
+ fp_make=vfopen ( "make_dir", "w");
+ fp_length=vfopen ( "barton_length", "w");
+ for ( a=0; a< 9; a++)
+ {
+ sprintf ( name, "barton_nseq%d",a);
+ fp_small[a]=vfopen ( name, "w");
+ }
+ get_pwd (pwd);
+
+
+ while ( c!=EOF)
+ {a=0;
+ while ( (c=fgetc(fp))!='#');
+ while ( (c=fgetc(fp))=='#');
+ ungetc ( c, fp);
+ while ( (c=fgetc(fp))!='#')buf[a++]=c;
+ buf[a]='\0';
+
+ sprintf ( name, "%s", buf);
+
+ while ( (c=fgetc(fp))=='#');
+
+ if ( c!=EOF)
+ {
+ a=0;
+ while ( (c=fgetc(fp))!='#' && c!=EOF)
+ {
+ buf[a++]=c;
+ if (a==len_buf)
+ {
+ len_buf+=10000;
+ buf=vrealloc ( buf, len_buf*sizeof (char));
+ }
+ }
+ buf[a]='\0';
+ if (c!=EOF)
+ {
+
+ nseq=process_barton_entry ( buf,name);
+ length[nseq]++;
+ longest=(longest<nseq)?nseq:longest;
+
+ if ( nseq<=8) fprintf ( fp_small[nseq], "%s.pep\n", name);
+ else fprintf ( fp_long, "%s.pep\n",name);
+ fprintf ( fp_make, "mkdir %s\nmv %s.pep %s\nmv %s.check %s\n", name, name, name, name, name);
+ k++;
+ }
+
+
+ }
+ }
+
+ vfclose (fp);
+ vfclose (fp_long);
+ for ( a=0; a< 9; a++)vfclose (fp_small[a]);
+ vfclose (fp_make);
+ for ( a=0; a<= longest; a++)fprintf ( fp_length, "%d: %d\n", a, length[a]);
+ vfclose ( fp_length);
+
+ }
+
+int process_barton_entry (char *buf, char *name)
+ {
+ Alignment *LA;
+ Sequence *LS;
+ int a,c;
+ static char *buf2;
+ int clen=0;
+ int current=0;
+ int p=0;
+ int max_len_seq=0;
+ int min_len_seq=999999;
+ int nseq=0;
+ int l;
+ char fname[100];
+ char com_name[100];
+ int rm_gap=1;
+
+ sprintf ( fname, "%s.pep", name);
+ sprintf ( com_name, "%s.check",name);
+
+ if ( buf2==NULL)buf2=vcalloc ( 10000, sizeof (char));
+ a=0;
+ while (buf[a]!='\0')
+ {
+ if (buf[a]=='>')
+ {
+ a=get_string_line (a,2, buf, buf2);
+ while ((c=buf[a++])!='*')
+ if (isalnum (c)|| c=='.' || c=='-')
+ clen++;
+ max_len_seq=(clen> max_len_seq)?clen: max_len_seq;
+ min_len_seq=(clen< min_len_seq)?clen: min_len_seq;
+ nseq++;
+ clen=0;
+ }
+ if ( buf[a]!='\0')a++;
+ }
+
+
+ LS=declare_sequence ( min_len_seq, max_len_seq, nseq);
+ LS->nseq=nseq;
+
+
+ for (a=0, current=0; current< nseq; current++)
+ {
+ a=get_string_line ( a, 1, buf, buf2);
+ sscanf ( buf2, ">P1;%s", LS->name[current]);
+ a=get_string_line ( a, 1, buf, buf2);
+ l=strlen ( buf2);
+ buf2[l-1]='\0';
+ sprintf ( LS->seq_comment[current],"%s", buf2);
+
+ p=0;
+ while ( (c=buf[a++])!='*')
+ {
+ if (isalpha (c))
+ LS->seq[current][p++]=tolower (c);
+ else if ( isgraph(c))
+ LS->seq[current][p++]=(c);
+ }
+ a++;
+ }
+
+ LA=declare_Alignment(LS);
+ seq2aln ( LS, LA,rm_gap);
+ output_fasta_seq (fname,LA);
+ output_pir_check (com_name,LA->nseq, LA->seq_comment);
+ free_Alignment ( LA);
+ free_sequence ( LS, nseq);
+
+ return nseq;
+ }
+
+
+
+
+Structure *read_rna_struc_number (Alignment *A,char *fname)
+ {
+ FILE *fp;
+ int a;
+ char x,y;
+ float f;
+ Sequence *SA;
+ Structure *ST;
+ int first, last;
+
+ SA=declare_sequence ( A->len_aln, A->len_aln, 1);
+ SA->len[0]=A->len[0];
+ for ( a=0; a< SA->len[0]; a++)
+ SA->seq[0][a]='.';
+ ST=declare_rna_structure_num (SA);
+ ST->S=SA;
+
+ fp=vfopen ( fname, "r");
+ fscanf ( fp, "%c\n%d\n",&x, &(ST)->tot_list);
+ for ( a=0; a<(ST)->tot_list; a++)
+ {
+ fscanf ( fp, "%d %d %d %c %c %f\n", &(ST)->list[a][0],&(ST)->list[a][1],&(ST)->list[a][2], &x, &y, &f);
+ (ST)->list[a][0]--;
+ (ST)->list[a][1]--;
+ (ST)->list[a][2]--;
+ if ( a==0)
+ {
+ (ST)->stem[0][0]=(ST)->list[a][0];
+ (ST)->stem[0][1]=a;
+ }
+ else if ( (ST)->stem[(ST)->tot_stem][0]==(ST)->list[a][0]);
+ else if ( (ST)->stem[(ST)->tot_stem][0]!=(ST)->list[a][0])
+ {
+ (ST)->stem[(ST)->tot_stem][2]=a-1;
+ (ST)->tot_stem++;
+ (ST)->stem[(ST)->tot_stem][0]=(ST)->list[a][0];
+ (ST)->stem[(ST)->tot_stem][1]=a;
+ }
+
+ SA->seq[0][(ST)->list[a][1]]='-';
+ SA->seq[0][(ST)->list[a][2]]='-';
+ }
+ (ST)->stem[(ST)->tot_stem][2]=a-1;
+ (ST)->tot_stem++;
+ for ( a=0; a< (ST)->tot_stem; a++)
+ {
+
+ first=(ST)->stem[a][1];
+ last=(ST)->stem[a][2];
+ SA->seq[0][(ST)->list[first][1]]='>';
+ SA->seq[0][(ST)->list[first][2]]='<';
+ SA->seq[0][(ST)->list[last][1]]='>';
+ SA->seq[0][(ST)->list[last][2]]='<';
+ }
+
+ return ST;
+ }
+
+Structure * declare_rna_structure_num (Sequence *SA)
+ {
+ Structure *ST;
+ ST=vcalloc ( 1, sizeof ( Structure));
+ ST->list=declare_int ( SA->len[0], 3);
+ ST->stem=declare_int ( SA->len[0], 3);
+ return ST;
+ }
+char ** read_lib_list (char *name, int *n)
+{
+
+ char **lines;
+ char **list;
+ int a, b, l;
+
+ lines=file2lines (name);
+ l=atoi (lines[0]);
+
+ list=vcalloc (l, sizeof (char*));
+ for ( n[0]=0,a=1; a<l; a++,b++)
+ if ( !strstr (lines[a], "TC_LIB_LIST_FORMAT_01"))list[n[0]++]=lines[a];
+ vfree (lines);
+ return list;
+}
+
+/*******************************************************************************************/
+/* */
+/* */
+/* INPUT SEQ */
+/* */
+/***************************************************************************************** */
+char ***read_group ( char *file)
+{
+ /*Format: Fasta like, the name fo the group followed with the name of the sequences
+ ><Group name> <First Seq> <second seq> ....
+ Groups must NOT be overlaping
+ list[group_index][0]="number of sequences"
+ list[group_index][1]="group name"
+ list[group_index][2...N]="sequence"
+ */
+
+ FILE *fp;
+ char *buf;
+ char ***list;
+ int a, c, l;
+
+
+
+ l=measure_longest_line_in_file (file)+1;
+ buf=vcalloc (l, sizeof (char));
+ list=vcalloc ( count_n_line_in_file (file )+1, sizeof (char**));
+
+ fp=vfopen (file, "r");
+
+ a=0;
+ while ((c=fgetc(fp))!=EOF)
+ {
+ buf=fgets (buf,l-1, fp);
+ if ( c=='>')list[a++]=string2list (buf);
+ }
+ vfclose (fp);
+ vfree (buf);
+ return list;
+}
+
+
+static Sequence* get_pdb_sequence_from_field (char *fname, char *field);
+
+Sequence* get_pdb_sequence (char *fname)
+{
+ Sequence *S;
+
+ if ( (S=get_pdb_sequence_from_field(fname, "SEQRES"))!=NULL);
+ else if ( (S=get_pdb_sequence_from_field(fname, "ATOM"))!=NULL)
+ {
+ add_warning (stderr,"Warning: Read Sequence from ATOM field in %s [%s:WARNING]", fname, PROGRAM);
+ }
+ else
+ {
+ add_warning ( stderr, "\nWARNING: failed to extract sequence from %s [%s:WARNING]\n", fname, PROGRAM);
+ S=NULL;
+ }
+ return S;
+}
+
+
+static Sequence* get_pdb_sequence_from_field (char *fname, char *field)
+{
+ char *tp_name;
+ char *command;
+ char *pdbid;
+ Sequence *S;
+
+
+ command=vcalloc ( LONG_STRING, sizeof (char));
+ tp_name=vtmpnam (NULL);
+ sprintf ( command, "extract_from_pdb -seq_field %s -chain FIRST -infile \'%s\' -mode fasta > %s", field, check_file_exists(fname), tp_name);
+// printf("CO: %s\n", command);
+// char *x = vcalloc ( LONG_STRING, sizeof (char));
+// sprintf(x, "cp %s ~/Desktop/erg.txt", tp_name);
+// my_system(x);
+ if ( getenv4debug ("DEBUG_EXTRACT_FROM_PDB"))fprintf ( stderr, "\n[DEBUG_EXTRACT_FROM_PDB:get_pdb_seq] %s\n", command);
+ my_system ( command);
+
+
+ S=get_fasta_sequence ( tp_name, NULL);
+ if (S==NULL)return NULL;
+
+ if ( (pdbid=get_pdb_id (fname))){sprintf ( S->name[0], "%s",pdbid);vfree (pdbid);}
+ S->nseq=1;
+
+ sprintf ( S->file[0], "%s", fname);
+ S->max_len=S->min_len=S->len[0];
+ if ( S->len[0]==0)
+ {
+ free_sequence (S, -1);
+ S=NULL;
+ }
+
+ vremove ( tp_name);
+ vfree ( command);
+
+ return S;
+}
+
+char * get_pdb_file ( char *fname)
+ {
+ char *file;
+ int a, c;
+ FILE *fp;
+
+
+ a=0;
+ file=vcalloc ( sizeof (char),count_n_char_in_file ( fname)+1);
+ fp=vfopen ( fname, "r");
+ while ( (c=fgetc(fp))!=EOF)file[a++]=c;
+ file[a]='\0';
+ return file;
+ }
+
+Sequence* get_struc_gor ( char *fname)
+ {
+ int nseq, min_len, max_len;
+ int a, c;
+ int len;
+ char name[STRING];
+
+
+ FILE *fp;
+ Sequence *S;
+
+ min_len=max_len=-1;
+ fp=vfopen ( fname, "r");
+ nseq=0;
+ while ( (c=fgetc(fp))!=EOF)
+ {
+ if ( c!='!');
+ else
+ {
+ nseq++;
+ fscanf ( fp, "%s %d", name, &len);
+ if (min_len==-1)min_len=max_len=len;
+ else
+ {
+ min_len=(len>min_len)?min_len:len;
+ max_len=(len>max_len)?len:max_len;
+ }
+ }
+
+ }
+ vfclose (fp);
+
+ S=declare_sequence ( min_len, max_len+1,nseq);
+ S->nseq=0;
+
+ fp=vfopen (fname,"r");
+ while ( (c=fgetc(fp))!=EOF)
+ {
+ if ( c!='!');
+ else
+ {
+ fscanf ( fp, "%s %d\n",S->name[S->nseq], &(S->len[S->nseq]));
+
+ while ( (c=fgetc(fp))!='\n');
+
+ for ( a=0; a<S->len[S->nseq]; a++)
+ fscanf ( fp, " %*c %c %*f %*f %*f\n",&(S->seq[S->nseq][a]));
+
+ S->seq[S->nseq][a]='\0';
+ while ( (c=fgetc(fp))!='!' && c!=EOF);
+ ungetc (c, fp);
+ S->nseq++;
+ }
+
+ }
+ vfclose (fp);
+ return S;
+ }
+
+Sequence* get_sequence_dali (char *fname)
+ {
+ Sequence *LS;
+ FILE *fp;
+ int c;
+
+ char name[100];
+ int clen=0;
+ int current=0;
+ int p=0;
+ int max_len_seq=0;
+ int min_len_seq=999999;
+ int nseq=0;
+
+ if ((fp=vfopen (fname,"r"))==NULL)
+ {printf ( "\nCOULDN'T OPEN %s",fname);
+ myexit(EXIT_FAILURE);
+ }
+ c=fgetc(fp);
+ while (c!=EOF)
+ {
+ if (isdigit(c))
+ {
+ ungetc(c, fp);
+ fscanf (fp, "%s",name);
+ while (!isdigit(c=fgetc(fp)) && c!=EOF)
+ if (isalnum (c) || c=='.' || c=='-')
+ clen++;
+ max_len_seq=(clen> max_len_seq)?clen: max_len_seq;
+ min_len_seq=(clen< min_len_seq)?clen: min_len_seq;
+ nseq++;
+ clen=0;
+ }
+ else
+ c=fgetc (fp);
+ }
+ vfclose (fp);
+
+ LS=declare_sequence ( min_len_seq, max_len_seq+1,nseq);
+ LS->nseq=nseq;
+
+ fp=vfopen (fname,"r");
+
+ current=0;
+ c=fgetc(fp);
+ while (c!=EOF)
+ {
+ if (isdigit(c))
+ {
+ ungetc(c, fp);
+ fscanf_seq_name (fp, LS->name[current]);
+ p=0;
+ while (!isdigit(c=fgetc(fp)) && c!=EOF)
+ {
+ if (isalpha (c))
+ LS->seq[current][p++]=tolower (c);
+ else if ( c=='.')
+ LS->seq[current][p++]='-';
+ else if ( c=='-')
+ LS->seq[current][p++]='-';
+ }
+ LS->seq[current][p]='\0';
+ LS->len[current]=strlen ( LS->seq[current]);
+ current++;
+ }
+ else
+ c=fgetc ( fp);
+ }
+
+ vfclose (fp);
+
+
+ return LS;
+ }
+
+Sequence* get_dialign_sequence (char *fname)
+ {
+ Sequence *LS;
+ FILE *fp;
+ int c;
+
+ char name[10000];
+ int clen=0;
+ int current=0;
+ int p=0;
+ int max_len_seq=0;
+ int min_len_seq=999999;
+ int nseq=0, l=0;
+ char *buf;
+
+ buf=vcalloc ( 1000, sizeof (char));
+ if ((fp=vfopen (fname,"r"))==NULL)
+ {printf ( "\nCOULDN'T OPEN %s",fname);
+ myexit(EXIT_FAILURE);
+ }
+ c=fgetc(fp);
+ while (c!=EOF)
+ {
+ if (c=='>')
+ {fscanf (fp, "%s",name);
+
+ buf=fgets ( buf, 1000, fp);
+ while ((c=fgetc(fp))!='>' && c!=EOF && c!=' ' && c!='\t')
+ if (isalnum (c)|| is_gap(c))
+ clen++;
+ max_len_seq=(clen> max_len_seq)?clen: max_len_seq;
+ min_len_seq=(clen< min_len_seq)?clen: min_len_seq;
+ nseq++;
+ clen=0;
+ }
+ else
+ c=fgetc (fp);
+ }
+ vfclose (fp);
+
+ LS=declare_sequence ( min_len_seq, max_len_seq, nseq);
+ LS->nseq=nseq;
+
+ fp=vfopen (fname,"r");
+
+ current=0;
+ c=fgetc(fp);
+ while (c!=EOF)
+ {
+ if (c=='>')
+ {
+
+ fscanf_seq_name (fp, LS->name[current]);
+ l=strlen ( LS->name[current]);
+ if ( LS->name[current][l-1]==','||LS->name[current][l-1]==',')LS->name[current][l-1]='\0';
+ buf=fgets ( buf, 1000, fp);
+ p=0;
+ while ((c=fgetc(fp))!='>' && c!=EOF && c!=EOF && c!=' ' && c!='\t')
+ if (isalpha (c))
+ LS->seq[current][p++]=tolower (c);
+ else if ( isgraph(c))
+ LS->seq[current][p++]=(c);
+ LS->seq[current][p]='\0';
+ LS->len[current]=strlen ( LS->seq[current]);
+ current++;
+ }
+ else
+ c=fgetc ( fp);
+ }
+
+ vfclose (fp);
+ return LS;
+ }
+
+Sequence* get_pima_sequence (char *fname)
+ {
+ Sequence *LS;
+
+ FILE *fp;
+ int c;
+
+ char name[10000];
+ int clen=0;
+ int current=0;
+ int p=0;
+ int max_len_seq=0;
+ int min_len_seq=999999;
+ int nseq=0, l=0, len=0;
+ char *buf, *buf2;
+ char prefix[1000];
+
+ sprintf ( prefix, "%s",fname);
+
+ buf=strstr(prefix, "-");
+ buf[0]='\0';
+ len=strlen (prefix);
+
+
+
+ buf=vcalloc ( 1000, sizeof (char));
+ if ((fp=vfopen (fname,"r"))==NULL)
+ {printf ( "\nCOULDN'T OPEN %s",fname);
+ myexit(EXIT_FAILURE);
+ }
+ c=fgetc(fp);
+ while (c!=EOF)
+ {
+ if (c=='>')
+ {
+ fscanf_seq_name (fp,name);
+ if ( strlen(name)>=len && strncmp ( name, prefix, len)==0)
+ {
+ c=fgetc(fp);
+ }
+ else
+ {
+
+ buf=fgets ( buf, 1000, fp);
+ while ((c=fgetc(fp))!='>' && c!=EOF)
+ if (isalnum (c)|| is_gap(c))
+ clen++;
+ max_len_seq=(clen> max_len_seq)?clen: max_len_seq;
+ min_len_seq=(clen< min_len_seq)?clen: min_len_seq;
+ nseq++;
+ clen=0;
+ }
+ }
+ else
+ c=fgetc (fp);
+ }
+ vfclose (fp);
+
+ LS=declare_sequence ( min_len_seq, max_len_seq, nseq);
+ LS->nseq=nseq;
+
+ fp=vfopen (fname,"r");
+
+ current=0;
+ c=fgetc(fp);
+ while (c!=EOF)
+ {
+ if (c=='>')
+ {
+ fscanf_seq_name (fp,LS->name[current]);
+ if ( strlen(LS->name[current])>=len && strncmp ( LS->name[current], prefix, len)==0)
+ c=fgetc (fp);
+ else
+ {
+ buf2=strstr (LS->name[current], ".");
+ if ( buf2!=NULL) buf2[0]='\0';
+
+ l=strlen ( LS->name[current]);
+ if ( LS->name[current][l-1]==','||LS->name[current][l-1]==',')LS->name[current][l-1]='\0';
+ buf=fgets ( buf, 1000, fp);
+ p=0;
+ while ((c=fgetc(fp))!='>' && c!=EOF)
+ if (isalpha (c))
+ LS->seq[current][p++]=tolower (c);
+ else if ( isgraph(c))
+ LS->seq[current][p++]=(c);
+ LS->seq[current][p]='\0';
+ LS->len[current]=strlen ( LS->seq[current]);
+ current++;
+ }
+ }
+ else
+ c=fgetc ( fp);
+ }
+
+ vfclose (fp);
+ return LS;
+ }
+
+Sequence* perl_reformat2fasta (char *perl_command, char *fname)
+ {
+ char command[1000];
+ char *file;
+
+ file=vtmpnam (NULL);
+
+ check_program_is_installed ( perl_command,"", perl_command,EMAIL,IS_FATAL);
+ sprintf ( command, "%s %s > %s", perl_command, fname, file);
+ my_system ( command);
+ return get_fasta_sequence (file, NULL);
+ }
+Sequence* get_fasta_sequence_num (char *fname, char *comment_out)
+ {
+ Sequence *LS;
+ char *buffer;
+ FILE *fp;
+ int a;
+
+ int c;
+ char *name;
+ int clen=0;
+ int current=0;
+ int p=0;
+ int max;
+ int max_len_seq=0;
+ int min_len_seq=0;
+ int nseq=0, l=0;
+
+
+
+
+ int *sub;
+
+ buffer=vcalloc (1000, sizeof (char));
+ name=vcalloc ( 100, sizeof (char));
+
+ nseq=count_n_char_x_in_file(fname, '>');
+ min_len_seq=max=count_n_char_in_file(fname);
+ sub=vcalloc (max+1, sizeof (int));
+
+ fp=vfopen (fname,"r");
+
+
+ c=fgetc(fp);
+ while (c!=EOF)
+ {
+ if (c=='>')
+ {
+ fscanf_seq_name (fp,name);
+ while ((c=fgetc(fp))!='\n' && c!=EOF);
+ while ((c=fgetc(fp))!='>' && c!=EOF)
+ if (isalnum (c)|| is_gap(c))
+ clen++;
+ max_len_seq=(clen> max_len_seq)?clen: max_len_seq;
+ min_len_seq=(clen< min_len_seq)?clen: min_len_seq;
+ clen=0;
+ }
+ else
+ c=fgetc (fp);
+
+ }
+
+ vfclose (fp);
+ LS=declare_sequence ( min_len_seq, max_len_seq,nseq);
+
+ LS->nseq=nseq;
+
+ fp=vfopen (fname,"r");
+ current=0;
+ c=fgetc(fp);
+ while (c!=EOF)
+ {
+ if (c=='>')
+ {
+
+ fscanf_seq_name (fp,LS->name[current]);
+ l=strlen ( LS->name[current]);
+ if ( LS->name[current][l-1]==','||LS->name[current][l-1]==';')LS->name[current][l-1]='\0';
+ LS->name[current]=translate_name ( LS->name[current]);
+ a=0;
+ while ((c=fgetc(fp))!='\n' && c!=EOF && a<(COMMENT_SIZE-1))LS->seq_comment[current][a++]=c;
+ LS->seq_comment[current][a]='\0';
+
+
+ p=0;
+ while ((c=fgetc(fp))!='>' && c!=EOF)
+ {
+ if (isalnum (c))
+ LS->seq[current][p++]=c;
+ else if (is_gap(c))
+ LS->seq[current][p++]=c;
+ }
+ LS->seq[current][p]='\0';
+ LS->len[current]=strlen ( LS->seq[current]);
+
+ current++;
+ }
+ else
+ c=fgetc ( fp);
+ }
+
+
+ vfclose (fp);
+
+
+ vfree (sub);
+ vfree (name);
+ vfree (buffer);
+ return LS;
+ }
+
+Sequence *get_tree_file_list ( char *fname)
+{
+
+ char ***list;
+ char *tmp;
+ int a;
+ FILE *fp;
+
+ tmp=vtmpnam (NULL);
+ list=file2list (fname, "\n");
+ fp=vfopen (tmp, "w");
+ a=0;
+ while (list[a] && !isspace(list[a][1][0]))
+ {
+ char *s;
+ s=file2string (list[a][1]);
+ fprintf ( fp, ">%s\n%s\n", list[a][1], (s)?s:"");
+ a++;
+ }
+ vfclose (fp);
+ free_arrayN((void ***)list, 3);
+ return get_fasta_tree (tmp, NULL);
+}
+Sequence *get_file_list ( char *fname)
+{
+
+ char ***list;
+ char *tmp;
+ int a;
+ FILE *fp;
+
+ tmp=vtmpnam (NULL);
+ list=file2list (fname, "\n");
+ fp=vfopen (tmp, "w");
+ a=0;
+ while (list[a] && !isspace(list[a][1][0]))
+ {
+
+ fprintf ( fp, ">%s\n", list[a][1]);
+ a++;
+ }
+ vfclose (fp);
+ free_arrayN((void ***)list, 3);
+ return get_fasta_sequence (tmp, NULL);
+}
+Sequence*get_fasta_tree (char *fname, char *comment_out)
+{
+ Sequence *LS;
+ char *buffer;
+ FILE *fp;
+ int a;
+
+ int c;
+ char *name;
+ int clen=0;
+ int current=0;
+ int p=0;
+ int max;
+ int max_len_seq=0;
+ int min_len_seq=0;
+ int nseq=0, l=0;
+
+
+
+
+ int *sub;
+
+ buffer=vcalloc (1000, sizeof (char));
+ name=vcalloc ( 100, sizeof (char));
+
+ nseq=count_n_char_x_in_file(fname, '>');
+ min_len_seq=max=count_n_char_in_file(fname);
+ sub=vcalloc (max+1, sizeof (int));
+
+ fp=vfopen (fname,"r");
+
+
+ c=fgetc(fp);
+ while (c!=EOF)
+ {
+ if (c=='>')
+ {
+ fscanf_seq_name (fp,name);
+ while ((c=fgetc(fp))!='\n' && c!=EOF);
+ while ((c=fgetc(fp))!='>' && c!=EOF)
+ if (isgraph(c))
+ clen++;
+ max_len_seq=(clen> max_len_seq)?clen: max_len_seq;
+ min_len_seq=(clen< min_len_seq)?clen: min_len_seq;
+ clen=0;
+ }
+ else
+ c=fgetc (fp);
+
+ }
+
+ vfclose (fp);
+ LS=declare_sequence ( min_len_seq, max_len_seq,nseq);
+
+ LS->nseq=nseq;
+
+ fp=vfopen (fname,"r");
+ current=0;
+ c=fgetc(fp);
+ while (c!=EOF)
+ {
+ if (c=='>')
+ {
+
+ fscanf_seq_name (fp,LS->name[current]);
+ l=strlen ( LS->name[current]);
+ if ( LS->name[current][l-1]==','||LS->name[current][l-1]==';')LS->name[current][l-1]='\0';
+ LS->name[current]=translate_name ( LS->name[current]);
+ a=0;
+ while ((c=fgetc(fp))!='\n' && c!=EOF && a<(COMMENT_SIZE-1))LS->seq_comment[current][a++]=c;
+ LS->seq_comment[current][a]='\0';
+
+
+ p=0;
+ while ((c=fgetc(fp))!='>' && c!=EOF)
+ {
+ LS->seq[current][p++]=c;
+ }
+
+ LS->seq[current][p]='\0';
+ LS->len[current]=strlen ( LS->seq[current]);
+
+ current++;
+
+ }
+
+ else
+ c=fgetc ( fp);
+ }
+
+
+ vfclose (fp);
+
+
+ vfree (sub);
+ vfree (name);
+ vfree (buffer);
+
+ return LS;
+}
+Sequence* get_fasta_sequence_raw (char *fname, char *comment_out)
+ {
+ Sequence *LS;
+ char *buffer;
+ FILE *fp;
+ int a;
+
+ int c;
+ char *name;
+ int clen=0;
+ int current=0;
+ int p=0;
+ int max;
+ int max_len_seq=0;
+ int min_len_seq=0;
+ int nseq=0, l=0;
+
+
+
+
+ int *sub;
+
+ buffer=vcalloc (1000, sizeof (char));
+ name=vcalloc ( 100, sizeof (char));
+
+ nseq=count_n_char_x_in_file(fname, '>');
+ min_len_seq=max=count_n_char_in_file(fname);
+ sub=vcalloc (max+1, sizeof (int));
+
+ fp=vfopen (fname,"r");
+
+
+ c=fgetc(fp);
+ while (c!=EOF)
+ {
+ if (c=='>')
+ {
+ fscanf_seq_name (fp,name);
+ while ((c=fgetc(fp))!='\n' && c!=EOF);
+ while ((c=fgetc(fp))!='>' && c!=EOF)
+ if (isgraph(c))
+ clen++;
+ max_len_seq=(clen> max_len_seq)?clen: max_len_seq;
+ min_len_seq=(clen< min_len_seq)?clen: min_len_seq;
+ clen=0;
+ }
+ else
+ c=fgetc (fp);
+
+ }
+
+ vfclose (fp);
+ LS=declare_sequence ( min_len_seq, max_len_seq,nseq);
+
+ LS->nseq=nseq;
+
+ fp=vfopen (fname,"r");
+ current=0;
+ c=fgetc(fp);
+ while (c!=EOF)
+ {
+ if (c=='>')
+ {
+
+ fscanf_seq_name (fp,LS->name[current]);
+ l=strlen ( LS->name[current]);
+ if ( LS->name[current][l-1]==','||LS->name[current][l-1]==';')LS->name[current][l-1]='\0';
+ LS->name[current]=translate_name ( LS->name[current]);
+ a=0;
+ while ((c=fgetc(fp))!='\n' && c!=EOF && a<(COMMENT_SIZE-1))LS->seq_comment[current][a++]=c;
+ LS->seq_comment[current][a]='\0';
+
+
+ p=0;
+ while ((c=fgetc(fp))!='>' && c!=EOF)
+ {
+ //if (c<'A')c+='z';
+ if (c!='\n')LS->seq[current][p++]=c;
+ }
+
+ LS->seq[current][p]='\0';
+ LS->len[current]=strlen ( LS->seq[current]);
+
+ current++;
+
+ }
+
+ else
+ c=fgetc ( fp);
+ }
+
+
+ vfclose (fp);
+
+
+ vfree (sub);
+ vfree (name);
+ vfree (buffer);
+ return LS;
+ }
+Sequence* get_fasta_sequence (char *fname, char *comment_out)
+ {
+ Sequence *LS;
+ Sequence *pdb_S;
+ int a;
+
+ char *pdb_name;
+
+ char *buffer;
+ FILE *fp;
+
+ int c;
+ char *name;
+ int clen=0;
+ int current=0;
+ int p=0;
+ int max;
+ int max_len_seq=0;
+ int min_len_seq=0;
+ int nseq=0, l=0;
+ char *sub;
+ int disk=0;
+ int coor=0;
+
+
+
+ buffer=vcalloc (1000, sizeof (char));
+ name=vcalloc ( 10000, sizeof (char));
+
+ nseq=count_n_char_x_in_file(fname, '>');
+ if (disk==1 || get_int_variable ("use_disk") || getenv ("SEQ_ON_DISK_4_TCOFFEE")){disk=1;}
+ if ( nseq==0)
+ {
+ vfree (buffer); vfree (name);
+ return NULL;
+ }
+
+ min_len_seq=max=count_n_char_in_file(fname);
+ sub=vcalloc (max+1, sizeof (char));
+
+ fp=vfopen (fname,"r");
+
+ nseq=0;
+ c=fgetc(fp);
+ while (c!=EOF)
+ {
+ if (c=='>')
+ {
+ nseq++;
+ fscanf_seq_name (fp,name);
+ while ((c=fgetc(fp))!='\n' && c!=EOF);
+ while ((c=fgetc(fp))!='>' && c!=EOF)
+ {
+ if (isalnum (c)|| is_gap(c))
+ sub[clen++]=c;
+ }
+
+ if (strm (sub, "PDB"))
+ {
+ pdb_name=get_pdb_struc(name,0, 0);
+ pdb_S=get_pdb_sequence (pdb_name);
+ if (pdb_S)
+ {
+ clen=strlen( pdb_S->seq[0]);
+ free_sequence ( pdb_S,1);
+ }
+ else
+ clen=0;
+
+ }
+
+ max_len_seq=(clen> max_len_seq)?clen: max_len_seq;
+ min_len_seq=(clen< min_len_seq)?clen: min_len_seq;
+ clen=0;
+ }
+ else
+ c=fgetc (fp);
+
+ }
+
+ vfclose (fp);
+
+
+ if ( disk==0)
+ LS=declare_sequence ( min_len_seq, max_len_seq,nseq);
+ else
+ {
+ LS=declare_sequence (0,0,nseq);
+ for (a=0; a<nseq; a++)LS->seq[a]=NULL;
+ }
+ LS->nseq=nseq;
+
+ fp=vfopen (fname,"r");
+ current=0;
+ c=fgetc(fp);coor++;
+
+ while (c!=EOF)
+ {
+ if (c=='>')
+ {
+ coor+=fscanf_seq_name (fp, LS->name[current]);
+
+
+ l=strlen ( LS->name[current]);
+ if ( LS->name[current][l-1]==','||LS->name[current][l-1]==';')LS->name[current][l-1]='\0';
+ LS->name[current]=translate_name ( LS->name[current]);
+ a=0;
+ while ((c=fgetc(fp))!='\n' && c!=EOF && a<(COMMENT_SIZE-1)){LS->seq_comment[current][a++]=c;coor++;}
+ coor++;
+
+ LS->seq_comment[current][a]='\0';
+
+ p=0;
+ while ((c=fgetc(fp))!='>' && c!=EOF)
+ {
+ coor++;
+
+ if (!isspace(c))
+ {
+ if (p==0)LS->dc[current][0]=coor;
+
+ if (disk==0)LS->seq[current][p++]=c;
+ else p++;
+ }
+
+ LS->dc[current][1]=coor;
+ }
+ coor++;
+
+ if ( disk==0)LS->seq[current][p]='\0';
+
+ if (LS->seq[current] && strm (LS->seq[current], "PDB"))
+ {
+
+ pdb_name=get_pdb_struc(LS->name[current],0, 0);
+ pdb_S=get_pdb_sequence (pdb_name);
+ if (pdb_S)
+ {
+ sprintf ( LS->seq[current], "%s", pdb_S->seq[0]);
+ clen=strlen( pdb_S->seq[0]);
+ free_sequence ( pdb_S, 1);
+ }
+ else
+ {
+ add_warning (stderr, "WARNING: Could not fetch PDB file: %s", pdb_name);
+ }
+ }
+
+
+ LS->len[current]=p;
+ current++;
+ }
+
+ else
+ {
+ c=fgetc ( fp);
+ coor++;
+ }
+ }
+
+ vfclose (fp);
+ vfree (sub);
+ vfree (name);
+ vfree (buffer);
+ //LS=clean_sequence (LS);
+
+ return LS;
+ }
+
+Sequence* get_sub_fasta_sequence (char *fname, char *comment_out)
+ {
+ Sequence *LS;
+
+ FILE *fp;
+
+ int c;
+ char name[100];
+ int clen=0;
+ int current=0;
+ int p=0;
+ int max;
+ int max_len_seq=0;
+ int min_len_seq=0;
+ int nseq=0, l=0;
+ char *buf;
+
+
+
+ int *sub;
+
+ nseq=count_n_char_x_in_file(fname, '>');
+ min_len_seq=max=count_n_char_in_file(fname);
+ sub=vcalloc (max+1, sizeof (int));
+ buf=vcalloc ( max+1, sizeof (char));
+ fp=vfopen (fname,"r");
+
+
+ c=fgetc(fp);
+ while (c!=EOF)
+ {
+ if (c=='>')
+ {
+ fscanf_seq_name (fp,name);
+ while ((c=fgetc(fp))!='\n' && c!=EOF);
+ buf=fgets ( buf,max, fp);
+ while ((c=fgetc(fp))!='>' && c!=EOF)
+ if (isalnum (c)|| is_gap(c))
+ clen++;
+ max_len_seq=(clen> max_len_seq)?clen: max_len_seq;
+ min_len_seq=(clen< min_len_seq)?clen: min_len_seq;
+ clen=0;
+ }
+ else
+ c=fgetc (fp);
+
+ }
+
+ vfclose (fp);
+ LS=declare_sequence ( min_len_seq, max_len_seq,nseq);
+ LS->nseq=nseq;
+
+ fp=vfopen (fname,"r");
+ current=0;
+ c=fgetc(fp);
+ while (c!=EOF)
+ {
+ if (c=='>')
+ {
+
+ fscanf_seq_name (fp,LS->name[current]);
+ l=strlen ( LS->name[current]);
+ if ( LS->name[current][l-1]==','||LS->name[current][l-1]==';')LS->name[current][l-1]='\0';
+ LS->name[current]=translate_name ( LS->name[current]);
+ while ((c=fgetc(fp))!='\n' && c!=EOF);
+
+ p=0;
+ while ((c=fgetc(fp))!='>' && c!=EOF)
+ {
+ if (isalpha (c))
+ LS->seq[current][p++]=tolower (c);
+ else if (is_gap(c))
+ LS->seq[current][p++]=(c);
+ }
+
+ LS->seq[current][p]='\0';
+ LS->len[current]=strlen ( LS->seq[current]);
+
+ current++;
+
+ }
+
+ else
+ c=fgetc ( fp);
+ }
+
+
+ vfclose (fp);
+
+
+ vfree (sub);
+ return LS;
+ }
+Sequence* get_pir_sequence (char *fname, char *comment_out)
+ {
+ Sequence *LS;
+
+ FILE *fp;
+ int c;
+
+ char name[100];
+ int clen=0;
+ int current=0;
+ int p=0;
+ int max_len_seq=0;
+ int min_len_seq=999999;
+ int nseq=0, l=0;
+ char *buf;
+
+ buf=vcalloc ( 1000, sizeof (char));
+ if ((fp=vfopen (fname,"r"))==NULL)
+ {printf ( "\nCOULDN'T OPEN %s",fname);
+ myexit(EXIT_FAILURE);
+ }
+ c=fgetc(fp);
+ while (c!=EOF)
+ {
+ if (c=='>')
+ {
+ if ( (c=fgetc(fp))=='P')while ( (c=fgetc(fp))!=';');
+ else ungetc ( c, fp);
+ fscanf_seq_name (fp,name);
+
+ buf=fgets ( buf, 1000, fp);
+ while ((c=fgetc(fp))!='>' && c!=EOF)
+ if (isalnum (c)|| is_gap(c))
+ clen++;
+ max_len_seq=(clen> max_len_seq)?clen: max_len_seq;
+ min_len_seq=(clen< min_len_seq)?clen: min_len_seq;
+ nseq++;
+ clen=0;
+ }
+ else
+ c=fgetc (fp);
+ }
+ vfclose (fp);
+
+
+
+ LS=declare_sequence ( min_len_seq, max_len_seq,nseq);
+ LS->nseq=nseq;
+
+ fp=vfopen (fname,"r");
+
+ current=0;
+ c=fgetc(fp);
+ while (c!=EOF)
+ {
+ if (c=='>')
+ {
+ if ( (c=fgetc(fp))=='P')while ( (c=fgetc(fp))!=';');
+ else ungetc ( c, fp);
+
+ fscanf_seq_name (fp,LS->name[current]);
+
+ l=strlen ( LS->name[current]);
+ if ( LS->name[current][l-1]==','||LS->name[current][l-1]==',')LS->name[current][l-1]='\0';
+ LS->name[current]=translate_name ( LS->name[current]);
+ buf=fgets ( buf, 1000, fp);
+
+ LS->seq_comment[current]=fgets ( LS->seq_comment[current],COMMENT_SIZE-1, fp);
+ LS->seq_comment[current][strlen(LS->seq_comment[current])-1]='\0';
+ p=0;
+ while ((c=fgetc(fp))!='>' && c!=EOF)
+ if (isalpha (c))
+ LS->seq[current][p++]=tolower (c);
+ else if ( !isspace(c) && c!='*')
+ LS->seq[current][p++]=(c);
+ LS->seq[current][p]='\0';
+ LS->len[current]=strlen ( LS->seq[current]);
+ current++;
+ }
+ else
+ c=fgetc ( fp);
+ }
+
+ vfclose (fp);
+ if (comment_out!=NULL) output_pir_check ( comment_out,LS->nseq, LS->seq_comment);
+ return LS;
+ }
+
+Sequence* get_gor_sequence (char *fname, char *comment_out)
+ {
+ Sequence *LS;
+
+ FILE *fp;
+ int c;
+
+ char name[100];
+ int clen=0;
+ int current=0;
+ int p=0;
+ int max_len_seq=0;
+ int min_len_seq=99999;
+ int nseq=0;
+ char *buf;
+
+ buf=vcalloc ( 1000, sizeof (char));
+ if ((fp=vfopen (fname,"r"))==NULL)
+ {printf ( "\nCOULDN'T OPEN %s",fname);
+ myexit(EXIT_FAILURE);
+ }
+ c=fgetc(fp);
+ while (c!=EOF)
+ {
+ if (c=='!')
+ {
+ fscanf_seq_name (fp,name);
+
+ buf=fgets ( buf, 1000, fp);
+ while ((c=fgetc(fp))!='!' && c!=EOF)
+ if (isalnum (c)|| is_gap(c))
+ clen++;
+ max_len_seq=(clen> max_len_seq)?clen: max_len_seq;
+ min_len_seq=(clen< min_len_seq)?clen: min_len_seq;
+ nseq++;
+ clen=0;
+ }
+ else
+ c=fgetc (fp);
+ }
+ vfclose (fp);
+
+ LS=declare_sequence ( min_len_seq, max_len_seq,nseq);
+ LS->nseq=nseq;
+
+ fp=vfopen (fname,"r");
+
+ current=0;
+ c=fgetc(fp);
+ while (c!=EOF)
+ {
+ if (c=='!')
+ {
+
+
+ fscanf_seq_name (fp,LS->name[current]);
+ LS->name[current]=translate_name ( LS->name[current]);
+ buf=fgets ( buf, 1000, fp);
+
+ p=0;
+ while ((c=fgetc(fp))!='!' && c!=EOF)
+ if (isalnum (c)|| is_gap(c))
+ LS->seq[current][p++]=tolower (c);
+
+ LS->seq[current][p]='\0';
+ LS->len[current]=strlen ( LS->seq[current]);
+ current++;
+ }
+ else
+ c=fgetc ( fp);
+ }
+
+ vfclose (fp);
+
+ return LS;
+ }
+Sequence* get_swissprot_sequence (char *fname, char *comment_out)
+ {
+ Sequence *LS;
+ FILE *fp;
+ int c;
+ char *buf;
+ int nseq=0;
+ int len, max_len_seq=0, min_len_seq=0;
+
+ if ( !check_file_exists(fname))
+ {printf ( "\nCOULDN'T OPEN %s",fname);
+ myexit(EXIT_FAILURE);
+ }
+
+ buf=vcalloc (LONG_STRING+1, sizeof (char));
+ fp=NULL;
+ while ( (fp=find_token_in_file(fname,fp,"\nSQ")))
+ {
+ nseq++;
+ fgets (buf, LONG_STRING, fp);
+ len=0;
+ while ((c=fgetc(fp))!='/')if(isalpha(c))len++;
+ if ( max_len_seq==0)max_len_seq=min_len_seq=len;
+ else
+ {
+ max_len_seq=MAX(len, max_len_seq);
+ min_len_seq=MIN(len, min_len_seq);
+ }
+ }
+
+ LS=declare_sequence ( min_len_seq, max_len_seq,nseq);
+ LS->nseq=0;
+
+ fp=NULL;
+ while ( (fp=find_token_in_file(fname,fp,"\nID")))
+ {
+ fscanf_seq_name (fp, LS->name[LS->nseq]);
+ fp=find_token_in_file(fname,fp,"\nSQ");
+ fgets (buf, LONG_STRING, fp);
+ while ((c=fgetc(fp))!='/')if (isalpha(c))LS->seq[LS->nseq][LS->len[LS->nseq]++]=c;
+ LS->seq[LS->nseq][LS->len[LS->nseq]]='\0';
+ LS->nseq++;
+ }
+
+
+ return LS;
+ }
+int fscanf_seq_name ( FILE *fp, char *sname)
+{
+ static char *name;
+ int r;
+ if ( !sname) return 0;
+
+ if ( !name)name=vcalloc ( 10000, sizeof (char));
+ fscanf (fp, "%s", name);
+ r=strlen (name);
+ if ( strlen (name)>MAXNAMES)
+ add_warning (stderr, "\nWARNING: Seq Name Too long: [%s]. Truncated to %d", name, MAXNAMES);
+ name[MAXNAMES]='\0';
+ sprintf ( sname, "%s", name);
+ return r;
+}
+
+/*******************************************************************************************/
+/* */
+/* */
+/* INPUT ALN */
+/* */
+/***************************************************************************************** */
+void undump_msa ( Alignment *A, char *tmp)
+{
+ FILE *fp;
+ int m;
+ char *buf;
+ int index;
+
+ if ( !A || !tmp || !check_file_exists (tmp))return;
+ m=measure_longest_line_in_file (tmp );
+ A=realloc_aln2 ( A,A->max_n_seq,m+1);
+
+ buf=vcalloc (m+1, sizeof (char));
+ fp=vfopen (tmp, "r");
+ while (fscanf (fp, "%d %s\n", &index, buf)==2)
+ {
+ sprintf ( A->seq_al[index], "%s", buf);
+ }
+ vfclose (fp);
+ vfree (buf);
+}
+void dump_msa ( char *file,Alignment *A, int nseq, int *lseq)
+{
+ FILE *fp;
+ int a;
+ fp=vfopen (file, "w");
+ for (a=0; a<nseq; a++)
+ fprintf ( fp, "%d %s\n", lseq[a], A->seq_al[lseq[a]]);
+ vfclose (fp);
+}
+
+void read_aln (char *file_name, Alignment *A)
+{
+ char *tmp_name;
+ Sequence *S;
+
+
+ tmp_name=vtmpnam (NULL);
+
+ if (printf_system ( "clustalw_aln2fasta_aln.pl %s > %s",file_name, tmp_name)!=EXIT_SUCCESS)
+ {
+ printf_exit ( EXIT_FAILURE, stderr, "Could Not Read File %s [FATAL:%s]\n", file_name, PROGRAM);
+ }
+ else
+ {
+ S=get_fasta_sequence ( tmp_name,NULL);
+ A=seq2aln (S, A, 0);
+ }
+ return;
+}
+void read_stockholm_aln (char *file_name, Alignment *A)
+{
+ char *tmp_name;
+ Sequence *S;
+
+
+ tmp_name=vtmpnam (NULL);
+ if (printf_system ( "clustalw_aln2fasta_aln.pl %s > %s",file_name, tmp_name)!=EXIT_SUCCESS)
+ {
+ printf_exit ( EXIT_FAILURE, stderr, "Could Not Read File %s [FATAL:%s]\n", file_name, PROGRAM);
+ }
+ else
+ {
+ int a;
+ S=get_fasta_sequence ( tmp_name,NULL);
+ for (a=0; a<S->nseq; a++)
+ {
+ if (strstr (S->name[a], "_stockholm"))
+ {
+ substitute ( S->name[a], "_stockholmspace_", " ");
+ substitute ( S->name[a], "_stockholmhasch_", "#");
+ }
+ }
+ A=seq2aln (S, A, 0);
+ }
+ return;
+}
+Alignment* read_blast_aln ( char *file_name, Alignment *A)
+{
+ char *tmp_name;
+
+ int type;
+
+
+ if ( !(type=is_blast_file (file_name)))
+ {
+ myexit (EXIT_FAILURE);
+ }
+ tmp_name=vtmpnam ( NULL);
+ if (type==BLAST_TXT)
+ {
+ printf_system("cat %s | blast_aln2fasta_aln.pl | fasta_aln2fasta_aln_unique_name.pl >%s", file_name, tmp_name);
+ }
+ else if (type==BLAST_XML)
+ {
+
+ printf_system("blast_xml2fasta_aln.pl %s >%s", file_name, tmp_name);
+ }
+
+ main_read_aln (tmp_name, A);
+ return A;
+}
+
+
+void read_number_aln ( char *file_name, Alignment *A)
+ {
+ FILE *fp, *fp2;
+ int * ptr_aln;
+ int a,b,d;
+ int c;
+ char *buf=NULL;
+
+ int tot=0;
+ int flag=0;
+ char *fname;
+ int n_comment=0;
+
+ int nseq=0;
+ int max_len=0;
+
+
+ fp=vfopen ( file_name, "r");
+
+ fname=vtmpnam(NULL);
+ fp2=vfopen ( fname, "w");
+ while ( (c=fgetc(fp))!=EOF)
+ {
+ fprintf ( fp2, "%c", c);
+ }
+ vfclose (fp);
+ vfclose (fp2);
+
+
+ /*1 Count The number of sequences*/
+ fp=vfopen ( fname, "r");
+ buf=vfgets ( buf,fp);
+ if ( !isblanc (buf));
+ while ( isblanc (buf))
+ {
+ buf=vfgets ( buf, fp);
+ }
+ while (!isblanc (buf))
+ {
+ buf=vfgets ( buf,fp);
+ }
+ while ( !isalnum ((c=fgetc(fp))))
+ {
+ ungetc(c,fp);
+ buf=vfgets ( buf,fp);
+ }
+
+ if ( c!='\n')ungetc(c,fp);
+
+ while ( isalnum ((c=fgetc(fp))))
+ {
+ ungetc(c,fp);
+ a=0;
+ while ( isgraph ((c=fgetc(fp))));
+ nseq++;
+ buf=vfgets ( buf, fp);
+ }
+ vfclose (fp);
+
+ /*DONE*/
+ /*2 get_max_len*/
+ max_len=count_n_char_in_file(fname)/nseq;
+ A=realloc_alignment2( A, nseq+1, max_len+1);
+
+ /*DONE*/
+
+
+ fp=vfopen ( fname, "r");
+ buf=vfgets ( buf, fp);
+ if ( !isblanc (buf))sprintf (A->aln_comment[n_comment++], "%s", buf);
+ while ( isblanc (buf))
+ {
+ buf=vfgets ( buf,fp);
+ }
+ while (!isblanc (buf))
+ {
+ buf=vfgets ( buf, fp);
+ sprintf ( A->aln_comment[n_comment++], "%s", buf);
+
+ }
+ while ( !isalnum ((c=fgetc(fp))))
+ {
+ ungetc(c,fp);
+ buf=vfgets ( buf, fp);
+
+ }
+
+ if ( c!='\n')ungetc(c,fp);
+
+ while ( isalnum ((c=fgetc(fp))))
+ {
+ ungetc(c,fp);
+
+ fscanf_seq_name (fp, A->name[A->nseq]);
+
+ if ( name_is_in_list (A->name[A->nseq], A->name, A->nseq, 100)!=-1)
+ {
+ fprintf ( stderr, "\nWARNING (read_number_aln): Sequence %s Duplicated in File %s ", A->name[A->nseq], A->file[A->nseq]);
+ if (!getenv("ALLOW_DUPLICATE"))
+ {
+ fprintf ( stderr, " [FATAL:%s]\n", PROGRAM);
+ myexit (EXIT_FAILURE);
+ }
+ }
+ A->nseq++;
+ buf=vfgets ( buf,fp);
+ }
+
+ vfclose (fp);
+
+
+
+ if ((fp=vfopen ( fname, "r"))==NULL)
+ printf ( "\nCOULDN'T READ %s", fname);
+
+ ptr_aln=vcalloc ( A->nseq, sizeof(int));
+ while ( flag==0)
+ {
+ while ( (c=fgetc(fp))!='\n');
+ if ( (c=fgetc(fp))=='\n')
+ flag=1;
+ }
+ while ( !isalnum(c=fgetc(fp)));
+ ungetc ( c, fp);
+ while ( c!=EOF)
+ {
+ tot=0;
+ while(tot< A->nseq && c!=EOF)
+ {
+ b=0;
+ while ( !isgraph (c=fgetc(fp)) && c!=EOF);
+ if ( c!=EOF)ungetc(c, fp);
+ while ( isgraph((buf[b++]=fgetc(fp))));
+ buf[b-1]='\0';
+ for ( a=-1,d=0; d< A->nseq; d++)
+ if ( strcmp (A->name[d], buf)==0)
+ {a=d;
+ tot++;
+ }
+
+ if ( a==-1) while ( (c=fgetc(fp))!='\n' && c!=EOF);
+ else
+ {
+ while ( (c=fgetc(fp))!='\n')
+ {
+ if ( isgraph(c) || is_gap(c))
+ {if ( isalpha(c))
+ c=(A->residue_case==2)?c:tolower(c);
+
+ if (!isspace(c))A->seq_al[a][ptr_aln[a]++]=c;
+ }
+ }
+ }
+ }
+ while ( !isalnum(c=getc(fp)) && c!=EOF);
+ if ( c!=EOF)
+ ungetc (c, fp);
+ }
+
+ vfclose (fp);
+
+
+ for ( a=0; a< A->nseq; a++)
+ {A->seq_al[a][ptr_aln[a]]='\0';
+ A->order[a][0]=a;
+ A->order[a][1]=0;
+ }
+
+ A->len_aln= strlen(A->seq_al[0]);
+
+ vfree (buf);
+ vfree(ptr_aln);
+ vremove (fname);
+
+ }
+void read_amps_aln ( char *in_file, Alignment *A)
+ {
+ FILE *fp;
+ int a, b, c, cont=1;
+ A->nseq=get_amps_seq_name ( A->name, in_file);
+
+ fp=vfopen ( in_file, "r");
+ fp=set_fp_id(fp, "1*");
+ while ( (c=fgetc(fp))!='\n');
+ b=0;
+ while ( cont==1)
+ {
+ c=fgetc ( fp);
+ c=fgetc(fp);
+ if ( c=='*')
+ {
+ cont=0;
+ for ( a=0; a<A->nseq; a++)
+ A->seq_al[a][b]='\0';
+ A->len_aln=b;
+ }
+
+ else
+ {
+ ungetc (c, fp);
+ for ( a=0; a< A->nseq; a++)
+ {
+ c=fgetc(fp);
+ if ( c==' ')A->seq_al[a][b]='-';
+ else
+ {
+ A->seq_al[a][b]=c;
+ A->len[a]++;
+ }
+ }
+ while ((c=fgetc(fp))!='\n');
+ b++;
+ }
+ }
+ }
+
+
+
+
+
+
+int get_amps_seq_name ( char **name, char* fname)
+ {
+ FILE *fp;
+ int nseq=0;
+
+ fp=vfopen ( fname, "r");
+ fp=set_fp_id ( fp, "Index");
+ while ( (fgetc(fp))!='\n');
+ while ( isspace(fgetc(fp)))
+ {fscanf (fp, "%*d >%s", name[nseq++]);
+ while ( (fgetc(fp))!='\n');
+ }
+ vfclose ( fp);
+ return nseq;
+ }
+Alignment * read_gotoh_aln ( char *fname, Alignment *A)
+ {
+ FILE *fp;
+ int * ptr_aln;
+ int a,b,d,e;
+
+
+ char *buf;
+ char buf2[VERY_LONG_STRING+1];
+ char buf3[VERY_LONG_STRING+1];
+ char buf4[VERY_LONG_STRING+1];
+
+ int tot=0;
+
+ int l;
+ int nseq, max_len;
+
+
+ if ( !check_file_exists (fname))return NULL;
+ fp=vfopen ( fname, "r");
+
+/*1 GET THE NUMBER OF SEQUENCES*/
+ nseq=0;
+ buf=vcalloc ( VERY_LONG_STRING+1, sizeof (char));
+ while ( isblanc (buf=fgets ( buf, VERY_LONG_STRING, fp)));
+ while (!isblanc (buf=fgets ( buf, VERY_LONG_STRING, fp)));
+ while ( isblanc (buf=fgets ( buf, VERY_LONG_STRING, fp)));
+ while ( !isblanc ( buf) && buf!=NULL)
+ {
+ a=-1;
+ d=sscanf ( buf, "%d %s %s %s", &a, buf2, A->name[A->nseq],buf3);
+ if ( a!=-1)
+ {
+ if ( name_is_in_list (A->name[A->nseq], A->name, A->nseq, 100)!=-1)
+ {
+ fprintf ( stderr, "\nWARNING (get_amps_seq_name): Sequence %s Duplicated in File %s ", A->name[A->nseq], A->file[A->nseq]);
+ if (!getenv("ALLOW_DUPLICATE"))
+ {
+ fprintf ( stderr, " [FATAL:%s]\n", PROGRAM);
+ myexit (EXIT_FAILURE);
+ }
+ }
+ nseq++;
+ fgets(buf, VERY_LONG_STRING, fp);
+ }
+ else ( buf=NULL);
+ }
+ vfclose (fp);
+/*2 Get the MAX Len and Reallocate*/
+ max_len=count_n_char_in_file(fname)/nseq;
+ A=realloc_aln2( A, nseq+1, max_len+1);
+/*3 Get The Sequences Names*/
+ A->nseq=0;
+ fp=vfopen ( fname, "r");
+ while ( isblanc (buf=fgets ( buf, VERY_LONG_STRING, fp)));
+ while (!isblanc (buf=fgets ( buf, VERY_LONG_STRING, fp)));
+ while ( isblanc (buf=fgets ( buf, VERY_LONG_STRING, fp)));
+ while ( !isblanc ( buf) && buf!=NULL)
+ {
+ a=-1;
+ d=sscanf ( buf, "%d %s %s %s", &a, buf2, A->name[A->nseq],buf3);
+ if ( a!=-1)
+ {
+ if ( d==4)sprintf (A->name[A->nseq],"%s", buf3);
+ A->nseq++;
+ fgets(buf, VERY_LONG_STRING, fp);
+ }
+ else ( buf=NULL);
+ }
+ vfclose (fp);
+
+/*READ THE ALN*/
+ fp=vfopen ( fname, "r");
+
+ buf=vcalloc ( VERY_LONG_STRING+1, sizeof (char));;
+ ptr_aln=vcalloc ( A->nseq, sizeof(int));
+
+ while ( isblanc (buf=fgets ( buf, VERY_LONG_STRING, fp)));
+ while (!isblanc (buf=fgets ( buf, VERY_LONG_STRING, fp)));
+
+
+ while ( isblanc (buf=fgets ( buf, VERY_LONG_STRING, fp)));
+
+ while (buf!=NULL)
+ {
+ tot=0;
+ while(tot< A->nseq)
+ {
+
+ e=sscanf (buf, "%d %s %s %s", &e, buf2, buf3, buf4);
+ if ( e==4)sprintf( buf3, "%s", buf4);
+
+
+ for ( d=0; d< A->nseq; d++)
+ {
+
+ if ( strcmp (A->name[d], buf3)==0)
+ {a=d;
+ tot++;
+ }
+ }
+ l=strlen (buf2);
+ if ( buf2[l-1]=='|')l--;
+ buf2[l]='\0';
+
+ for (b=0; b<l; b++)
+ {
+ if ( isgraph (buf2[b]))
+ A->seq_al[a][ptr_aln[a]++]=(A->residue_case==2)?buf2[b]:tolower (buf2[b]);
+ }
+ buf=fgets(buf, VERY_LONG_STRING, fp);
+ }
+ if ( buf!=NULL)
+ {
+ buf=fgets(buf, VERY_LONG_STRING, fp);
+ while ( isblanc (buf) && buf!=NULL)
+ {
+ buf=fgets ( buf, VERY_LONG_STRING, fp);
+ }
+ }
+
+ }
+
+ vfclose (fp);
+
+
+ for ( a=0; a< A->nseq; a++)
+ {A->seq_al[a][ptr_aln[a]]='\0';
+ }
+
+ A->len_aln= strlen(A->seq_al[0]);
+
+
+
+ for ( a=0; a< A->nseq; a++)
+ {
+ for ( b=0; b< A->len_aln; b++)
+ A->len[a]+=1-is_gap(A->seq_al[a][b]);
+ }
+ for ( a=0, b=0; a< A->len_aln; a++)
+ {
+ if ( !is_gap(A->seq_al[0][a]) &&!is_gap(A->seq_al[1][a]))b++;
+ }
+ return A;
+ }
+
+
+
+
+
+void read_msf_aln ( char *fname, Alignment *A)
+ {
+ char command[1000];
+ char *tmp_name;
+ Sequence *S;
+
+ tmp_name=vtmpnam(NULL);
+ sprintf ( command, "msf_aln2fasta_aln.pl %s > %s", fname, tmp_name);
+
+ if ( my_system (command)!=EXIT_SUCCESS)
+ {
+ fprintf ( stderr, "\nERROR: file %s does not have a legal msf format [FATAL:%s]", fname,PROGRAM);
+ myexit (EXIT_FAILURE);
+ }
+
+ S=get_fasta_sequence ( tmp_name,NULL);
+ A=seq2aln (S, A, 0);
+ vremove (tmp_name);
+ return;
+ }
+
+/**************************************************************************************************/
+/*************************************REFORMAT OUT*************************************************/
+/**************************************************************************************************/
+/*******************************************************************************************/
+/* */
+/* */
+/* OUTPUT MATRICES */
+/* */
+/***************************************************************************************** */
+
+
+
+int output_freq_mat ( char *outfile, Alignment *A)
+ { /*
+ function documentation: start
+
+ int output_freq_mat ( char *outfile, Aligmnent *A)
+
+ This function counts the number of residues in each column of an alignment (Prot)
+ It outputs these values in the following format
+
+ A | 0 0 0 1 0
+ B | 1 0 0 0 1
+ - | 0 1 1 0 0
+
+ This format can be piped into:
+ The routine used for computing the p-value gmat-inf-gc-v2c
+
+ function documentation: end
+ */
+
+ int a, b;
+ int **freq_mat;
+ FILE *fp;
+
+
+ freq_mat=aln2count_mat (A);
+
+ fp=vfopen ( outfile, "w");
+ for ( b=0; b< 26; b++)
+ {
+ fprintf (fp, "%c |", 'A'+b);
+ for ( a=0; a< A->len_aln; a++)fprintf (fp,"%d ", freq_mat[b][a]);
+ fprintf (fp, "\n");
+ }
+ fprintf (fp, "- |");
+ for ( a=0; a< A->len_aln; a++)fprintf (fp,"%d ", freq_mat[26][a]);
+
+ free_int (freq_mat, -1);
+ vfclose ( fp);
+ return 1;
+ }
+/*******************************************************************************************/
+/* */
+/* */
+/* OUTPUT P-Values */
+/* */
+/***************************************************************************************** */
+float output_maln_pval ( char *outfile, Alignment *A)
+ {
+ /*
+ function documentation: start
+ float output_maln_pval ( char *outfile, Aligmnent *A)
+
+ This function outputs the p-value of a multiple alignmnet as described
+ in Hertz, Stormo, Bioinformatics, 15-7/8, 563/577
+ ftp beagle.colorado.edu /pub/cosensus
+ Locally
+ packages/consensus/gmat-inf-gc-v2c
+
+
+ The routine used for computing the p-value is the program gmat-inf-gc-v2c
+ function documentation: end
+ */
+
+
+ char *mat;
+ char *result;
+ FILE *fp;
+ float value;
+ char command[LONG_STRING];
+ char string[STRING];
+ mat=vtmpnam (NULL);
+ result=vtmpnam (NULL);
+
+ output_freq_mat (mat,A);
+ sprintf ( command, "more %s | gmat-inf-gc-v2c -A abcdefghijklmnopqrstuvwxyz> %s",mat, result);
+ my_system ( command);
+
+ if ( !check_file_exists(result))return 0;
+ fp=find_token_in_file ( result, NULL, "ln(p-value):");
+
+ fscanf ( fp, "%s",string);
+ value=atof ( string);
+ vfclose ( fp);
+
+ vremove ( mat);
+ vremove ( result);
+
+ fp=vfopen ( outfile, "w");
+ fprintf ( fp, "%.6f\n", value);
+ vfclose ( fp);
+
+ return value;
+ }
+
+
+/*******************************************************************************************/
+/* */
+/* */
+/* OUTPUT WEIGHTS */
+/* */
+/***************************************************************************************** */
+int output_seq_weights ( Weights *W, char *wfile)
+ {
+ FILE*fp;
+ int a;
+
+ if ( W==NULL)return 0;
+
+ fp=vfopen (wfile, "w");
+ if ( fp==NULL)return 0;
+
+
+ for ( a=0; a< W->nseq; a++)
+ {
+
+ fprintf ( fp, "%s %.2f\n", W->seq_name[a],W->SEQ_W[a]);
+ }
+ vfclose ( fp);
+ return 1;
+ }
+void output_pw_weights4saga ( Weights *W, float **w_list, char *wfile)
+ {
+ FILE*fp;
+ int a, b;
+ fp=vfopen (wfile, "w");
+
+ fprintf ( fp, "%s\n$\n", W->comments);
+ for ( a=0; a< W->nseq-1; a++)
+ {
+ for (b=a+1; b< W->nseq; b++)
+ {
+ fprintf ( fp, "%s %s %f\n", W->seq_name[a], W->seq_name[b],w_list[a][b]);
+ }
+ }
+ fprintf ( fp, "$\n");
+ vfclose ( fp);
+ }
+
+FILE * display_weights (Weights *W, FILE *fp)
+{
+ int a;
+ int max_len;
+
+ if ( W==NULL)
+ {
+ fprintf ( fp, "\n\nUN-WEIGHTED MODE: EVERY SEQUENCE WEIGHTS 1\n");
+ return fp;
+ }
+ fprintf ( fp, "\n\nWEIGHTED MODE:%s\n\n", (W)->mode);
+ for ( a=0, max_len=0; a< W->nseq; a++)max_len=MAX(max_len, strlen (W->seq_name[a]));
+ for ( a=0; a< (W->nseq); a++)
+ {
+ fprintf ( fp, "\t%*s %.2f\n", max_len,(W)->seq_name[a],W->SEQ_W[a]);
+ }
+ fprintf ( fp, "\n");
+ return fp;
+}
+
+/*******************************************************************************************/
+/* */
+/* */
+/* OUTPUT SEQ */
+/* */
+/***************************************************************************************** */
+int ** input_similarities (char *file, Alignment *A, char *mode)
+{
+ int a, b, i, n;
+ int **sim;
+ float score;
+ char name[1000];
+ FILE *fp=NULL;
+ char *buf1=NULL, *buf2=NULL;
+ int new_aln=0;
+
+
+
+ if ( !check_file_exists (file) || !is_distance_matrix_file (file) ||!is_similarity_matrix_file (file) )
+ {
+ return NULL;
+ }
+
+ if ( A)
+ {
+ fp=vfopen (file, "r");
+ while ((buf2=vfgets (buf1,fp))!=NULL )
+ {
+ if (strstr (buf2, "SEQ_INDEX"))
+ {
+ buf1=buf2;
+ sscanf (buf1, "# SEQ_INDEX %s %d",name, &i);
+ if ( !strm (A->name[i], name))
+ {
+ return NULL;
+ }
+ }
+ }
+ vfclose (fp);
+ }
+ else
+ {
+
+ A=similarities_file2aln(file);
+ new_aln=1;
+ }
+
+ sim=declare_int ( A->nseq, A->nseq);
+ for ( a=0; a<A->nseq; a++)sim[a][a]=100;
+
+
+ fp=find_token_in_file (file, NULL, "PW_SEQ_DISTANCES");
+ fp=find_token_in_file (file, fp, "BOT");
+ while ((buf2=vfgets (buf1,fp))!=NULL )
+ {
+ if ( !(strstr (buf2, "BOT\t") || strstr (buf2, "TOP\t")))continue;
+ buf1=buf2;
+ n=sscanf (buf1, "%*s %d %d %f", &a, &b, &score);
+ if ( n!=3)
+ {
+ free_int (sim, -1);
+ return NULL;
+ }
+ else sim[a][b]=sim[b][a]=(int)score;
+ }
+ vfclose (fp);
+ vfree (buf1);
+ if (new_aln)free_aln(A);
+ return sim;
+}
+
+Alignment * similarities_file2aln ( char *file)
+{
+ int nseq=0, i;
+ FILE *fp;
+ char name[1000];
+ Alignment *A;
+
+
+ fp=vfopen (file, "r");
+ while ((fp=find_token_in_file (file,fp, "SEQ_INDEX")))nseq++;
+ A=declare_aln2 (nseq+1, 10);
+
+ while ((fp=find_token_in_file (file,fp, "SEQ_INDEX")))
+ {
+ fscanf (fp, "%s %d", name,&i);
+ sprintf ( A->name[i], "%s", name);
+ }
+ A->nseq=nseq;
+
+ return A;
+}
+
+void output_similarities (char *file, Alignment *A, char *mode)
+{
+ float s;
+ float *tot;
+ float bigtot=0;
+ int n, max;
+ FILE *fp;
+ int a, b;
+ char *p;
+ int **M=NULL;
+ for (max=0, a=0; a< A->nseq; a++)max=MAX(max,(strlen (A->name[a])));
+
+
+ tot=vcalloc ( A->nseq, sizeof (float));
+ fp=vfopen (file, "w");
+ fprintf (fp, "# TC_SIMILARITY_MATRIX_FORMAT_01\n");
+ for ( a=0; a<A->nseq; a++)
+ fprintf ( fp, "# SEQ_INDEX %s %d\n",A->name[a],a);
+ fprintf ( fp, "# PW_SEQ_DISTANCES \n");
+ for (n=0,a=0;a< A->nseq-1; a++)
+ {
+ for ( b=a+1; b<A->nseq; b++, n++)
+ {
+ if (strstr (mode, "_sarmat2"))
+ {
+ s=get_sar_sim (A->seq_al[a], A->seq_al[b]);
+ }
+ else if (strstr (mode, "_sar"))
+ {
+ s=get_sar_sim (A->seq_al[a], A->seq_al[b]);
+ }
+ else if ( (p=strstr (mode, "_memory_")))
+ {
+ int **sim;
+ sscanf ( p, "_memory_%ld", (long int*)&sim);
+ s=sim[a][b];
+ }
+ else if ( strstr (mode, "_idscore") || strstr ( mode, "_covscore"))
+ {
+ static Sequence *S;
+ if (a==0 && b==1)
+ {
+ free_sequence (S, -1);
+ if ( strstr (mode, "idscoreDNA"))
+ M=read_matrice ("idmat");
+ else
+ M=read_matrice("blosum62mt");
+
+ S=aln2seq(A);
+ }
+ if ( strstr (mode, "_idscore"))s=idscore_pairseq(S->seq[a], S->seq[b], -10,-1, M, "sim");
+ else s=idscore_pairseq(S->seq[a], S->seq[b], -10,-1, M, "cov");
+ }
+ else if ( strstr (mode, "cov"))
+ {
+ s=get_seq_sim ( A->seq_al[a], A->seq_al[b],GAP_LIST, "cov");
+ }
+ else
+ {
+ s=get_seq_fsim2 (A->seq_al[a], A->seq_al[b],GAP_LIST, mode);
+ }
+ fprintf (fp, "BOT\t %4d %4d\t %5.2f %*s\t %*s\t %5.2f\n", a,b,s,max,A->name[a], max, A->name[b], s);
+ fprintf (fp, "TOP\t %4d %4d\t %5.2f %*s\t %*s\t %5.2f\n", b,a,s,max,A->name[b], max, A->name[a], s);
+ tot[a]+=s;
+ tot[b]+=s;
+ bigtot+=s;
+ }
+ }
+ for ( a=0; a< A->nseq; a++)
+ {
+ fprintf (fp, "AVG\t %d\t %*s\t %*s\t %5.2f\n", a,max,A->name[a], max, "*", tot[a]/(A->nseq-1));
+
+ }
+ vfree (tot);free_int (M, -1);
+ fprintf (fp, "TOT\t %*s\t %*s\t %5.2f\n", max,"TOT", max, "*", bigtot/n);
+ vfclose (fp);
+}
+
+void output_similarities_pw (char *file, Alignment *A, Alignment *B,char *mode)
+{
+ float s;
+ float *tot;
+ float bigtot=0;
+ int n, max;
+ FILE *fp;
+ int a, b;
+
+ int **M=NULL;
+ Sequence *SA, *SB;
+
+ if ( strstr (mode, "idscoreDNA"))
+ M=read_matrice ("idmat");
+ else
+ M=read_matrice("blosum62mt");
+
+ SA=aln2seq(A);
+ SB=aln2seq(B);
+
+ for (max=0, a=0; a< A->nseq; a++)max=MAX(max,(strlen (A->name[a])));
+ for (a=0; a< B->nseq; a++)max=MAX(max,(strlen (B->name[a])));
+
+
+ tot=vcalloc ( A->nseq, sizeof (float));
+ fp=vfopen (file, "w");
+ fprintf (fp, "# TC_SIMILARITY_MATRIX_FORMAT_01\n");
+ for ( a=0; a<A->nseq; a++)
+ fprintf ( fp, "# SEQ_INDEX %s %d\n",A->name[a],a);
+ fprintf ( fp, "# PW_SEQ_DISTANCES \n");
+ for (n=0,a=0;a< A->nseq; a++)
+ {
+ for ( b=0; b<B->nseq; b++, n++)
+ {
+ s=idscore_pairseq(SA->seq[a], SB->seq[b], -10,-1, M, "sim");
+ fprintf (fp, "BOT\t %4d %4d\t %5.2f %*s\t %*s\t %5.2f\n", a,b,s,max,A->name[a], max, B->name[b], s);
+ fprintf (fp, "TOP\t %4d %4d\t %5.2f %*s\t %*s\t %5.2f\n", b,a,s,max,B->name[b], max, A->name[a], s);
+ tot[a]+=s;
+ tot[b]+=s;
+ bigtot+=s;
+ }
+ }
+
+ for ( a=0; a< A->nseq; a++)
+ {
+ fprintf (fp, "AVG\t %d\t %*s\t %*s\t %5.2f\n", a,max,A->name[a], max, "*", tot[a]/(A->nseq-1));
+ }
+ vfree (tot);free_int (M, -1);
+ fprintf (fp, "TOT\t %*s\t %*s\t %5.2f\n", max,"TOT", max, "*", bigtot/n);
+ vfclose (fp);
+}
+void output_conservation_statistics ( char *file, Alignment *A)
+{
+ int a, b, c,c1, c2;
+ double **tot;
+ char aa[1000];
+ int naa;
+
+ sprintf (aa, "%s", BLAST_AA_ALPHABET);
+ naa=strlen (aa);
+
+ tot=declare_double (256, 256);
+
+
+ for ( a=0; a<A->nseq; a+=2)
+ {
+ b=a+1;
+ for ( c=0; c<A->len_aln; c++)
+ {
+ c1=tolower (A->seq_al[a][c]);
+ c2=tolower (A->seq_al[b][c]);
+ if ( !is_gap(c1) && !is_gap(c2))
+ {
+ tot[c1][c2]++;
+ tot[c2][c1]++;
+ tot[c1][0]++;
+ tot[c2][0]++;
+ tot[0][0]++;
+ }
+ }
+ }
+
+ fprintf ( stdout, "# BLAST_MATRIX FORMAT\n#ALPHABET=%s\n",aa);
+ for (a=0; a<naa; a++)fprintf ( stdout, "%3c ", toupper(aa[a]));
+ fprintf ( stdout, "\n");
+ for (a=0; a< naa; a++)
+ {
+ fprintf (stdout, "%c", toupper(aa[a]));
+ for ( b=0; b< naa; b++)
+ {
+ float f1, f2, f3, r, v;
+ c1=tolower(aa[a]);c2=tolower(aa[b]);
+ f1=(float)((tot[c1][c2]*2)/tot[0][0]);
+ f2=(float)((tot[c1][0])/tot[0][0]);
+ f3=(float)((tot[c2][0])/tot[0][0]);
+ r=(float)(f2==0 || f3==0)?0:(f1/(f2*f3));
+ v=(r==0)?0:((float)10*log((double)r));
+ fprintf (stdout, " %5d",(int)v);
+ }
+ fprintf ( stdout, "\n");
+ }
+}
+void output_statistics (char *file, Alignment *A, char *mode)
+ {
+ FILE *fp;
+ int a, b, c, d=0, n;
+ int maxname=0;
+
+
+ if (!mode || !mode[0])
+ mode="hnrglNL";
+ else if ( mode[0]=='_')
+ mode++;
+ for ( a=0; a<A->nseq; a++)maxname=MAX(strlen(A->name[a]), maxname);
+ maxname++;
+
+
+ fp=vfopen (file, "w");
+
+ if (mode[0]=='h')
+ {
+ b=0;
+ while ((c=mode[b++])!='\0')
+ {
+ if ( c=='n') fprintf (fp, "%-*s ",maxname,"name");
+ if ( c=='l') fprintf (fp, "%-*s ",5,"nres");
+ if ( c=='g') fprintf (fp, "%-*s ",5,"ngap");
+ if ( c=='t') fprintf (fp, "%-*s ",5,"len");
+ }
+ if (is_in_set ( c, "nlgt")) fprintf (fp, "\n");
+ mode++;
+ }
+ b=0;
+ while ((c=mode[b++])!='\0')
+ {
+ if ( c=='n')break;
+ if ( c=='N'){d=1;fprintf (fp, "NSEQ %d ", A->nseq);}
+ if ( c=='L'){d=1;fprintf (fp, "LEN %d ", A->len_aln);}
+ }
+ if ( d) fprintf (fp, "\n");
+
+ for (a=0; a<A->nseq; a++)
+ {
+ b=0;
+ d=0;
+ while ((c=mode[b++])!='\0')
+ {
+ if (is_in_set ( c, "nlgt"))d=1;
+
+ if (c=='n'){d=1;fprintf ( fp, "%-*s ", maxname,A->name[a]);}
+ if (c=='l')
+ {
+ for (n=0,d=0; d<A->len_aln; d++)n+=!is_gap(A->seq_al[a][d]);
+ fprintf ( fp, "%-5d ",n);
+ }
+ if (c=='g')
+ {
+ for (n=0,d=0; d<A->len_aln; d++)n+=((is_gap(A->seq_al[a][d]) && !is_gap(A->seq_al[a][d+1]))||(is_gap(A->seq_al[a][d])&& A->seq_al[a][d+1]=='\0')) ;
+ fprintf ( fp, "%-5d ",n);
+ }
+ if (c=='t')
+ {
+ fprintf ( fp, "%-5d ",(int)strlen (A->seq_al[a]));
+ }
+ if (c=='N' && d)
+ {
+ fprintf ( fp, "%-5d ",A->nseq);
+ }
+ if (c=='L'&& d)
+ {
+ fprintf ( fp, "%-5d ",A->len_aln);
+ }
+ }
+ if (d)fprintf ( fp, "\n");
+ }
+ vfclose (fp);
+ }
+
+int output_age_matrix ( char *outfile, int val)
+{
+ int **mat;
+ int a, b;
+ char alp[]="abcdefghij-";
+ int naa;
+
+ mat=declare_int ( 256, 256);
+ naa=strlen (alp);
+ for ( a=0; a<naa; a++)
+ for ( b=0; b<naa; b++)
+ {
+ if (is_gap(alp[a]) ||is_gap(alp[b] ))mat[(int)alp[a]][(int)alp[b]]=((val==0)?1:val)*-1;
+ else mat[(int)alp[a]][(int)alp[b]]=(FABS((a-b))*-1)*((val==0)?1:val);
+
+ }
+ output_mat ( mat,outfile, alp, 0);
+ free_arrayN((void**)mat, 2);
+ return 1;
+}
+
+
+
+
+int output_transitions(char *outfile, Alignment *A)
+{
+ double table[256][256];
+ double symbols[256];
+ double tot, l, freq, expected, log_odd;
+ int a, b;
+ char *s;
+ char *alp;
+ int naa=0;
+ int **mat;
+ float **fmat;
+
+ FILE *fp;
+
+ for ( a=0; a< 256; a++)
+ for (b=0; b<256; b++)
+ {
+ symbols[b]=0;
+ table[a][b]=0;
+ }
+ alp=vcalloc ( 256, sizeof (char));
+ mat=declare_int ( 256,256);
+ fmat=declare_float ( 256,256);
+
+ for (tot=0,a=0; a< A->nseq; a++)
+ {
+ ungap (A->seq_al[a]);
+ lower_string (A->seq_al[a]);
+ s=A->seq_al[a];
+ l=strlen (s);
+ if ( s[0]=='\0') continue;
+ symbols[(int)s[0]]++;
+ for ( b=1; b< l; b++)
+ {
+ symbols[(int)s[b]]++;
+ table[(int)s[b-1]][(int)s[b]]++;
+ tot++;
+ }
+ }
+ for (naa=0, a=0; a< 256; a++)
+ {
+ if (symbols[a])alp[naa++]=a;
+ }
+
+
+ for ( a=0; a< 256; a++)
+ for (b=0; b<256; b++)
+ {
+ if (symbols[a]&& symbols[b] && table[a][b] && tot>0)
+ {
+ freq=(table[a][b])/tot;
+ expected=(symbols[a]*symbols[b])/(tot*tot);
+ log_odd=log (freq/expected);
+ mat[a-'A'][b-'A']=log_odd*10;
+ fmat[a-'A'][b-'A']=log_odd;
+ }
+ else if ( symbols[a]&& symbols[b])
+ {
+ mat[a-'A'][b-'A']=-999;
+ fmat[a-'A'][b-'A']=-999;
+ }
+ }
+ output_mat ( mat,outfile, alp, 'A');
+
+ fp=vfopen (outfile, "a");
+ for ( a=0; a<256; a++)
+ if ( symbols[a])
+ {
+ fprintf (fp, "# %c tot: %6d freq: %7.5f\n", a, (int)symbols[a],(float)symbols[a]/tot);
+ }
+
+ for ( a=0; a< 256; a++)
+ for (b=0; b<256; b++)
+ {
+ if (symbols[a]&& symbols[b])
+ {
+ freq=(table[a][b])/tot;
+ fprintf (fp, "# %c%c tot: %6d freq: %7.5f log_odd: %9.3f\n", a, b, (int)table[a][b],(float)freq,fmat[a-'A'][b-'A']);
+ }
+ }
+ vfclose (fp);
+ vfree(alp);
+ free_arrayN ((void **)mat, 2);
+ free_arrayN ((void **)fmat, 2);
+
+ return 1;
+}
+
+
+
+void output_est_prf (char *fname, Alignment *A)
+ {
+ int a;
+ FILE *fp;
+
+ if ( !A->P)
+ {
+ fprintf ( stderr, "\nFormat output_est_prf Impossible: No profile\n");
+ myexit(EXIT_FAILURE);
+ }
+
+
+ fp=vfopen ( fname, "w");
+ fprintf ( fp, "Consensus Sequence\nReconstructed with %s (%s,%s)\n",PROGRAM,AUTHOR,DATE);
+ fprintf ( fp, "%4c %4c %4c %4c %15s Consensus\n", 'A','G','C','T', "Internal Gaps");
+
+ for ( a=0; a< A->len_aln; a++)
+ {
+ fprintf (fp, "%4d %4d %4d %4d %15d %c\n", (A->P)->count[0][a],(A->P)->count[1][a],(A->P)->count[2][a], (A->P)->count[3][a], (A->P)->count[4][a],A->seq_al[0][a]);
+ }
+ return;
+ }
+
+
+void output_gotoh_seq (char *fname, Alignment*A )
+ {
+ int a;
+ FILE *fp;
+
+ fp=vfopen ( fname, "w");
+ fprintf ( fp, "%d %d\n",A->nseq, A->max_len);
+ for ( a=0; a< A->nseq; a++)
+ {
+ ungap ( A->seq_al[a]);
+ fprintf ( fp, ">%s\n", A->name[a]);
+ fp=output_string_wrap ( 50,A->seq_al[a] , fp);
+ fprintf ( fp, "//\n");
+ }
+
+ vfclose (fp);
+ }
+
+void output_mult_fasta_seq (char *fname, Alignment*A, int n )
+ {
+ int a;
+ FILE *fp;
+
+ fp=vfopen (fname, "w");
+ ungap(A->seq_al[0]);
+ for (a=0; a<n; a++)
+ {
+ fprintf (fp, ">%s_%d\n%s\n", A->name[0],a+1, A->seq_al[0]);
+ }
+ vfclose (fp);
+ }
+int output_wexons (char *name, Alignment *A)
+{
+ int a,b,c;
+ FILE *fp;
+ int **w;
+ fp=vfopen (name, "w");
+ if (!fp) return 0;
+ if (!A) {vfclose(fp);return 0;}
+ w=A->score_res;
+ if (!w) {vfclose (fp);return 0; }
+
+ for (a=0; a<A->nseq; a++)
+ {
+ fprintf (fp, ">%s\n", A->name[a]);
+ for (c=0,b=0; b<A->len_aln; b++)
+ {
+ int r;
+ r=A->seq_al[a][b];
+ if (!is_gap(r) && r!='f' && r!='F')
+ {
+ fprintf (fp, " %c %d ", r,w[a][c++]);
+ }
+ else if (!is_gap(r))fprintf (fp,"%c -1 ",r);
+ }
+ fprintf (fp, "\n");
+ }
+ return 1;
+}
+char * output_fasta_seqX (char *name, char *mode, Sequence *S, Alignment *A, int i)
+{
+ FILE *fp;
+
+ if (!name)name=vtmpnam (NULL);
+ fp=vfopen (name, mode);
+ if ( (S && S->nseq<=i) || (A && S->nseq<=i) || (!A && !S))
+ {
+ fprintf ( stderr, "\nERROR in function reformat:output_fasta_seqX[FATAL:%s]", PROGRAM);
+ myexit (EXIT_FAILURE);
+ }
+
+ else if ( S)
+ fprintf ( fp, ">%s %s\n%s\n", S->name[i], S->seq_comment[i], S->seq[i]);
+ else if ( A)
+ {
+ ungap (A->seq_al[i]);
+ fprintf ( fp, ">%s %s\n%s\n", A->name[i], A->seq_comment[i], A->seq_al[i]);
+ }
+ vfclose (fp);
+ return name;
+}
+
+void output_fasta_seq1 (char *fname, Alignment*A )
+ {
+ char seq_name[VERY_LONG_STRING];
+ int a;
+ FILE *fp;
+ char *extension;
+
+ for ( a=0; a< A->nseq; a++)
+ {
+ if ( strncmp( fname, "name",4)==0)
+ {
+ if ( (fname+4)[0]!='\0')extension=fname+5;
+ else
+ extension=NULL;
+
+ sprintf ( seq_name,"%s.%s", A->name[a],(extension==NULL)?"seq":extension);
+ }
+ else
+ sprintf ( seq_name,"%s.seq",A->name[a]);
+
+ ungap ( A->seq_al[a]);
+ fp=vfopen (seq_name, "w");
+ fprintf (fp, ">%s %s\n", A->name[a], A->seq_comment[a]);
+ fp=output_string_wrap ( 50, A->seq_al[a],fp);
+ fprintf ( fp, "\n");
+ vfclose (fp);
+ }
+ }
+void output_pir_check (char *fname,int nseq, char **comment )
+ {
+ int a;
+ FILE *fp;
+
+ if ( fname==NULL)return;
+ fp=vfopen ( fname, "w");
+
+ for ( a=0; a< nseq; a++)fprintf (fp, "%s\n", comment[a]);
+ vfclose (fp);
+ }
+void output_fasta_seqS (char *fname, Sequence *S)
+{
+ Alignment *A;
+ A=seq2aln (S,NULL,RM_GAP);
+ output_fasta_seq (fname, A);
+ free_aln (A);
+}
+
+void output_fasta_seq (char *fname, Alignment*A)
+{
+ main_output_fasta_seq (fname, A, HEADER);
+}
+void output_fasta_tree (char *fname, Alignment*A)
+ {
+ int a;
+ FILE *fp;
+ if ( !A || !A->nseq) return;
+
+ fp=vfopen ( fname, "w");
+
+ for ( a=0; a< A->nseq; a++)
+ {
+ fprintf ( fp, ">%s %s\n%s\n", A->name[a], A->seq_comment[a], A->seq_al[a]);
+ }
+ vfclose (fp);
+ }
+void main_output_fasta_seq (char *fname, Alignment*A,int header )
+ {
+ int a;
+ FILE *fp;
+
+ fp=vfopen ( fname, "w");
+
+ for ( a=0; a< A->nseq; a++)
+ {
+ ungap(A->seq_al[a]);
+ fprintf ( fp, ">%s", A->name[a]);
+ if (header==HEADER && A->seq_comment[a][0] && !isblanc(A->seq_comment[a]))fprintf (fp," %s\n",A->seq_comment[a]);
+ else fprintf ( fp, "\n");
+ fp=output_string_wrap ( 50, A->seq_al[a],fp);
+ fprintf ( fp, "\n");
+ }
+ vfclose (fp);
+ }
+void output_gor_seq (char *fname, Alignment*A )
+ {
+ int a;
+ FILE *fp;
+
+ fp=vfopen ( fname, "w");
+
+ for ( a=0; a< A->nseq; a++)
+ {
+ ungap(A->seq_al[a]);
+ fprintf ( fp, "!%s %d \n", A->name[a], (int)strlen(A->seq_al[a]));
+ upper_string ( A->seq_al[a]);
+ fp=output_string_wrap ( 50, A->seq_al[a],fp);
+ fprintf ( fp, "@\n");
+ }
+ vfclose (fp);
+ }
+void output_pir_seq (char *fname, Alignment*A )
+ {
+ int a;
+ for ( a=0; a< A->nseq; a++)ungap(A->seq_al[a]);
+ output_pir_aln (fname, A);
+ }
+void output_pir_seq1 (char *fname, Alignment*A )
+ {
+ char seq_name[VERY_LONG_STRING];
+ int a;
+ FILE *fp;
+ char type[20];
+
+
+ for ( a=0; a< A->nseq; a++)
+ {
+ if ( strm ( get_string_type (A->seq_al[a]),"DNA") || strm ( get_string_type (A->seq_al[a]),"RNA"))sprintf(type, "DL");
+ else if ( strm ( get_string_type (A->seq_al[a]),"PROTEIN"))sprintf(type, "P1");
+ sprintf ( seq_name,"%s;%s_%s.seq",type, fname,A->name[a]);
+ ungap ( A->seq_al[a]);
+ fp=vfopen (seq_name, "w");
+ fprintf (fp, ">%s\n\n", A->name[a]);
+ fp=output_string_wrap ( 50, A->seq_al[a],fp);
+ fprintf ( fp, "\n*\n");
+ vfclose (fp);
+ }
+ }
+/*******************************************************************************************/
+/* */
+/* */
+/* OUTPUT ALN */
+/* */
+/***************************************************************************************** */
+void output_mocca_aln (char *outfile, Alignment *A, Alignment *S)
+ {
+ FILE *fp;
+ int **score;
+ char **new_name_order;
+ int a, maxl;
+
+ score=declare_int (S->nseq, 2);
+ new_name_order=declare_char ( S->nseq,MAXNAMES+1);
+ for ( a=0; a<A->nseq; a++)
+ {
+ score[a][0]=a;
+ score[a][1]=S->score_seq[a];
+ }
+ sort_int_inv (score+1,2,1,0,S->nseq-2);
+ for ( a=0; a<A->nseq; a++)
+ {
+ sprintf ( new_name_order[a], "%s", A->name[score[a][0]]);
+ }
+ A=reorder_aln (A, new_name_order, A->nseq);
+
+ fp=vfopen (outfile, "w");
+ fprintf ( fp, "MOCCA,(%s,%s, C. Notredame)\nSCORE %d\nNSEQ %d\nLEN %d\n",VERSION,DATE, A->score_aln, A->nseq, A->len_aln);
+
+ maxl=return_maxlen ( new_name_order, A->nseq);
+
+
+ for (a=0; a< A->nseq; a++)
+ {
+ fprintf (fp, "%-*s: %3d\n", maxl, A->name[a], score[a][1]);
+ }
+
+ fprintf ( fp, "\n");
+
+ fp=output_Alignment_without_header ( A, fp);
+ vfclose (fp);
+ free_int (score, -1);
+ free_char (new_name_order, -1);
+ return ;
+ }
+
+void print_sub_aln ( Alignment *B, int *ns, int **ls)
+{
+ Alignment *X;
+ int a, b;
+
+
+ X=copy_aln (B, NULL);
+ X->nseq=0;
+ X->len_aln=strlen ( B->seq_al[ls[0][0]]);
+
+
+ for (a=0; a< 2; a++)
+ for ( b=0; b<ns[a]; b++, X->nseq++)
+ {
+ sprintf ( X->seq_al[X->nseq], "%s", B->seq_al[ls[a][b]]);
+ sprintf ( X->name[X->nseq], "%s", B->name[ls[a][b]]);
+ }
+ X->name[X->nseq][0]='\0';
+
+ print_aln (X);
+ free_aln (X);
+}
+void print_aln ( Alignment *B)
+ {
+
+ while(B)
+ {
+ output_Alignment_without_header ( B, stderr);
+ B=B->A;
+ }
+ }
+
+
+FILE * output_aln ( Alignment *B, FILE *fp){return output_Alignment(B, fp);}
+FILE * output_Alignment ( Alignment *B, FILE *fp)
+ {
+ fprintf ( fp, "%s, %s (%s) [%s] [MODE: %s]\n%s\nCPU %d sec\nSCORE %d\nNSEQ %d\nLEN %d\n",PROGRAM,VERSION,DATE,retrieve_mode(),URL,AUTHOR, (B->cpu+get_time())/1000, B->score_aln, B->nseq, B->len_aln);
+
+ return output_Alignment_without_header ( B, fp);
+ }
+
+FILE * output_Alignment_without_header ( Alignment *B, FILE *fp)
+ {
+ int a,b, c;
+ int max_len=0;
+ int line;
+ int *n_residues;
+ char s;
+
+
+ if (fp==NULL)return fp;
+ for ( a=0; a< B->nseq; a++)
+ {if ( strlen (B->name[a])>max_len)
+ max_len= strlen ( (B->name[a]));
+ }
+ max_len=MAX(max_len+2, 16);
+ line=get_msa_line_length (0, 0);
+ n_residues=vcalloc ( B->nseq+1, sizeof (int));
+ for ( a=0; a<B->nseq; a++)n_residues[a]=(B->output_res_num==2)?B->order[a][1]:0;
+
+
+
+
+ fprintf ( fp, "\n");
+ for (a=0; a<B->len_aln; a+=line)
+ {for (b=0; b<=B->nseq; b++)
+ {
+ fprintf (fp,"%-*s",max_len,B->name[b]);
+ if (B->output_res_num)fprintf (fp, " %4d ", n_residues[b]+1);
+ for (c=a;c<a+line && c<B->len_aln;c++)
+ {
+ if (b==B->nseq){n_residues[b]++;s=analyse_aln_column ( B, c);}
+ else
+ {n_residues[b]+=!is_gap(B->seq_al[b][c]);
+ s=GET_CASE(B->residue_case, B->seq_al[b][c]);
+ }
+
+ fprintf (fp,"%c",s );
+ }
+ if (B->output_res_num)fprintf (fp, " %4d", n_residues[b]);
+ fprintf (fp,"\n");
+ }
+
+ fprintf (fp,"\n");
+ }
+
+ fprintf (fp,"\n\n");
+ vfree (n_residues);
+
+ return fp;
+ }
+FILE * output_aln_score ( Alignment *B, FILE *fp){return output_Alignment_score(B, fp);}
+FILE * output_Alignment_score ( Alignment *B, FILE *fp)
+ {
+ int a, b, c;
+ static int max_len=0;
+ static int line;
+ int ch;
+
+ if (fp==NULL)return fp;
+ if ( max_len==0)
+ {
+ for ( a=0; a< B->nseq; a++)
+ {if ( strlen (B->name[a])>max_len)
+ max_len= strlen ( (B->name[a]));
+ }
+ max_len+=4;
+
+ }
+ line=get_msa_line_length(0, 0);
+ sprintf (B->name[B->nseq], "CONS");
+ fprintf ( fp, "T_COFFEE ALIGNMENT\nCPU TIME:%d sec.\n", (B->cpu+get_time())/1000);
+ fprintf ( fp, "SCORE=%d\n", B->score_aln);
+ for ( a=0;a<B->nseq; a++)fprintf ( fp, "%s: %d\n", B->name[a], B->score_seq[a]);
+ fprintf ( fp, "\n");
+ for (a=0; a<B->len_aln; a+=line)
+ {for (b=0; b<B->nseq; b++)
+ {
+ fprintf (fp,"%-*s",max_len,B->name[b]);
+ for (c=a;c<a+line && c<B->len_aln;c++)
+ {
+ ch=B->seq_al[b][c];
+ if (ch==NO_COLOR_RESIDUE)fprintf (fp,"-");
+ else if ( ch==NO_COLOR_GAP)fprintf (fp,"*");
+ else if ( ch<10 && ch>=0)fprintf (fp,"%d",ch);
+ else if ( ch>10)fprintf (fp,"#");
+ else if ( ch<0)fprintf (fp,".");
+ else fprintf (fp,"9");
+ }
+ fprintf (fp,"\n");
+ }
+ fprintf (fp,"\n");
+ fprintf (fp,"%-*s",max_len,B->name[b]);
+ for (c=a;c<a+line && c<B->len_aln;c++)
+ {
+ ch=B->seq_al[b][c];
+ if (ch==NO_COLOR_RESIDUE)fprintf (fp,"-");
+ else if ( ch==NO_COLOR_GAP)fprintf ( fp, "*");
+ else if ( ch<10 && ch>=0)fprintf (fp,"%d",ch);
+ else if ( ch>10)fprintf (fp,"#");
+ else if ( ch<0)fprintf (fp,".");
+ else fprintf (fp,"9");
+ }
+ fprintf (fp,"\n\n\n");
+ }
+ fprintf (fp,"\n\n");
+ return fp;
+ }
+FILE * output_aln_with_res_number ( Alignment *B, FILE *fp){return output_Alignment_with_res_number(B, fp);}
+FILE * output_Alignment_with_res_number ( Alignment *B, FILE *fp)
+ {
+ int a, b, c;
+ static int max_len=0;
+ static int line;
+ int**order;
+
+ if (fp==NULL)return fp;
+ if ( max_len==0)
+ {
+ for ( a=0; a< B->nseq; a++)
+ {if ( strlen (B->name[a])>max_len)
+ max_len= strlen ( (B->name[a]));
+ }
+ max_len+=4;
+ line=60;
+ }
+ order=copy_int ( B->order,declare_int ( B->nseq, 2), B->nseq, 2);
+
+ fprintf ( fp, "T_COFFEE ALIGNMENT\nCPU TIME:%d sec.\n", (B->cpu+get_time())/1000);
+ fprintf ( fp, "\n");
+ for (a=0; a<B->len_aln; a+=line)
+ {for (b=0; b<B->nseq; b++)
+ {
+ fprintf (fp,"%-*s %3d %4d ",max_len,B->name[b], order[b][0], order[b][1] );
+ for (c=a;c<a+line && c<B->len_aln;c++)
+ {
+ order[b][1]+=1-is_gap(B->seq_al[b][c]);
+ fprintf (fp,"%c",toupper(B->seq_al[b][c]) );
+ }
+ fprintf (fp," %4d\n", order[b][1] );
+ }
+ fprintf (fp,"\n");
+ }
+ fprintf (fp,"\n\n");
+
+ free_int (order, -1);
+ return fp;
+ }
+
+void output_constraints ( char *fname, char *mode,Alignment *A)
+ {
+ FILE *fp;
+ Constraint_list *CL;
+ char *buf;
+ char **name_list;
+
+ if ( !A->CL || strm ( mode, "pdb"))
+ {
+ if (!A->S)
+ {
+ A->S=aln2seq(A);
+ }
+
+ CL=declare_constraint_list ( A->S, NULL, NULL, 0, NULL, NULL);
+ CL=aln2constraint_list (A,CL, mode);
+ fp=save_constraint_list ( CL, 0, CL->ne,fname, NULL, "lib",A->S);
+ vfclose (fp);
+ free_constraint_list (CL);
+ return;
+ }
+ else if ( strncmp ( mode, "extended_pair", 13)==0)
+ {
+ buf=duplicate_string (mode+14);
+
+ name_list=vcalloc(2, sizeof(char*));
+ name_list[0]=strtok (buf,"_");
+ name_list[1]=strtok (NULL,"_");
+ mode[13]='\0';
+
+
+ CL=A->CL;
+ fp=save_sub_list_header (vfopen(fname, "w"),2, name_list,CL);
+ fp=save_extended_constraint_list_pair (CL, "pair",name_list[0],name_list[1],fp);
+ fp=save_list_footer (fp, CL);
+ vfree (buf);
+ }
+ else if ( strm2 (mode, "extended_lib","extended_cosmetic"))
+ {
+ CL=A->CL;
+ fp=save_extended_constraint_list ( CL,mode+9, vfopen(fname, "w"));
+ }
+ else
+ {
+ CL=(Constraint_list *)A->CL;
+ fp=save_constraint_list ( CL, 0, CL->ne,fname, NULL, "lib",A->S);
+ }
+ vfclose ( fp);
+
+ if ( (Constraint_list *)A->CL !=CL)free_constraint_list (CL);
+
+ return;
+
+ }
+void output_model_aln (char *fname, Alignment*A )
+ {
+ FILE *fp;
+ int a;
+ Dp_Model *M;
+ Dp_Result *R;
+ char *string;
+
+ if ( A->Dp_result==NULL)
+ {
+ fprintf ( stderr, "\nWARNING Could Not Output Model %s [%s]", fname, PROGRAM);
+ }
+ R=A->Dp_result;
+ M=R->Dp_model;
+
+ fp=vfopen ( fname, "w");
+ for (a=0; a<M->nstate; a++)
+ {
+ if (M->model_comments[a][0])fprintf ( fp, "#STATE %c: %s\n", 'a'+a, M->model_comments[a]);
+ }
+ string=vcalloc ( R->len+1, sizeof (char));
+ for (a=0; a<R->len; a++)string[a]=R->traceback[a]+'a';
+ fprintf ( fp, ">%s\n",fname);
+ fp=output_string_wrap ( 50,string, fp);
+ vfree(string);
+ fprintf ( fp, "\n");
+
+ vfclose (fp);
+ return;
+ }
+char * output_fasta_sub_aln (char *fname, Alignment*A, int ns, int *ls )
+{
+ int a,s;
+ FILE *fp;
+ if (fname==NULL)fname=vtmpnam (NULL);
+ fp=vfopen (fname, "w");
+ for (a=0; a<ns; a++)
+ {
+ s=ls[a];
+ fprintf (fp, ">%s %s\n%s\n", A->name[s],A->seq_comment[s],A->seq_al[s]);
+ }
+ vfclose (fp);
+ return fname;
+}
+char * output_fasta_sub_aln2 (char *fname, Alignment*A, int *ns, int **ls )
+{
+ int a,g,s;
+ FILE *fp;
+ if (fname==NULL)fname=vtmpnam (NULL);
+ fp=vfopen (fname, "w");
+ for ( g=0; g<2; g++)
+ for (a=0; a<ns[g]; a++)
+ {
+ s=ls[g][a];
+ fprintf (fp, ">%s %s\n%s\n", A->name[s],A->seq_comment[s],A->seq_al[s]);
+ }
+ vfclose (fp);
+ return fname;
+}
+
+int output_suchard_aln (char *out_file, Alignment *A)
+{
+ int a, b, c, d;
+ FILE *fp;
+
+ A=back_translate_dna_aln (A);
+
+ for ( c=0,a=0; a<A->len_aln; a++, c++)
+ {
+ if (c==3)c=0;
+ for (b=0; b<A->nseq; b++)
+ {
+ if (c==2)
+ {
+ A->seq_al[b][a]='-';
+ }
+ }
+ }
+ A=ungap_aln_n (A, 1);
+ fp=vfopen (out_file, "w");
+ for ( a=0; a< A->nseq; a++)
+ {
+ for (b=0; b< A->len_aln; b++)
+ {
+ c=tolower(A->seq_al[a][b]);
+ if ( c=='a')d=1;
+ else if ( c=='g')d=2;
+ else if ( c=='c')d=3;
+ else if ( c=='t')d=4;
+ else if ( c=='u')d=5;
+ else d=6;
+
+ fprintf ( fp, "%d", d);
+ }
+ fprintf ( fp, "\n");
+ }
+ vfclose (fp);
+ myexit (EXIT_SUCCESS);
+}
+
+void output_fasta_aln (char *fname, Alignment*A )
+ {
+ FILE *fp;
+ int a;
+ int line=0;
+
+ line=get_msa_line_length (line, A->len_aln+1);
+ fp=vfopen ( fname, "w");
+
+ for ( a=0; a< A->nseq; a++)
+ {
+ fprintf ( fp, ">%s", A->name[a]);
+
+ if ( A->seq_comment[a][0] && !isblanc (A->seq_comment[a]))fprintf ( fp, " %s", A->seq_comment[a]);
+ fprintf ( fp, "\n");
+ fp=output_string_wrap ( line,A->seq_al[a] , fp);
+ fprintf ( fp, "\n");
+ }
+ vfclose (fp);
+ }
+
+void output_pir_aln (char *fname, Alignment*A )
+ {
+ int a;
+ FILE *fp;
+ char type[20];
+
+
+
+
+
+ fp=vfopen ( fname, "w");
+ for ( a=0; a< A->nseq; a++)
+ {
+ if ( strm ( get_string_type (A->seq_al[a]),"DNA") || strm ( get_string_type (A->seq_al[a]),"RNA"))sprintf(type, "DL");
+ else if ( strm ( get_string_type (A->seq_al[a]),"PROTEIN"))sprintf(type, "P1");
+ fprintf ( fp, ">%s;%s\n%s\n",type, A->name[a], A->seq_comment[a]);
+ fp=output_string_wrap ( 50,A->seq_al[a] , fp);
+ fprintf ( fp, "\n*\n");
+ }
+
+ vfclose (fp);
+ }
+
+int landscape_msa;
+int set_landscape_msa (int len)
+{
+ if ( len==0)landscape_msa=-1;
+ else
+ {
+ landscape_msa=len;
+ }
+ return landscape_msa;
+}
+int get_msa_line_length (int line, int aln_len)
+{
+ if (landscape_msa==-1) return aln_len;
+ else if ( landscape_msa)return landscape_msa;
+ else if (line) return line;
+ else
+ {
+ return (getenv ("ALN_LINE_LENGTH"))?atoi(getenv("ALN_LINE_LENGTH")):ALN_LINE_LENGTH;
+ }
+}
+
+void output_msf_aln (char *fname,Alignment *B)
+ {
+ int a, b, c;
+ char *seq;
+ int *all_checks;
+ int i,j;
+ long grand_checksum;
+ FILE *fp;
+ int max_len;
+ int line=0;
+ int block=10;
+ int c_block;
+ char aa;
+
+
+ line=get_msa_line_length (line, B->len_aln+1);
+
+
+ for ( max_len=0,a=0; a< B->nseq; a++)max_len= MAX(strlen ( B->name[a]),max_len);
+
+
+ max_len+=5;
+
+ fp=vfopen (fname, "w");
+
+ seq =vcalloc(B->len_aln, sizeof(char));
+ all_checks =vcalloc(B->nseq, sizeof(int));
+ for ( i=0; i< B->nseq; i++)
+ {
+ for ( j=0; j<B->len_aln; j++)
+ {
+ if ( is_gap(B->seq_al[i][j]))seq[j]='.';
+ else seq[j]=B->seq_al[i][j]=toupper(B->seq_al[i][j]);
+
+ }
+ all_checks[i] = SeqGCGCheckSum(seq, (int)B->len_aln);
+ }
+ grand_checksum = 0;
+ for(i=0; i<B->nseq; i++) grand_checksum += all_checks[i];
+ grand_checksum = grand_checksum % 10000;
+ fprintf(fp,"PileUp\n\n");
+ B=get_aln_type(B);
+ fprintf(fp,"\n\n MSF:%5d Type: ",B->len_aln);
+ if(strm ( (B->S)->type, "DNA") || strm ( (B->S)->type, "RNA"))
+ fprintf(fp,"N");
+ else
+ fprintf(fp,"P");
+ fprintf(fp," Check:%6ld .. \n\n", (long)grand_checksum);
+ for (i=0; i< B->nseq; i++)
+ {
+ fprintf ( fp, " Name: %s oo Len:%5d Check:%6ld Weight: %.3f\n", B->name[i], B->len_aln,(long)all_checks[i],(B->S)->W?((B->S)->W)->SEQ_W[i]:1.00);
+ }
+ fprintf(fp,"\n//\n\n");
+
+ for (a=0; a<B->len_aln; a+=line)
+ {
+ fprintf ( fp,"\n\n");
+ for (b=0; b<B->nseq; b++)
+ {
+ fprintf (fp,"%-*s ",max_len,B->name[b]);
+ for (c_block=0,c=a;c<a+line && c<B->len_aln;c++)
+ {
+ if ( c_block==block)
+ {
+ fprintf (fp, " ");
+ c_block=0;
+ }
+ c_block++;
+ aa=(is_gap(B->seq_al[b][c]))?'.': toupper(B->seq_al[b][c]);
+ fprintf (fp,"%c",aa );
+ }
+ if ( c_block==block)
+ {
+ fprintf (fp, " ");
+ c_block=0;
+ }
+ fprintf (fp,"\n");
+
+ }
+ }
+ fprintf ( fp,"\n");
+ vfclose ( fp);
+
+
+ vfree(seq);
+ vfree(all_checks);
+
+
+ return;
+}
+int SeqGCGCheckSum(char *seq, int len)
+{
+ int i;
+ long check;
+
+ for( i=0, check=0; i< len; i++,seq++)
+ check += ((i % 57)+1) * toupper(*seq);
+
+ return(check % 10000);
+}
+void old_output_msf_aln (char *fname,Alignment *B)
+ {
+ FILE *fp;
+ static int *put_seq;
+ int a, b, c;
+ int line=0;
+ char aa;
+ char *buf;
+ int max_len;
+ int seq_max_len;
+
+ line=get_msa_line_length (line, B->len_aln+1);
+
+
+ for ( max_len=0,a=0; a< B->nseq; a++)max_len= MAX(strlen ( B->name[a]),max_len);
+ for ( seq_max_len=0,a=0; a< B->nseq; a++)seq_max_len= MAX(strlen ( B->seq_al[a]),max_len);
+
+
+ buf=vcalloc(seq_max_len+1, sizeof (int));
+
+ if ( put_seq==NULL)
+ put_seq= vcalloc ( B->nseq, sizeof (int));
+ put_seq[0]=1;
+
+
+ for ( b=1; b< B->nseq; b++)
+ {
+ sprintf ( buf, "%s", B->seq_al[b]);
+ ungap(buf);
+ put_seq[b]=( strlen (buf)>0)?1:0;
+ }
+
+ fp=vfopen ( fname, "w");
+ fprintf ( fp, "MSF: %d Type P Check: 5083 ..\n", B->len_aln);
+ for ( a=0; a< B->nseq; a++)
+ {
+ if ( put_seq[a]==1)
+ fprintf ( fp,"Name: %s\n",B->name[a]);
+ }
+ fprintf ( fp, "//\n");
+ for (a=0; a<B->len_aln; a+=line)
+ {for (b=0; b<B->nseq; b++)
+ {
+ if ( put_seq[b]==1)
+ {
+ fprintf (fp,"%-*s ",max_len,B->name[b]);
+ for (c=a;c<a+line && c<B->len_aln;c++)
+ {
+
+
+
+ aa=(B->seq_al[b][c]=='-')?'.': toupper(B->seq_al[b][c]);
+ fprintf (fp,"%c",aa );
+ }
+ fprintf (fp,"\n");
+ }
+ }
+ fprintf (fp,"\n");
+ }
+ fprintf ( fp,"\n\n");
+ vfclose ( fp);
+
+ vfree (buf);
+ vfree(put_seq);
+ }
+
+void output_saga_aln ( char *name, Alignment *B)
+ {
+ int a, b, c;
+ FILE *fp;
+
+
+
+ int max_len;
+ int line=0;
+
+ line=get_msa_line_length (line, B->len_aln+1);
+
+
+
+ for ( max_len=0,a=0; a< B->nseq; a++)max_len= (strlen ( B->name[a])>max_len)?(strlen ( B->name[a])):max_len;
+
+
+
+
+ fp= vfopen ( name, "w");
+
+ fprintf (fp, "\nSAGA FORMAT\nalignement %s nseq=%d len=%d\n", name, B->nseq, B->len_aln);
+
+ fprintf (fp, "\n\n");
+ for (a=0; a<B->len_aln; a+=line)
+ {for (b=0; b<B->nseq; b++)
+ {fprintf (fp,"%-*s ",max_len,B->name[b]);
+ for (c=a;c<a+line && c<B->len_aln;c++)
+ {
+ fprintf (fp,"%c",(B->seq_al[b][c]) );
+ }
+ fprintf (fp,"\n");
+ }
+ fprintf (fp,"\n");
+ }
+ fprintf (fp,"\n\n");
+ vfclose ( fp);
+ }
+void output_compact_aln ( char *name, Alignment *B)
+ {
+ int a, b, c;
+ FILE *fp;
+ int do_print=0;
+
+
+ int max_len;
+ int line=0;
+
+ line=get_msa_line_length (line, B->len_aln+1);
+
+
+ for ( max_len=0,a=0; a< B->nseq; a++)max_len= (strlen ( B->name[a])>max_len)?(strlen ( B->name[a])):max_len;
+
+
+
+
+ fp= vfopen ( name, "w");
+
+ fprintf (fp, "\nSAGA FORMAT\nalignement %s nseq=%d len=%d", name, B->nseq, B->len_aln);
+ fprintf (fp, "\n\n");
+ for (a=0; a<B->len_aln; a+=line)
+ {for (b=0; b<B->nseq; b++)
+ {
+
+ for ( do_print=0, c=a;c<a+line && c<B->len_aln;c++)
+ do_print+=1-is_gap(B->seq_al[b][c]);
+ if ( do_print>0)
+ {
+ fprintf (fp,"%-*s ",max_len,B->name[b]);
+
+
+
+ for (c=a;c<a+line && c<B->len_aln;c++)
+ {
+ if ( is_gap(B->seq_al[b][c])&& B->seq_al[b][c]!='-' )fprintf (fp,"%c", '-');
+ else fprintf (fp,"%c",(B->seq_al[b][c]) );
+ }
+ fprintf (fp,"\n");
+ }
+ }
+ fprintf (fp,"\n");
+ }
+ fprintf (fp,"\n\n");
+ vfclose ( fp);
+ }
+
+void output_clustal_aln ( char *name, Alignment *B)
+{
+ return output_generic_clustal_aln (name, B, "tc_clustal");
+}
+void output_strict_clustal_aln ( char *name, Alignment *B)
+{
+ return output_generic_clustal_aln (name, B, "strict_clustal");
+}
+
+void output_generic_clustal_aln ( char *name, Alignment *B, char *mode)
+ {
+ int a, b, c;
+ FILE *fp;
+ int max_len=0;
+ int line=0;
+ int *n_residues;
+
+ if ( getenv ("SEP_4_TCOFFEE"))
+ {
+ while ( line<B->len_aln && B->seq_al[0][line]!='o' && B->seq_al[0][line]!='O')line++;
+ if ( B->seq_al[0][line]=='O' || B->seq_al[0][line]=='o')line++;
+ }
+ else
+ {
+ while ( line<B->len_aln)line++;
+ }
+
+ if ( line==B->len_aln)line=get_msa_line_length (0, B->len_aln+1);
+
+ n_residues=vcalloc ( B->nseq+1, sizeof (int));
+ for ( a=0; a< B->nseq; a++)
+ {if ( strlen (B->name[a])>max_len)
+ max_len= strlen ( (B->name[a]));
+ n_residues[a]=B->order[a][1];
+ }
+ max_len=MAX(max_len+2, 16);
+
+
+ fp= vfopen ( name, "w");
+
+ if ( strm (mode, "strict_clustal"))
+ fprintf ( fp, "CLUSTAL W (1.83) multiple sequence alignment");
+ else
+ {
+ fprintf (fp, "CLUSTAL FORMAT for %s %s [%s] [MODE: %s ], CPU=%.2f sec, SCORE=%d, Nseq=%d, Len=%d ", PROGRAM, VERSION,URL, retrieve_mode (),(float)(B->cpu+get_time())/1000, B->score_aln, B->nseq, B->len_aln);
+ if (B->ibit>0)
+ {
+ float ibit=(float)log ((double)B->ibit)/log ((double)2);
+ float nibit=(float)log(ibit/(B->len_aln*B->nseq));
+ fprintf ( fp, "\nTies: %.1f bits (%d alternative)\n",ibit, B->ibit-1);
+
+ }
+ }
+ fprintf (fp, "\n\n");
+
+
+ if ( B->len_aln==0)
+ {
+ for (b=0; b<=B->nseq; b++)
+ fprintf (fp,"%-*s -\n",max_len, B->name[b]);
+ }
+
+ else
+ {
+ for (a=0; a<B->len_aln; a+=line)
+ {for (b=0; b<=B->nseq; b++)
+ {
+ if (b!=B->nseq)
+ {
+ fprintf (fp,"%-*s",max_len, B->name[b]);
+ for (c=a;c<a+line && c<B->len_aln;c++)
+ {
+ if ( is_gap(B->seq_al[b][c]))fprintf (fp,"%c", '-');
+ else
+ {
+ n_residues[b]++;
+ fprintf (fp, "%c", GET_CASE(B->residue_case, B->seq_al[b][c]));
+
+ }
+
+ }
+ if (B->output_res_num)fprintf (fp, " %d", n_residues[b]);
+ fprintf (fp,"\n");
+ }
+ else if ( b==B->nseq)
+ {
+ fprintf (fp,"%-*s",max_len," ");
+ for (c=a;c<a+line && c<B->len_aln;c++)
+ {
+ fprintf ( fp, "%c", analyse_aln_column (B, c));
+ }
+ fprintf (fp,"\n");
+ }
+ }
+ fprintf (fp,"\n");
+ }
+ }
+ fprintf (fp,"\n\n");
+ vfree (n_residues);
+ vfclose ( fp);
+ }
+FILE * output_generic_interleaved_aln (FILE *fp, Alignment *B, int line, char gap, char *mode)
+ {
+ int a, b, c;
+ int max_len=0;
+ int *n_residues;
+
+
+ n_residues=vcalloc ( B->nseq+1, sizeof (int));
+ for ( a=0; a< B->nseq; a++)
+ {if ( strlen (B->name[a])>max_len)
+ max_len= strlen ( (B->name[a]));
+ n_residues[a]=B->order[a][1];
+ }
+ max_len=MAX(max_len+2, 16);
+
+
+
+
+ if ( B->len_aln==0)
+ {
+ for (b=0; b<=B->nseq; b++)
+ fprintf (fp,"%-*s -\n",max_len, B->name[b]);
+ }
+
+ else
+ {
+ for (a=0; a<B->len_aln; a+=line)
+ {for (b=0; b<=B->nseq; b++)
+ {
+ if (b!=B->nseq)
+ {
+ fprintf (fp,"%-*s",max_len, B->name[b]);
+ for (c=a;c<a+line && c<B->len_aln;c++)
+ {
+ if ( is_gap(B->seq_al[b][c]))fprintf (fp,"%c", gap);
+ else
+ {
+ n_residues[b]++;
+ fprintf (fp, "%c", GET_CASE(B->residue_case, B->seq_al[b][c]));
+
+ }
+
+ }
+ if (B->output_res_num)fprintf (fp, " %d", n_residues[b]);
+ fprintf (fp,"\n");
+ }
+ }
+ fprintf (fp,"\n");
+ }
+ }
+ vfree (n_residues);
+ return fp;
+ }
+void output_phylip_aln ( char *name, Alignment *B)
+ {
+ int a, b, c, d;
+ FILE *fp;
+
+ int *print_name;
+ static int line=0;
+ line=get_msa_line_length(0, 0);
+
+ print_name=vcalloc ( B->nseq, sizeof (int));
+ fp= vfopen ( name, "w");
+
+ fprintf (fp, "%3d %d\n", B->nseq, B->len_aln);
+ for (a=0; a<B->len_aln; a+=line)
+ {for (b=0; b<B->nseq; b++)
+ {if ( print_name[b]==0)
+ {
+
+ fprintf (fp,"%-10.10s ",B->name[b]);
+ print_name[b]=1;
+ }
+ else
+ {
+ fprintf (fp, "%10.10s ", " ");
+ }
+
+
+ for (d=0,c=a;c<a+line && c<B->len_aln;c++, d++)
+ {
+ if ( d==10)
+ {
+ fprintf ( fp, " ");
+ d=0;
+ }
+ if ( is_gap(B->seq_al[b][c])&& B->seq_al[b][c]!='-' )fprintf (fp,"%c", '-');
+ else fprintf (fp,"%c",(B->seq_al[b][c]) );
+ }
+ fprintf (fp,"\n");
+ }
+ fprintf (fp,"\n");
+ }
+ fprintf (fp,"\n\n");
+ vfclose ( fp);
+ }
+
+void output_rnalign (char *out_file, Alignment *A, Sequence *STRUC)
+ {
+ int a, b;
+ FILE *fp;
+ char bank_file[100];
+ char pep_file[100];
+ char *buf;
+
+ sprintf ( bank_file, "%s.mss", out_file);
+ sprintf ( pep_file, "%s.one_rna", out_file);
+
+
+ buf=vcalloc ( strlen ( A->seq_al[0]+1), sizeof (char));
+
+ for ( b=0,a=0; a< strlen(A->seq_al[0]); a++)
+ {
+ if ( is_gap(A->seq_al[0][a]))
+ buf[a]='.';
+ else
+ buf[a]=STRUC->seq[0][b++];
+ }
+ buf[a]='\0';
+
+ fp=vfopen ( bank_file, "w");
+
+ fprintf ( fp, "ST\n");
+ fp=output_string_wrap ( 50, buf, fp);
+ fprintf ( fp, "\n\n");
+
+ for ( a=0; a<A->nseq-1; a++)
+ {
+ fprintf ( fp, "AS %s\n ", A->name[a]);
+ fp=output_string_wrap ( 50, A->seq_al[a], fp);
+ fprintf ( fp, "\n\n");
+ }
+ vfclose ( fp);
+ fp=vfopen ( pep_file, "w");
+ fprintf ( fp, ">%s\n", A->name[A->nseq-1]);
+ fp=output_string_wrap ( 50, A->seq_al[A->nseq-1], fp);
+ fprintf ( fp, "\n");
+ vfclose (fp);
+ }
+
+void output_lib (char *pw_lib_saga_aln_name, Alignment *A )
+ {
+ Alignment *B;
+ char fname[VERY_LONG_STRING];
+ int a,b;
+
+ B=declare_Alignment (NULL);
+
+ B->nseq=2;
+
+ for ( a=0; a< A->nseq-1; a++)
+ {
+ for ( b=a+1; b<A->nseq; b++)
+ {
+ sprintf ( B->seq_al[0], "%s", A->seq_al[a]);
+ sprintf ( B->name[0], "%s", A->name[a]);
+ sprintf(B->name[1], "%s", A->name[b]);
+ sprintf ( B->seq_al[1], "%s",A->seq_al[b]);
+ B->nseq=2;
+ sprintf ( fname, "%s_%s_%s.lib",pw_lib_saga_aln_name, A->name[a], A->name[b]);
+
+ B->len_aln=strlen ( B->seq_al[0]);
+ ungap_aln (B);
+ output_clustal_aln (fname,B);
+ }
+ }
+ }
+void output_pw_lib_saga_aln (char *pw_lib_saga_aln_name, Alignment *A )
+ {
+ Alignment *B;
+ char fname[VERY_LONG_STRING];
+ int a,b;
+
+ B=declare_Alignment (NULL);
+
+ B->nseq=2;
+
+ for ( a=0; a< A->nseq-1; a++)
+ {
+ for ( b=a+1; b<A->nseq; b++)
+ {
+ sprintf ( B->seq_al[0], "%s", A->seq_al[a]);
+ sprintf ( B->name[0], "%s", A->name[a]);
+ sprintf(B->name[1], "%s", A->name[b]);
+ sprintf ( B->seq_al[1], "%s",A->seq_al[b]);
+ B->nseq=2;
+ sprintf ( fname, "%s_%s_%s.pw_lib_saga_aln",pw_lib_saga_aln_name, A->name[a], A->name[b]);
+
+ B->len_aln=strlen ( B->seq_al[0]);
+ ungap_aln (B);
+ output_clustal_aln (fname,B);
+ }
+ }
+ }
+void output_lalign_header( char *name, Alignment *A)
+ {
+ FILE *fp;
+
+ fp=vfopen ( name, "w");
+ fprintf ( fp, " Lalign mode: best local alignments between two sequences\n");
+ fprintf ( fp, " %s(%s) [%s]\n\n", VERSION, DATE, URL);
+ fprintf ( fp, " Comparison of:\n(A) %s\t%s\t-%d aa\n", (A->S)->file[A->order[0][0]],(A->S)->name[A->order[0][0]], (A->S)->len[A->order[0][0]]);
+ fprintf ( fp, "(B) %s\t%s\t-%d aa\n", (A->S)->file[A->order[1][0]],(A->S)->name[A->order[1][0]], (A->S)->len[A->order[1][0]]);
+
+
+ vfclose ( fp);
+ return;
+ }
+void output_stockholm_aln (char *file, Alignment *A, Alignment *ST)
+{
+ FILE *fp;
+ int a,b;
+
+ for (a=0; a<A->nseq; a++)
+ for (b=0; b<A->len_aln; b++)
+ if (A->seq_al[a][b]==STOCKHOLM_CHAR)A->seq_al[a][b]='.';
+
+ fp=vfopen (file, "w");
+ fprintf ( fp, "# STOCKHOLM 1.0\n\n");
+ output_generic_interleaved_aln (fp,A, 50, '.', NULL);
+ fprintf ( fp, "//\n");
+ vfclose (fp);
+}
+
+void output_glalign ( char *name, Alignment *B, Alignment *S)
+{
+ int a, b, g, s;
+ int naln=0;
+ FILE *fp;
+ int **nr;
+ B=B->A;
+ if ( B==NULL){return;}
+
+ fp=vfopen (name, "w");
+ fprintf (fp, "Format: GLALIGN_01 [Generated with %s ]\n", PROGRAM);
+ fprintf (fp, "#Each Line corresponds to a column\n");
+ fprintf (fp, "#First column coresponds to first genome\n");
+ fprintf (fp, "#Last Column gives the column reliability on a 0-9 scale\n");
+ fprintf (fp, "#[-1] Indicates that the reliability was not evaluated\n");
+
+ fprintf (fp, "Genome List\n");
+ for ( a=0; a< B->nseq; a++)
+ fprintf (fp, "\tGenome %s\n", B->name[a]);
+ fprintf (fp, "Alignment List\n");
+ while (B)
+ {
+ fprintf (fp, "Alignment %d Len %d Score %d\n", ++naln, B->len_aln, S->score_aln);
+ nr=duplicate_int (B->order, -1, -1);
+ for ( a=0; a< B->len_aln; a++)
+ {
+ fprintf ( fp, "\t");
+ for ( b=0; b< B->nseq; b++)
+ {
+ g=is_gap (B->seq_al[b][a]);
+ nr[b][1]+=1-g;
+
+ if (g)fprintf (fp, "---- ");
+ else fprintf ( fp, "%4d ",nr[b][1]);
+ }
+ s=((S)?S->seq_al[S->nseq][a]:-1);
+ if (s==NO_COLOR_RESIDUE)s=-1;
+ fprintf ( fp,"[ %d ]",s);
+ fprintf ( fp, "\n");
+
+ }
+ free_int (nr, -1);
+ B=B->A;
+ S=S->A;
+ }
+ vfclose ( fp);
+}
+Alignment *input_conc_aln ( char *name, Alignment *IN)
+{
+ FILE *fp;
+ char *string, *p, *file;
+ Alignment *F=NULL,*A=NULL, *B=NULL;
+
+ file=vtmpnam (NULL);
+
+ string=file2string(name);
+ string=substitute ( string, "@", "!Protected!");
+ string=substitute ( string, TC_REC_SEPARATOR, "@");
+ strtok (string,"@");
+
+
+ while ( (p=strtok (NULL,"@"))!=NULL)
+ {
+ char *buf;
+ buf=vcalloc ( strlen (p)+1, sizeof (char));
+ sprintf (buf,"%s", p);
+ buf=substitute (buf,"!protected!", "@");
+
+ fp=vfopen (file, "w");
+ fprintf ( fp, "%s",buf);
+ vfclose (fp);
+ vfree (buf);
+
+ if ( is_aln (file))
+ {
+ B=main_read_aln (file,NULL);
+
+ if ( !A)
+ {
+ if (IN){copy_aln (B, IN);F=A=IN;}
+ else F=A=B;
+ }
+ else
+ {
+ A->A=B;
+ A=A->A;
+ }
+ }
+ }
+
+ vfree (string);
+ return F;
+}
+
+void output_conc_aln ( char *name, Alignment *B)
+{
+ FILE *fp;
+ int a;
+
+ fp=vfopen (name, "w");
+ fprintf (fp, "# CONC_MSF_FORMAT_01\n");
+ while (B)
+ {
+ fprintf (fp, "%s\n", TC_REC_SEPARATOR);
+ for ( a=0; a< B->nseq; a++)
+ {
+ fprintf ( fp, ">%s\n%s\n", B->name[a], B->seq_al[a]);
+ }
+ B=B->A;
+
+ }
+ vfclose (fp);
+}
+
+void output_lalign ( char *name, Alignment *B)
+{
+ static int output_header;
+
+ B=B->A;
+ if ( B==NULL){output_header=0;return;}
+ else if ( output_header==0)
+ {
+ output_lalign_header(name, B);
+ output_header=1;
+ }
+ while (B)
+ {
+ output_lalign_aln ( name, B);
+ B=B->A;
+ }
+}
+void output_lalign_aln ( char *name, Alignment *B)
+ {
+ int a, b, c,d=0, s=0;
+ char col;
+
+ float tot=0;
+ float id=0;
+
+ FILE *fp;
+ int max_len=0;
+ int line;
+ int *n_residues;
+ int res;
+
+
+ n_residues=vcalloc ( B->nseq+1, sizeof (int));
+ for ( a=0; a< B->nseq; a++)
+ {if ( strlen (B->name[a])>max_len)
+ max_len= strlen ( (B->name[a]));
+ n_residues[a]=B->order[a][1];
+ }
+ max_len=MAX(max_len+2, 16);
+ line=60;
+
+
+
+ fp= vfopen ( name, "a");
+
+ for (a=0; a< B->len_aln; a++)
+ {
+ if ( !is_gap(B->seq_al[0][a]) && !is_gap(B->seq_al[1][a]))
+ {
+ tot++;
+ id+=(B->seq_al[0][a]==B->seq_al[1][a]);
+ }
+ }
+
+ id=(id*100)/tot;
+ fprintf (fp, " %.1f%% identity in %d aa overlap; score: %d\n\n", id,(int)tot, B->score_aln);
+
+
+ for (a=0; a<B->len_aln; a+=line)
+ {for (b=0; b<5; b++)
+ {
+ if ( b==0 || b==4)
+ {
+ if ( b==0)s=0;
+ if ( b==4)s=1;
+ fprintf (fp,"%-*s",max_len," ");
+ for (d=0,c=a;c<a+line && c<B->len_aln;c++)
+ {
+ res=!is_gap ( B->seq_al[s][c]);
+ n_residues[s]+=res;
+ if ( (n_residues[s]%10)==0 && res && (c-a+4)<line){fprintf (fp, "%-4d", n_residues[s]);d=-3;}
+ else
+ {
+ if ( d==0)fprintf (fp, " ");
+ else d++;
+ }
+ }
+ fprintf (fp,"\n");
+ }
+ else if (b==1 || b==3)
+ {
+ if ( b==1)s=0;
+ if ( b==3)s=1;
+ fprintf (fp,"%-*s",max_len, B->name[s]);
+ for (c=a;c<a+line && c<B->len_aln;c++)
+ {
+ if ( is_gap(B->seq_al[s][c]))fprintf (fp,"%c", '-');
+ else
+ {
+ fprintf (fp, "%c", GET_CASE(B->residue_case, B->seq_al[s][c]));
+ }
+ }
+ fprintf (fp,"\n");
+ }
+ else if ( b==2)
+ {
+ fprintf (fp,"%-*s",max_len," ");
+ for (c=a;c<a+line && c<B->len_aln;c++)
+ {
+ col=analyse_aln_column (B, c);
+ if ( col=='*')col=':';
+ else if ( col==':')col='.';
+ else if ( col=='.')col=' ';
+ fprintf ( fp, "%c", col);
+ }
+ fprintf (fp,"\n");
+ }
+ }
+ fprintf (fp,"\n");
+ }
+
+ fprintf (fp,"\n\n----------\n\n");
+ vfree (n_residues);
+ vfclose ( fp);
+ }
+
+
+/****************************************************************************************************/
+/*************************************UTIL *********************************************************/
+/**************************************************************************************************/
+
+
+/****************************************************************************************************/
+/*************************** *************************************/
+/*************************** PROCESSING *************************************/
+/*************************** *************************************/
+/*******************************************************************************************/
+/* */
+/* */
+/* THREADING */
+/***************************************************************************************** */
+
+char *thread_aa_seq_on_dna_seq( char *s)
+ {
+ int l, b, c;
+ char *array;
+
+
+ l=strlen ( s);
+ array=vcalloc ( l*3 +1, sizeof (char));
+ for ( b=0, c=0; b< l; b++, c+=3)
+ {
+ array[c]=s[b];
+ array[c+1]='o';
+ array[c+2]='o';
+ }
+ array[c]='\0';
+ return array;
+ }
+
+Alignment *thread_dnaseq_on_prot_aln (Sequence *S, Alignment *A)
+ {
+ Alignment *B=NULL;
+ int a, b, c, n, la, ls, ln, m;
+
+ B=copy_aln ( A, B);
+ B=realloc_aln2 ( B, B->nseq, B->len_aln*3 +1);
+
+ for ( n=0,a=0; a< A->nseq; a++)
+ {
+ for ( m=0,b=0; b< S->nseq; b++)
+ {
+ if (strm (A->name[a], S->name[b]) )
+ {
+ m=1;
+ n++;
+ ungap ( S->seq[b]);
+ B->seq_al[a][0]='\0';
+ for (la=0, ls=0, ln=0; la< A->len_aln; la++)
+ {
+ for (c=0; c< 3; c++)
+ B->seq_al[a][ls++]=(is_gap(A->seq_al[a][la]))?'-':S->seq[b][ln++];
+ }
+ B->seq_al[a][ls]='\0';
+ }
+ }
+ if ( m==0)
+ {
+ for (la=0, ls=0, ln=0; la< A->len_aln; la++)
+ {
+
+ B->seq_al[a][ls++]=A->seq_al[a][la];
+ B->seq_al[a][ls++]='-';
+ B->seq_al[a][ls++]='-';
+ }
+ }
+ }
+
+ B->len_aln=strlen ( B->seq_al[0]);
+ return B;
+ }
+void thread_seq_struc2aln ( Alignment *A, Sequence *ST)
+ {
+ int a, b, c,d;
+ int len, cons;
+
+ for ( a=0; a< A->nseq; a++)
+ for ( b=0; b< ST->nseq; b++)
+ {
+ if ( strcmp ( A->name[a], ST->name[b])==0)
+ {
+ ungap (ST->seq[b]);
+ len=strlen(A->seq_al[a]);
+ for ( c=0, d=0; c<len; c++)
+ {
+ if ( !is_gap(A->seq_al[a][c]))A->seq_al[a][c]=ST->seq[b][d++];
+ }
+ }
+ }
+ cons=name_is_in_list ("Cons", ST->name, ST->nseq, 100);
+ if ( cons!=-1 && A->len_aln==strlen ( ST->seq[cons]))
+ {
+ sprintf (A->name[A->nseq], "Cons");
+ sprintf (A->seq_al[A->nseq],"%s", ST->seq[cons]);
+ A->nseq++;
+ }
+ }
+void cache_id ( Alignment *A)
+ {
+ int a, b,n;
+ char r1, r2, r3;
+
+ for ( a=0; a< A->len_aln; a++)
+ {
+ for ( b=0, n=0; b< A->nseq; b++)if ( !is_gap(A->seq_al[b][a]))n++;
+ for ( b=0; b< A->nseq; b++)
+ if ( !is_gap(A->seq_al[b][a]) && n==A->nseq)A->seq_al[b][a]='h';
+ else if( !is_gap(A->seq_al[b][a]))A->seq_al[b][a]='x';
+ }
+ for ( a=0; a< A->nseq; a++)
+ {
+ for ( b=1; b< A->len_aln-1; b++)
+ {
+ r1=A->seq_al[a][b-1];
+ r2=A->seq_al[a][b];
+ r3=A->seq_al[a][b+1];
+ if (r2=='h')
+ {
+ if ( (r1=='h' || r1=='b') && (r3=='h' || r3=='b'))A->seq_al[a][b]='h';
+ else A->seq_al[a][b]='b';
+ }
+ }
+ for ( b=1; b< A->len_aln-1; b++)if ( A->seq_al[a][b]=='b')A->seq_al[a][b]='x';
+ }
+
+ }
+
+
+/*******************************************************************************************/
+/* */
+/* */
+/* PROCESING OF EST */
+/* */
+/***************************************************************************************** */
+int process_est_sequence ( Sequence *S, int *cluster_list)
+ {
+ char **inverted_seq;
+ int T=20;
+ int a, b;
+ int V1, V2;
+ int **sens;
+ int **a_sens;
+ int **best;
+ int *solution;
+ char buf [VERY_LONG_STRING];
+ int n_clusters=0;
+ int n;
+
+ sens=declare_int ( S->nseq,S->nseq);
+ a_sens=declare_int ( S->nseq,S->nseq);
+ best=declare_int ( S->nseq,S->nseq);
+
+
+ inverted_seq=vcalloc ( S->nseq, sizeof (char*));
+ for ( a=0; a<S->nseq; a++)
+ inverted_seq[a]=invert_seq ( S->seq[a]);
+
+ for ( a=0; a< S->nseq-1; a++)
+ {
+
+ for ( b=a+1; b<S->nseq; b++)
+ {
+
+ V1=sens[a][b]=sens[b][a]=get_best_match ( S->seq[a], S->seq[b]);
+ V2=a_sens[a][b]=a_sens[b][a]=get_best_match ( S->seq[a],inverted_seq[b]);
+ best[a][b]=best[b][a]=(V1>V2)?V1:V2;
+ }
+ }
+ solution=SHC ( S->nseq, a_sens, sens);
+
+
+ for ( a=0; a<S->nseq; a++)cluster_list[a]=-1;
+ for ( a=0; a<S->nseq; a++)
+ {
+ n=search_for_cluster (a, n_clusters, cluster_list, T, S->nseq, best);
+ if ( n>0)n_clusters++;
+ }
+ fprintf ( stderr, "\nTHERE %s %d Independant Cluster(s) in your sequences",(n_clusters>1)?"are":"is",(n_clusters));
+ for (a=0; a<n_clusters; a++)
+ {
+ fprintf (stderr, "\n");
+ for ( b=0; b<S->nseq; b++)
+ {
+ if ( cluster_list[b]==a)fprintf ( stderr, "%s ", S->name[b]);
+ }
+ }
+
+ for ( a=0; a<S->nseq; a++)
+ {
+ if ( solution[a]==-1)
+ {
+ S->seq[a]=inverted_seq[a];
+ sprintf ( buf, "i_%s", S->name[a]);
+ sprintf ( S->name[a], "%s", buf);
+ }
+ }
+ return n_clusters;
+ }
+
+int search_for_cluster ( int seq, int cluster_number, int *cluster_list, int T, int nseq, int **S)
+ {
+ int n=0,a;
+
+ if (cluster_list[seq]==-1)
+ {
+ cluster_list[seq]=cluster_number;
+ n++;
+ }
+ for ( a=0; a<nseq; a++)
+ if ( cluster_list[a]==-1)
+ {
+
+ if (S[seq][a]>T)
+ {
+ n++;
+ cluster_list[a]=cluster_number;
+ n+=search_for_cluster ( a, cluster_number, cluster_list, T, nseq, S);
+ }
+ }
+ return n;
+ }
+
+int * SHC ( int nseq, int **NST, int **ST)
+ {
+ int a;
+ int mut;
+ int score, new_score;
+ int N_IT=VERY_LONG_STRING;
+ int *sol;
+ int count;
+
+ sol=vcalloc ( nseq, sizeof (int));
+ for ( a=0; a<nseq; a++)
+ sol[a]=(addrand ((unsigned long)100)>49)?1:-1;
+
+ score=evaluate_sol (sol, nseq, ST, NST);
+ fprintf ( stderr, "\nI_Score=%d\n", score);
+ N_IT=N_IT*nseq;
+
+ for ( count=0,a=0; a< N_IT && score<VERY_LONG_STRING; a++, count++)
+ {
+ mut=mutate_sol ( sol,nseq);
+ new_score=evaluate_sol (sol, nseq, ST, NST);
+ if ( new_score>score)
+ {
+ score=new_score;
+ }
+ else if ( (addrand ((unsigned long)VERY_LONG_STRING))>score)
+ {
+ score=new_score;
+ }
+ else
+ sol[mut]=sol[mut]*-1;
+ if ( count==VERY_LONG_STRING)
+ {
+ count=0;
+ fprintf ( stderr, "\nScore=%d", score);
+ }
+ }
+ fprintf ( stderr, "\nScore=%d\n", score);
+ return sol;
+ }
+
+int mutate_sol (int *sol, int nseq)
+ {
+ int n;
+ n=addrand ((unsigned long)nseq);
+ sol[n]=sol[n]*-1;
+ return n;
+ }
+int evaluate_sol ( int *sol, int nseq, int **ST, int **NST)
+ {
+ static int max_score;
+ int a, b, score=0;
+
+ if ( max_score==0)
+ {
+ for ( a=0; a<nseq-1; a++)
+ for ( b=a+1; b<nseq; b++)
+ {
+ max_score+=(ST[a][b]>NST[a][b])?ST[a][b]:NST[a][b];
+ }
+ }
+
+ for ( a=0; a<nseq-1; a++)
+ for (b=a+1; b<nseq; b++)
+ if ( (sol[a]*sol[b])<0)score+=NST[a][b];
+ else score+=ST[a][b];
+ return (score*VERY_LONG_STRING)/max_score;
+ }
+
+
+char * invert_seq ( char *seq)
+ {
+ int a, b;
+
+ char *nseq;
+ int l;
+
+
+ l=strlen ( seq);
+ for ( a=0; a<l; a++)
+ seq[a]=tolower ( seq[a]);
+ nseq=vcalloc ( l+1, sizeof (char));
+
+ for ( a=0, b=l-1; a<l; a++, b--)
+ {
+ if (seq[b]=='n')nseq[a]='n';
+ else if (seq[b]=='g')nseq[a]='c';
+ else if (seq[b]=='c')nseq[a]='g';
+ else if (seq[b]=='a')nseq[a]='t';
+ else if (seq[b]=='t')nseq[a]='a';
+ }
+
+ nseq[l]='\0';
+ return nseq;
+ }
+
+
+int get_best_match ( char *seq1, char *seq2)
+ {
+ static int **m;
+ static int ml;
+ int a, b;
+ int **mdiag;
+ int n_mdiag=0;
+ int best;
+ int l1, l2;
+
+
+ l1=strlen ( seq1);
+ l2=strlen (seq2);
+ if ( m==NULL)
+ {
+ ml=(l1>l2)?l1:l2;
+ m=declare_int (ml, ml);
+ }
+ else if ( (ml<l1) || (ml<l2))
+ {
+ free_int (m, ml);
+ ml=(l1>l2)?l1:l2;
+ m=declare_int (ml, ml);
+ }
+
+ for ( a=0; a<l1; a++)
+ {
+ for ( b=0; b<l2; b++)
+ m[a][b]=((seq1[a]==seq2[b])|| seq1[a]=='n' ||seq2[b]=='n')?1:0;
+ }
+ mdiag= extract_m_diag_streches ( m, l1, l2,seq1, seq2, &n_mdiag);
+
+ for ( best=0,a=0; a<n_mdiag; a++)
+ best=(mdiag[a][0]>best)?mdiag[a][0]:best;
+
+ return best;
+ }
+
+int** extract_m_diag_streches ( int ** m, int l1, int l2,char *seq1, char *seq2, int *n_mdiag)
+ {
+
+ int b, x, y, s1, s2;
+ static int **mdiag;
+ int in;
+ static int max_diag=VERY_LONG_STRING;
+
+ /*
+ diag[0]=len;
+ diag[1]=x_start;
+ diag[2]=y_start;
+ diag[3]=x_end;
+ diag[4]=y_end;
+ */
+
+ if ( mdiag==NULL)
+ mdiag=declare_int ( max_diag, 5);
+
+ for ( s1=l1-1, s2=0;s2<l2;)
+ {
+ for ( in=0,x=s1, y=s2; x<l1 && y<l2; x++, y++)
+ {
+ if (m[x][y]>0)
+ {
+ if (in==1)
+ mdiag[n_mdiag[0]][0]++;
+ else
+ {
+ mdiag[n_mdiag[0]][0]=1;
+ mdiag[n_mdiag[0]][1]=x;
+ mdiag[n_mdiag[0]][2]=y;
+ in=1;
+ }
+ }
+ else
+ if (in==1)
+ {
+ in=0;
+ mdiag[n_mdiag[0]][3]=x-1;
+ mdiag[n_mdiag[0]][4]=y-1;
+ if ( !is_strech ( "ta", seq1, seq2,mdiag[n_mdiag[0]][0], mdiag[n_mdiag[0]][1],mdiag[n_mdiag[0]][2]))n_mdiag[0]++;
+ }
+ if (n_mdiag[0]==(max_diag-1))
+ {mdiag=vrealloc (mdiag, (max_diag+VERY_LONG_STRING)*sizeof (int*));
+ for ( b=max_diag; b<max_diag+VERY_LONG_STRING; b++)mdiag[b]=vcalloc ( 5, sizeof (int));
+ max_diag+=VERY_LONG_STRING;
+ }
+ }
+ s2+= (s1==0)?1:0;
+ s1-= (s1==0)?0:1;
+ if (in==1)
+ {
+ in=0;
+ mdiag[n_mdiag[0]][3]=x-1;
+ mdiag[n_mdiag[0]][4]=y-1;
+ if ( !is_strech ( "ta", seq1, seq2,mdiag[n_mdiag[0]][0], mdiag[n_mdiag[0]][1],mdiag[n_mdiag[0]][2]))n_mdiag[0]++;
+ }
+ }
+
+ return mdiag;
+ }
+int is_strech ( char *AA, char *seq1, char *seq2, int len, int x, int y)
+ {
+ int n, i, j, c,a,nr;
+ int T=70;
+
+ n=strlen ( AA);
+ for ( a=0; a<n; a++)
+ {
+ for (nr=0, i=x, j=y, c=0; c<len; c++, i++, j++)
+ if ((seq1[i]==AA[a]) && (seq2[j]==AA[a]))nr++;
+ if ( ((nr*100)/len)>T)return 1;
+ }
+ return 0;
+ }
+
+
+/************************************************************************************/
+/* */
+/* STRUC */
+/* */
+/* */
+/************************************************************************************/
+
+char * oneletaa2threeletaa(char aa);
+float aa2property (char aa, char *mode);
+
+int output_seq2struc(char *outfile, Alignment *A)
+{
+ FILE *fp1, *fp2;
+ int a,c, l;
+ float v, h, x, y, z, dx, dy, dz;
+ char *s;
+ char *tmpfile1, *tmpfile2;
+ char command[1000];
+
+ tmpfile1=vtmpnam(NULL);
+ tmpfile2=vtmpnam(NULL);
+
+ ungap (A->seq_al[0]);
+ s=A->seq_al[0];l=strlen (s);
+ fp1=vfopen (tmpfile1, "w");
+
+ x=y=z=0;
+ for ( a=0; a< l; a++)
+ {
+ h=aa2property ( s[a], "doolittle" );
+ v=aa2property (s[a], "volume");
+ /*14.398907: peptide bond length*/
+ dx=(float)sqrt ((double)(14.398907/(((h*h)/(v*v))+1)));
+ dy=dx*(h/v);
+ dz=0;
+
+
+ x+=dx;
+ y+=dy;
+ z+=dz;
+ fprintf (fp1, "ATOM%7d CA %s A%4d%12.3f%8.3f%8.3f 1.00 5.30\n",a+1, oneletaa2threeletaa(s[a]),a+1, x, y, z);
+ }
+ vfclose (fp1);
+ sprintf ( command, "extract_from_pdb -infile %s -force > %s", tmpfile1, tmpfile2);
+ my_system (command);
+ fp1=vfopen (tmpfile2, "r");
+ fp2=vfopen (outfile, "w");
+
+ while ( (c=fgetc(fp1))!=EOF)fprintf (fp2, "%c", c);
+ vfclose (fp1);
+ vfclose (fp2);
+
+ return 0;
+}
+
+char * oneletaa2threeletaa(char aa)
+ {
+ aa=tolower (aa);
+ if ( aa=='a')return "ALA";
+ else if ( aa=='r') return "ARG";
+ else if ( aa=='n') return "ASN";
+ else if ( aa=='d') return "ASP";
+ else if ( aa=='c') return "CYS";
+ else if ( aa=='q') return "GLN";
+ else if ( aa=='e') return "GLU";
+ else if ( aa=='g') return "GLY";
+ else if ( aa=='h') return "HIS";
+ else if ( aa=='i') return "ILE";
+ else if ( aa=='l') return "LEU";
+ else if ( aa=='k') return "LYS";
+ else if ( aa=='m') return "MET";
+ else if ( aa=='f') return "PHE";
+ else if ( aa=='p') return "PRO";
+ else if ( aa=='s') return "SER";
+ else if ( aa=='t') return "THR";
+ else if ( aa=='w') return "TRP";
+ else if ( aa=='y') return "TYR";
+ else if ( aa=='v') return "VAL";
+ else
+ {
+ fprintf ( stderr, "\nERROR: %c is not an amino acid [FATAL::aa2hydropathy::%s]", aa, PROGRAM);
+ myexit (EXIT_FAILURE);
+ return NULL;
+ }
+ return NULL;
+ }
+
+float aa2property (char aa, char *mode)
+ {
+ if ( mode==NULL || strm (mode, "doolittle"))
+ {
+ aa=tolower (aa);
+ if ( aa=='i')return 4.5;
+ else if ( aa=='v') return 4.2;
+ else if ( aa=='l') return 3.8;
+ else if ( aa=='f') return 2.8;
+ else if ( aa=='c') return 2.5;
+ else if ( aa=='m') return 1.9;
+ else if ( aa=='a') return 1.8;
+ else if ( aa=='g') return -0.4;
+ else if ( aa=='t') return -0.7;
+ else if ( aa=='w') return -0.9;
+ else if ( aa=='s') return -0.8;
+ else if ( aa=='y') return -1.3;
+ else if ( aa=='p') return -1.6;
+ else if ( aa=='h') return -3.2;
+ else if ( aa=='e') return -3.5;
+ else if ( aa=='q') return -3.5;
+ else if ( aa=='d') return -3.5;
+ else if ( aa=='n') return -3.5;
+ else if ( aa=='k') return -3.9;
+ else if ( aa=='r') return -4.5;
+ else
+ {
+ fprintf ( stderr, "\nERROR: %c is not an amino acid [FATAL::aa2hydropathy::%s]", aa, PROGRAM);
+ myexit (EXIT_FAILURE);
+ }
+ }
+ else if (strm (mode, "volume"))
+ {
+ aa=tolower (aa);
+ if ( aa=='a')return 0.915;
+ else if ( aa=='r') return 2.02;
+ else if ( aa=='n') return 1.35;
+ else if ( aa=='d') return 1.24;
+ else if ( aa=='c') return 1.18;
+ else if ( aa=='q') return 1.61;
+ else if ( aa=='e') return 1.55;
+ else if ( aa=='g') return 0.66;
+ else if ( aa=='h') return 1.67;
+ else if ( aa=='i') return 1.69;
+ else if ( aa=='l') return 1.68;
+ else if ( aa=='k') return 1.71;
+ else if ( aa=='m') return 1.70;
+ else if ( aa=='f') return 2.03;
+ else if ( aa=='p') return 1.29;
+ else if ( aa=='s') return 0.99;
+ else if ( aa=='t') return 1.22;
+ else if ( aa=='w') return 2.37;
+ else if ( aa=='y') return 2.03;
+ else if ( aa=='v') return 1.41;
+ else
+ {
+ fprintf ( stderr, "\nERROR: %c is not an amino acid [FATAL::aa2hydropathy::%s]", aa, PROGRAM);
+ myexit (EXIT_FAILURE);
+ }
+ }
+
+ else
+ {
+ fprintf ( stderr, "\nERROR: %s is an unknown mode [FATAL::aa2hydropathy::%s]", mode , PROGRAM);
+ myexit (EXIT_FAILURE);
+ }
+ return 0;
+ }
+
+
+
+
+
+/************************************************************************************/
+/* */
+/* DNA */
+/* */
+/* */
+/************************************************************************************/
+
+Alignment *code_dna_aln (Alignment *A)
+ {
+ int a, b,l,r;
+
+ for ( a=0; a< A->nseq; a++)
+ {
+ for (l=0, b=0; b< A->len_aln; b++)
+ {
+ r=A->seq_al[a][b];
+ if ( r=='-')l++;
+ else if ( r=='~')continue;
+ else if ( r=='.')l++;
+ else if ( !islower(r))A->seq_al[a][b]='4';
+ else
+ {
+ A->seq_al[a][b]=(l+3)%3+'0';
+ l++;
+ }
+ }
+ }
+ return A;
+ }
+
+
+Alignment *back_translate_dna_aln (Alignment *A)
+ {
+ /*Given a set of aligned sequences
+ starts from left to right
+ 1 aa->3 nuc
+ ambiguities are randomly resolved.
+ returns the corresponding amino acid alignment
+ */
+ int a;
+ char *seq ;
+
+ ungap_aln(A);
+ A=realloc_aln (A, 10000);
+ seq=vcalloc ( 10000, sizeof (char));
+
+
+ for ( a=0; a< A->nseq; a++)
+ {
+ seq=back_translate_dna_seq (A->seq_al[a], seq, RANDOM);
+ sprintf ( A->seq_al[a], "%s", seq);
+ }
+ A->len_aln=A->len_aln*3;
+ compress_aln (A);
+ vfree (seq);
+ return A;
+ }
+char * back_translate_dna_seq ( char *in_seq,char *out_seq, int mode)
+ {
+ int a,len;
+
+ len=strlen(in_seq);
+
+ if (out_seq==NULL)out_seq=vcalloc ( len*3+1, sizeof (char));
+
+ out_seq[0]='\0';
+ for (a=0; a<len; a++)
+ {
+ strcat (out_seq, back_translate_dna_codon (in_seq[a],mode));
+ }
+
+ return out_seq;
+ }
+
+static Sequence *rna_seq2dna_seq (Sequence *S);
+static Sequence *dna_seq2rna_seq (Sequence *S);
+Sequence * transform_sequence ( Sequence *S, char *mode)
+{
+ if ( strm (mode, "rna2dna"))
+ return rna_seq2dna_seq (S);
+ else if ( strm (mode, "dna2rna"))
+ return dna_seq2rna_seq (S);
+ else
+ printf_exit (EXIT_FAILURE, stderr, "Unknown -transform mode: %s [FATAL:%s]\n", mode,PROGRAM);
+ return NULL;}
+
+Sequence *rna_seq2dna_seq (Sequence *S)
+{
+ int a, b;
+
+ if ( !strm(S->type, "DNA") && !strm (S->type, "RNA")) printf_exit (EXIT_FAILURE, stderr, "Sequences should be *RNA* type [FATAL:%s]\n", PROGRAM);
+ for ( a=0; a<S->nseq; a++)
+ {
+ for (b=0; b<strlen (S->seq[a]); b++)
+ {
+ if ( S->seq[a][b]=='u') S->seq[a][b]='t';
+ if ( S->seq[a][b]=='U') S->seq[a][b]='T';
+ }
+ HERE ("%s", S->seq[a]);
+ }
+ return S;
+}
+Sequence *dna_seq2rna_seq (Sequence *S)
+{
+ int a, b;
+
+ if ( !strm(S->type, "DNA") && !strm (S->type, "RNA")) printf_exit (EXIT_FAILURE, stderr, "Sequences should be *DNA* type (type=%s) [FATAL:%s]\n", PROGRAM, S->type);
+ for ( a=0; a<S->nseq; a++)
+ for (b=0; b<S->len[a]; b++)
+ {
+ if ( S->seq[a][b]=='t') S->seq[a][b]='u';
+ if ( S->seq[a][b]=='T') S->seq[a][b]='U';
+ }
+ return S;
+}
+
+
+
+int get_longest_frame (char *seq, int mode);
+Sequence *translate_dna_seqS (Sequence *S, int frame, int stop)
+{
+ //frame: 1->3
+ char *s;
+ int a, b,c,l;
+
+ for (a=0; a<S->nseq; a++)
+ {
+ s=S->seq[a];
+ ungap(s);
+ l=strlen (s);
+ for (b=(frame-1); b<l; b+=3)
+ {
+ s[b]=translate_dna_codon (s+b,stop);
+ for (c=b+1; c<b+3 && c<l; c++)s[c]='-';
+ }
+ }
+ return S;
+}
+Alignment *translate_dna_aln (Alignment *A, int frame)
+ {
+ /*Given a set of aligned sequences
+ starts from left to right
+ 3 nuc->1 aa
+ 2nuc+1gap, 1nuc+2gap->3 gaps
+ 1 stop-> 3gaps
+ returns the corresponding amino acid alignment
+ */
+
+
+ int a, b,r;
+
+
+ if (frame==3 || frame ==4)
+ {
+
+ for (a=0; a< A->nseq; a++)
+ {
+ char *d, *buf, f;
+ d=A->seq_al[a];
+ f=get_longest_frame (d,frame);
+ buf=vcalloc ( strlen (d)+1, sizeof (char));
+ if ( f<3)
+ {
+ sprintf (buf, "%s", d+f);
+ sprintf (d, "%s", buf);
+ sprintf (A->seq_comment[a], " frame: %d", f);
+ }
+ else if ( f>=3)
+ {
+ f-=3;
+ sprintf ( buf, "%s", d);
+ buf=complement_string (buf);
+ sprintf (d, "%s",buf+f);
+ sprintf (A->seq_comment[a], " frame: %d Reverse Complement", f);
+ }
+ vfree (buf);
+ }
+ }
+ else
+ {
+
+ for ( a=0; a< A->nseq; a++)
+ for (b=0; b< frame; b++)
+ A->seq_al[a][b]='-';
+ ungap_aln(A);
+ }
+
+ for ( b=0; b< A->nseq; b++)
+ for ( a=0; a< A->len_aln;)
+ {
+
+ r=translate_dna_codon (A->seq_al[b]+a, 'z');
+ if (is_gap(r))
+ {
+ A->seq_al[b][a++]='-';
+ A->seq_al[b][a++]='-';
+ A->seq_al[b][a++]='-';
+ }
+ else if ( r=='x')
+ {
+ A->seq_al[b][a++]='o';
+ A->seq_al[b][a++]='-';
+ A->seq_al[b][a++]='-';
+ }
+ else if ( r=='z')
+ {
+ A->seq_al[b][a++]='x';
+ A->seq_al[b][a++]='-';
+ A->seq_al[b][a++]='-';
+ }
+ else
+ {
+ A->seq_al[b][a++]=r;
+ A->seq_al[b][a++]='-';
+ A->seq_al[b][a++]='-';
+ }
+ }
+ compress_aln (A);
+
+ return A;
+ }
+
+
+int seq2tblastx_db (char *out,Sequence *S, int strand)
+{
+ //strand : same values as in ncbi blastall
+ //1: direct
+ //2:revers
+ //3: both
+ int a, b,d, l;
+ char *prot, *pprot;
+ int min_exon_len=5;
+ FILE *fp;
+ fp=vfopen (out, "w");
+ for (a=0; a<S->nseq; a++)
+ {
+ for (b=-3; b<=3; b++)
+ {
+ int f;
+ int dl;
+
+ dl=strlen (S->seq[a]);
+ if (b==0)continue;
+ else if ( strand==1 && b<0)continue;//only direct strand
+ else if ( strand==2 && b>0)continue;//only reverse strand
+ else if (b<0)
+ {
+ S->seq[a]=complement_string (S->seq[a]);
+ f=b*-1;
+ }
+ else
+ f=b;
+ prot=translate_dna_seq (S->seq[a], f, 'X', NULL);
+ upper_string (prot);
+
+ l=strlen (prot);
+ pprot=prot;
+ for (pprot=prot,d=0; d<=l; d++)
+ {
+ if (prot[d]=='\0')
+ {
+ prot[d]='\0';
+ if ( strlen (pprot)>min_exon_len)
+ {
+ int start, end;
+ end=(d)*3+(f-1);
+ start=(end-(strlen (pprot))*3)+1;
+ fprintf (fp, ">%s__%c__%d__%d__%d\n%s\n", S->name[a],(b>0)?'d':'r',start,end,dl, pprot);
+ pprot=prot+d+1;
+ }
+ }
+ }
+ vfree (prot);
+ if (b<0) S->seq[a]=complement_string (S->seq[a]);
+ }
+ }
+ vfclose (fp);
+ return EXIT_SUCCESS;
+}
+
+int get_longest_frame (char *in_seq, int mode)
+{
+ char *prot, *seq;
+ int a;
+ int max_l=0, l;
+ int best_frame=0;
+ int nf;
+
+ seq=vcalloc (strlen (in_seq)+1, sizeof (char));
+ prot=vcalloc (strlen (in_seq)+1, sizeof (char));
+ sprintf ( seq, "%s", in_seq);
+
+ if ( mode == 3)nf=3;
+ else if ( mode == 4) nf=6;
+
+ for (a=0; a<nf; a++)
+ {
+ int f;
+ if (a==3)seq=complement_string (seq);
+ f=(a>=3)?a-3:a;
+ prot=translate_dna_seq ( seq,f,'\0', prot);
+ l=strlen (prot);
+ if (l>=max_l){max_l=l;best_frame=a;}
+ }
+ vfree (seq);
+ vfree (prot);
+ return best_frame;
+}
+
+Alignment *clean_gdna_aln (Alignment *A)
+ {
+ int a, b, c, r1, r2,s, p, n, tn;
+ int *col;
+ static int **mat;
+ Alignment *T=NULL;
+ int **score;
+ char *buffer;
+
+
+ /*Viterbi Parameters*/
+ int AL=0; /*Allowed Transition*/
+ int F=-1000000; /*Forbiden Transition*/
+ int SPLICE_PENALTY=100;
+ int ORF1=0, ORF2=1, ORF3=2, NC=3;
+
+ int state, pstate, best_e, best_pstate_p,best_state_p, best_pstate_v, best_state_v, v;
+ int nstate=4;
+ int **transitions;
+ int e;
+ int **v_tab_p;
+ int **v_tab;
+ int * is_dna;
+
+ best_state_p=best_state_v=best_pstate_p=best_pstate_v=best_e=0;
+ buffer=vcalloc ( 100000, sizeof (char));
+ is_dna=vcalloc ( A->nseq, sizeof (int));
+ score=declare_int ( A->nseq+1, A->len_aln);
+
+
+ if ( !mat)mat=read_matrice("pam250mt");
+ T=copy_aln (A, T);
+ col=vcalloc ( A->nseq, sizeof (int));
+
+ for (a=0; a<= A->len_aln; a++)
+ for ( b=0; b< A->nseq; b++){A->seq_al[b][a]=tolower(A->seq_al[b][a]); A->seq_al[b][a]=(A->seq_al[b][a]=='t')?'u':A->seq_al[b][a];}
+
+ for ( a=0; a< A->nseq; a++)
+ {
+ sprintf ( buffer, "%s", A->seq_al[a]);
+ ungap (buffer);
+ is_dna[a]=strm ( get_string_type (buffer), "DNA");
+ }
+
+
+ for (a=0; a< A->len_aln-2; a++)
+ {
+ for (b=0; b< A->nseq; b++)
+ {
+ if (is_dna[b])col[b]=translate_dna_codon (A->seq_al[b]+a, 'x');
+ else col[b]=tolower ( A->seq_al[b][a]);
+ }
+
+ for (n=0,tn=0,b=0; b< A->nseq; b++)
+ for ( c=b; c< A->nseq; c++ )
+ {
+ r1=col[b];
+ r2=col[c];
+
+ if (r1=='x' || r2=='x'){score[A->nseq][a]=F;break;}
+ else if (r1=='-' && r2=='-');
+ else if (r1=='-' || r2=='-');
+ else
+ {
+
+ if ( is_dna[b] && is_dna[c])score[A->nseq][a]+= mat[r1-'A'][r2-'A'];
+ else score[A->nseq][a]+=mat[r1-'A'][r2-'A']* (A->nseq*A->nseq);
+ }
+ n+=( !is_gap(r1) && !is_gap(r2));
+ score[A->nseq][a]=(((tn!=0)?score[A->nseq][a]/tn:0));
+ }
+
+ }
+
+ /*initialisation*/
+
+ transitions=declare_int ( nstate, nstate);
+ v_tab=declare_int ( A->len_aln+2, nstate );
+ v_tab_p=declare_int ( A->len_aln+2, nstate );
+
+ for (a=0; a<nstate;a++)
+ for (b=0; b<nstate;b++)
+ {transitions[a][b]=F;}
+
+ transitions[ORF1][ORF2]=AL;
+ transitions[ORF2][ORF3]=AL;
+ transitions[ORF3][ORF1]=AL;
+
+ transitions[ORF3][NC] =AL-SPLICE_PENALTY;
+ transitions[NC][ORF1] =AL-SPLICE_PENALTY;
+
+
+ for ( s=0; s<A->nseq; s++)
+ {
+ for ( p=0; p<=A->len_aln; p++){for (state=0; state< nstate; state++)v_tab_p[p][state]=-1; }
+ for (p=1+2; p<= A->len_aln; p++)
+ {
+
+ for (state=0; state< nstate; state++)
+ {
+
+ if ( state==NC){e=-best_e;}
+ else
+ {
+ e=score[A->nseq][(p-1)-state];
+ if ( state==0)best_e=e;
+ else best_e=MAX(e, best_e);
+ }
+
+ for ( pstate=0; pstate<nstate; pstate++)
+ {
+ v=e+transitions[pstate][state]+v_tab[p-1][pstate];
+ if (pstate==0 ||(v>best_pstate_v) )
+ {
+ best_pstate_v=v;
+ best_pstate_p=pstate;
+ }
+ }
+
+ v_tab[p][state]=best_pstate_v;
+ v_tab_p[p][state]=best_pstate_p;
+ if (state==0 ||best_pstate_v>best_state_v )
+ {
+ best_state_p=state;
+ best_state_v=best_pstate_v;
+ }
+ }
+
+ }
+
+
+
+ for (p=0; p< A->len_aln; p++)T->seq_al[s][p]='.';
+ for (p=A->len_aln; p>0; p--)
+ {
+
+ if ( best_state_p==0)T->seq_al[s][p-1]=translate_dna_codon (A->seq_al[s]+(p-1), 'x');
+ else if ( best_state_p==1 || best_state_p==2)T->seq_al[s][p-1]='-';
+
+
+
+ best_state_p=v_tab_p[p][best_state_p];
+
+ }
+ }
+
+
+
+ vfree (col);
+ return T;
+ }
+
+Alignment *clean_cdna_aln (Alignment *A)
+ {
+ /*Given an alignmnet of nucleotides
+ Returns the same alignmnent whith non coding nucleotides replaced with dots
+
+ at each position, the emission probability is the sum of pair of the substitution of amino-acids
+ */
+
+ int a, b, c,s, p;
+ static int **mat;
+ int *emission;
+ float em1, em2;
+ char *buffer;
+ Alignment *B=NULL;
+
+
+
+
+ /*Viterbi Parameters*/
+ int AL=0; /*Allowed Transition*/
+ int F=-1000000; /*Forbiden Transition*/
+ int PENALTY=30;
+ int NC, C1,C2, C3, START, END;
+ int nstate=0;
+ int state=0,best_state=0, score=0, best_score=0;
+ int p_state;
+ int e=0;
+ int **score_tab;
+ int **state_tab;
+
+ int **transitions;
+ int n;
+ int r1, r2, r3;
+
+ NC=nstate++;
+ C1=nstate++;
+ C2=nstate++;
+ C3=nstate++;
+ START=nstate++;
+ END=nstate++;
+
+
+ B=copy_aln (A, B);
+ buffer=vcalloc ( 100000, sizeof (char));
+ emission=vcalloc (A->len_aln, sizeof (int));
+
+ if ( !mat)
+ {
+ mat=read_matrice("pam250mt");
+ }
+
+ /*Computation of the emission proba for the coding state*/
+
+
+ for (a=0; a< A->len_aln; a++)
+ {
+
+ /*First component: % occupancy of the column*/
+ em1=0;
+ for ( b=0; b< A->nseq; b++) em1+=!is_gap(translate_dna_codon (A->seq_al[b]+a, '-'));
+ em1=em1/(float)A->nseq;
+
+ /*Second Component: % similarity within column*/
+ em2=0;
+ for (n=0,b=0; b< A->nseq-1; b++)
+ {
+ r1=translate_dna_codon (A->seq_al[b]+a, '-');
+
+ for (c=b+1; c<A->nseq; c++)
+ {
+ r2=translate_dna_codon (A->seq_al[c]+a, '-');
+ if (is_gap(r2) || is_gap(r1));
+ else
+ {
+ n++;
+ em2+=((mat[r1-'A'][r2-'A'])>1)?1:0;
+ }
+ }
+ }
+ em2=em2/(float)((n==0)?1:n);
+
+
+ emission[a]=(em1*100);
+
+ }
+
+
+
+ /*initialisation*/
+
+ transitions=declare_int ( nstate, nstate);
+ score_tab=declare_int ( A->len_aln+2, nstate );
+ state_tab=declare_int ( A->len_aln+2, nstate );
+
+ for (a=0; a<nstate;a++)
+ for (b=0; b<nstate;b++)
+ {transitions[a][b]=F;}
+
+
+ transitions[START][C1]=AL;
+ transitions[START][NC]=AL;
+ transitions[C3][END]=AL;
+ transitions[NC][END]=AL;
+ transitions[C1 ][C2 ]=AL;
+ transitions[C2 ][C3 ]=AL;
+ transitions[C3 ][C1 ]=AL;
+ transitions[C3 ][NC ]=AL-PENALTY;
+ transitions[NC ][C1 ]=AL-PENALTY;
+ transitions[NC][NC]=AL-PENALTY;
+
+
+
+ for ( s=0; s< A->nseq; s++)
+ {
+ for ( p=0; p<=A->len_aln; p++){for (state=0; state< nstate; state++){score_tab[p][state]=F;state_tab[p][state]=-1;} }
+ score_tab[0][START]=0;
+
+ for (p=1; p<= A->len_aln; p++)
+ {
+ for (state=0; state< nstate; state++)
+ {
+ if ( state==START || state==END)continue;
+ else if ( state==NC) e=-10;
+ else if ( state==C1)
+ {
+ e=emission[p-1];
+ }
+ else if ( state ==C2)
+ {
+ if ( p-2<0)e=F;
+ else e=emission[p-2];
+ }
+ else if ( state==C3)
+ {
+ if ( p-3<0)e=F;
+ else e=emission[p-3];
+ }
+
+ for (p_state=0; p_state<nstate; p_state++)
+ {
+
+ if (e==F)score=F;
+ else
+ {
+ score=(score_tab[p-1][p_state]==F)?F:(e+transitions[p_state][state]+score_tab[p-1][p_state]);
+ }
+
+ if(p_state==0 || score>best_score){ best_score=score;best_state=p_state;}
+
+ }
+
+ score_tab[p][state]=best_score;
+ state_tab[p][state]=best_state;
+
+ }
+ }
+
+ best_score=best_state=UNDEFINED;
+ for (state=0; state<nstate; state++)
+ {
+ if (state==START || state==END)continue;
+ e=transitions[state][END];
+ if (e==F || score_tab[p-1][state]==F)continue;
+
+ if (best_score==UNDEFINED || score_tab[p-1][state]>best_score)
+ {
+ best_score=score_tab[p-1][state]+e;
+ best_state=state;
+ }
+
+ }
+
+ for (p=A->len_aln; p>0;)
+ {
+ B->seq_al[s][p-1]=best_state+'0';
+ best_state=state_tab[p][best_state];
+ p--;
+ }
+ }
+
+ for ( a=0; a< A->nseq; a++)
+ for ( b=0; b< A->len_aln;)
+ {
+ s=B->seq_al[a][b];
+ if ( s==C1+'0')
+ {
+ r1=A->seq_al[a][b];
+ r2=A->seq_al[a][b+1];
+ r3=A->seq_al[a][b+2];
+
+
+ if ( is_gap(r1) ||is_gap(r2) || is_gap(r3))
+ {
+ A->seq_al[a][b]=(is_gap(r1))?'~':'.';
+ A->seq_al[a][b+1]=(is_gap(r2))?'~':'.';
+ A->seq_al[a][b+2]=(is_gap(r3))?'~':'.';
+ }
+ b+=3;
+ }
+ else if ( s==NC+'0')
+ {
+ A->seq_al[a][b]=(is_gap(A->seq_al[a][b]))?'~':'.';
+ b++;
+ }
+ else
+ {
+ fprintf (stderr, "\nPROBLEM: [%d %d]->%d", a, b, s-'0');
+ }
+ }
+
+
+ free_aln (B);
+ free_int (transitions, -1);
+ free_int (score_tab, -1);
+ free_int (state_tab, -1);
+ vfree (emission);
+ vfree (buffer);
+
+ return A;
+ }
+
+
+
+
+Alignment *translate_splice_dna_aln (Alignment *A, Alignment *ST)
+ {
+ int a, b, c, r1, r2,s, p, n, tn;
+ int *col;
+ static int **mat;
+ Alignment *T=NULL;
+ int **score;
+
+ /*Viterbi Parameters*/
+ int AL=0; /*Allowed Transition*/
+ int F=-1000000; /*Forbiden Transition*/
+ int ORF1=0, ORF2=1, ORF3=2,SPL1=3, SPL2=4, SPL3=5, SPL4=6, NC=7;
+ int SPLICE_PENALTY;
+ int frame1, frame2, frame3, best_frame;
+ int nstate=8;
+ char r;
+
+
+
+ int state=0, pstate=0, best_pstate_p=0,best_state_p=0, best_pstate_v=0, best_state_v=0, v=0;
+
+ int **transitions;
+ int e=0;
+ int **v_tab_p;
+ int **v_tab;
+
+ score=declare_int ( A->nseq+1, A->len_aln);
+
+
+ if ( !mat)mat=read_matrice("pam250mt");
+ T=copy_aln (A, T);
+ col=vcalloc ( A->nseq, sizeof (int));
+
+ for (a=0; a<= A->len_aln; a++)
+ for ( b=0; b< A->nseq; b++){A->seq_al[b][a]=tolower(A->seq_al[b][a]); A->seq_al[b][a]=(A->seq_al[b][a]=='t')?'u':A->seq_al[b][a];}
+
+
+
+
+ for (a=0; a< A->len_aln-2; a++)
+ {
+ for (b=0; b< A->nseq; b++)
+ {
+ col[b]=translate_dna_codon (A->seq_al[b]+a, 'x');
+ }
+
+ for (n=0,tn=0,b=0; b< A->nseq-1; b++)
+ for ( c=b+1; c< A->nseq; c++, tn++ )
+ {
+ r1=col[b];
+ r2=col[c];
+
+ if (r1=='x' || r2=='x')score[A->nseq][a]=F;
+ else if (r1=='-' && r2=='-');
+ else if (r1=='-' || r2=='-');
+ else
+ {
+ score[A->nseq][a]+= mat[r1-'A'][r2-'A'];
+
+ }
+ n+=( !is_gap(r1) && !is_gap(r2));
+ }
+ score[A->nseq][a]=(((tn!=0)?score[A->nseq][a]/tn:0));
+
+ }
+
+ /*initialisation*/
+
+ transitions=declare_int ( nstate, nstate);
+ v_tab=declare_int ( A->len_aln+2, nstate*nstate);
+ v_tab_p=declare_int ( A->len_aln+2, nstate*nstate);
+
+ for (a=0; a<nstate;a++)
+ for (b=0; b<nstate;b++)
+ {transitions[a][b]=F;}
+
+ SPLICE_PENALTY=-1000;
+
+ transitions[ORF1][ORF2] =AL;
+ transitions[ORF1][SPL1] =AL-SPLICE_PENALTY;
+
+ transitions[ORF2][ORF3] =AL;
+ transitions[ORF2][SPL1] =AL-SPLICE_PENALTY;
+
+ transitions[ORF3][ORF1] =AL;
+ transitions[ORF3][SPL1] =AL-SPLICE_PENALTY;
+
+ transitions[ORF3][ORF1] =AL;
+ transitions[ORF3][SPL1] =AL-SPLICE_PENALTY;
+
+ transitions[ORF3][NC]=AL-100;
+ transitions[NC][ORF1]=AL-100;
+
+
+ transitions[SPL1][SPL2]=AL;
+ transitions[SPL2][NC ]=AL-SPLICE_PENALTY;
+ transitions[NC ][NC ]=AL;
+ transitions[NC ][SPL3]=AL-SPLICE_PENALTY;
+ transitions[SPL3][SPL4]=AL;
+ transitions[SPL4][ORF1]=AL;
+ transitions[SPL4][ORF2]=AL;
+ transitions[SPL4][ORF3]=AL;
+
+
+ for ( s=0; s<A->nseq; s++)
+ {
+ for ( p=0; p<=A->len_aln; p++){for (state=0; state< nstate; state++)v_tab_p[p][state]=-1; }
+ for (p=1+2; p<= A->len_aln; p++)
+ {
+ frame1=score[A->nseq][(p-1)];
+ frame2=score[A->nseq][(p-1)-1];
+ frame3=score[A->nseq][(p-1)-2];
+ best_frame=best_int (3, 1, &a, frame1, frame2, frame3);
+ for (state=0; state< nstate; state++)
+ {
+ r=tolower (A->seq_al[s][p-1]);
+ r=(r=='u')?'t':r;
+
+ if (state==ORF1)e=frame1;
+ else if (state==ORF2)e=frame2;
+ else if (state==ORF3)e=frame3;
+ else if (state==SPL1)e=(r=='g')?best_frame:F;
+ else if (state==SPL2)e=(r=='t')?best_frame:F;
+ else if (state==SPL3)e=(r=='a')?best_frame:F;
+ else if (state==SPL4)e=(r=='g')?best_frame:F;
+ else if (state==NC)e=-best_frame;
+ for ( pstate=0; pstate<nstate; pstate++)
+ {
+ v=e+transitions[pstate][state]+v_tab[p-1][pstate];
+ if (pstate==0 ||(v>best_pstate_v) ){best_pstate_v=v;best_pstate_p=pstate;}
+ }
+
+ v_tab[p][state]=best_pstate_v;
+ v_tab_p[p][state]=best_pstate_p;
+ if (state==0 ||best_pstate_v>best_state_v ){best_state_p=state; best_state_v=best_pstate_v;}
+ }
+ }
+
+
+
+ for (p=0; p< A->len_aln; p++)T->seq_al[s][p]='.';
+ for (p=A->len_aln; p>0; p--)
+ {
+ if ( best_state_p==0)T->seq_al[s][p-1]=toupper(translate_dna_codon (A->seq_al[s]+(p-1), 'x'));
+ else if ( best_state_p>=SPL1 && best_state_p<=SPL4)T->seq_al[s][p-1]='-';
+ best_state_p=v_tab_p[p][best_state_p];
+ }
+ }
+
+
+
+ vfree (col);
+ return T;
+ }
+
+Alignment * mutate_cdna_aln ( Alignment *A)
+{
+ int a, b, c, n;
+ int n1, n2, r1, r2;
+ int **pos, ps;
+ int neutral_substitution=50;
+ int random_substitution=0;
+ int random_deletion=0;
+ int amino_acid_deletion=0;
+ int amino_acid_substitution=0;
+ char nuc_list[]="agct";
+ char *new_codon;
+
+ neutral_substitution=atoi(get_env_variable ("NEUTRAL_SUBSTITUTION",IS_FATAL));
+ random_substitution =atoi(get_env_variable ("RANDOM_SUBSTITUTION", IS_FATAL));
+ random_deletion =atoi(get_env_variable ("RANDOM_DELETION", IS_FATAL));
+ amino_acid_deletion =atoi(get_env_variable ("AMINO_ACID_DELETION", IS_FATAL));
+ amino_acid_substitution =atoi(get_env_variable ("AMINO_ACID_SUBSTITUTION", IS_FATAL));
+
+
+ if (A->S)free_sequence ( A->S, (A->S)->nseq);
+ A->S=aln2seq(A);
+
+ addrandinit(time (NULL));
+
+
+ pos=aln2pos_simple ( A, A->nseq);
+
+ /* 1 Apply neutral substitutions */
+
+ if ( neutral_substitution)
+ {
+ for ( c=0; c< neutral_substitution; c++)
+ {
+ for ( a=0; a< A->nseq; a++)
+ {
+
+ for ( b=0; b< A->len_aln; b++)
+ {
+
+ if (pos[a][b]<=0)continue;
+ ps=MAX(0,pos[a][b]-(pos[a][b]-1)%3-1);
+
+
+ n1=(A->S)->seq[a][pos[a][b]-1];
+ r1=translate_dna_codon ( (A->S)->seq[a]+ps, 'o');
+
+ n2=nuc_list[(int)addrand((unsigned long) 4)];
+ (A->S)->seq[a][pos[a][b]-1]=n2;
+ r2=translate_dna_codon ( (A->S)->seq[a]+ps, 'o');
+
+
+ if ( r1==r2 && r1!='o')A->seq_al[a][b]=n2;
+
+ else (A->S)->seq[a][pos[a][b]-1]=n1;
+ }
+ }
+ }
+ }
+
+ /* 2 Apply substitutions */
+ if ( random_substitution)
+ {
+ for ( a=0; a< A->nseq; a++)
+ {
+ for ( b=0; b< A->len_aln; b++)
+ {
+ if (pos[a][b]<=0)continue;
+ if (addrand ((unsigned long) 100)>random_substitution)continue;
+
+ n1=nuc_list[(int)addrand((unsigned long)4)];
+ (A->S)->seq[a][pos[a][b]-1]=n1;
+ A->seq_al[a][b]=n1;
+ }
+ }
+ }
+
+ /* 3 Apply amino acid substitutions */
+ if ( amino_acid_substitution)
+ {
+ for ( a=0; a< A->nseq; a++)
+ {
+ for ( b=0; b< A->len_aln; b+=3)
+ {
+ if (pos[a][b]<=0)continue;
+ if (addrand ((unsigned long) 100)>amino_acid_substitution)continue;
+ ps=MAX(0,pos[a][b]-(pos[a][b]-1)%3-1);
+
+ r1=translate_dna_codon ( (A->S)->seq[a]+ps, 'o');
+ new_codon=mutate_amino_acid(r1, "clustalw_col");
+
+ for ( c=ps; c<ps+3; c++)(A->S)->seq[a][c]=new_codon[c-ps];
+ }
+ for ( b=0; b< A->len_aln; b++)
+ {
+ if (pos[a][b]<=0)continue;
+ else A->seq_al[a][b]=(A->S)->seq[a][pos[a][b]-1];
+ }
+ }
+ }
+ /* 3 Apply amino acid deletions */
+ if ( amino_acid_deletion)
+ {
+ for ( a=0; a< A->nseq; a++)
+ {
+ for ( b=0; b< A->len_aln; b+=3)
+ {
+ if (pos[a][b]<=0)continue;
+ if (addrand ((unsigned long) 1000)>amino_acid_deletion)continue;
+ ps=MAX(0,pos[a][b]-(pos[a][b]-1)%3-1);
+ n=addrand ((unsigned long) 4)+1;
+
+ for ( c=ps; c<ps+(3*n) && c<A->len_aln; c++)(A->S)->seq[a][c]='-';
+ }
+ for ( b=0; b< A->len_aln; b++)
+ {
+ if (pos[a][b]<=0)continue;
+ else A->seq_al[a][b]=(A->S)->seq[a][pos[a][b]-1];
+ }
+ }
+ }
+ /* 4 Apply amino acid insertions */
+
+/*FRAMESHIFT MUTATIONS*/
+ /* 5 Apply nucleotide deletions*/
+ if ( random_deletion)
+ {
+ for ( a=0; a< A->nseq; a++)
+ {
+ for ( b=0; b< A->len_aln; b++)
+ {
+ if (pos[a][b]<=0)continue;
+ if (addrand ((unsigned long) 1000)>random_deletion)continue;
+
+ n1='-';
+ (A->S)->seq[a][pos[a][b]-1]=n1;
+ A->seq_al[a][b]=n1;
+ }
+ }
+ }
+ /* 6 Apply nucleotide deletions*/
+ free_int (pos, -1);
+ return A;
+
+}
+
+Alignment* clean_est ( Alignment *A)
+ {
+ /*Rules are as follow:
+ Internal Gap > 30% Requences ----> -
+ Best Residue < 50% Residues ----> 'N'
+ */
+ int a, b,c;
+ int best;
+ int tot;
+
+ for ( a=0; a< A->len_aln; a++)
+ {
+
+ for (tot=0, b=0; b<4; b++)tot+=(A->P)->count[b][a];
+ best=best_int (5,1, &c, (A->P)->count[0][a],(A->P)->count[1][a],(A->P)->count[2][a],(A->P)->count[3][a],(A->P)->count[4][a]);
+
+ if ( tot==0)
+ {
+ fprintf ( stderr, "\nWARNING: POSITION WITH NO INFORMATION [clean_est:%s]", PROGRAM);
+ A->seq_al[0][a]='-';
+ }
+ else if (((A->P)->count[4][a]*100)/tot >30)A->seq_al[0][a]='-';
+ else if ( (best*100)/tot<50)A->seq_al[0][a]='n';
+
+ }
+ return A;
+ }
+
+
+
+char **make_symbols ( char *name, int *n)
+ {
+ char **symbol;
+
+ symbol=declare_char ( STRING, STRING);
+
+ if ( strcmp (name, "3d_ali")==0)
+ {
+ sprintf ( symbol[0], "gih");
+ sprintf ( symbol[1], "eb");
+ sprintf ( symbol[2], "x");
+ sprintf ( symbol[3], "#l");
+ n[0]=4;
+ }
+
+ else if ( strcmp (name, "all")==0)
+ {
+ int a, i;
+ for ( i=0,a=0; a<26; a++)
+ {
+ sprintf ( symbol[i++], "%c%c", 'a'+a, 'a'+a);
+ sprintf ( symbol[i++], "%c%c", 'A'+a, 'A'+a);
+ }
+ sprintf ( symbol[i++], "--");
+ n[0]=i;
+ }
+
+ else if ( strcmp (name, "set1")==0)
+ {
+ sprintf ( symbol[0], "ilvmfywhktcagH");
+ sprintf ( symbol[1], "reqdnsP");
+ sprintf ( symbol[2], "--");
+ sprintf ( symbol[3], "#l");
+ n[0]=4;
+ }
+ else if ( strcmp (name, "set2")==0)
+ {
+ n[0]=0;
+ sprintf ( symbol[n[0]++], "gsacT");
+ sprintf ( symbol[n[0]++], "ndtvpS");
+ sprintf ( symbol[n[0]++], "ilkreqL");
+ sprintf ( symbol[n[0]++], "--");
+ sprintf ( symbol[n[0]++],"#l");
+ }
+ else if ( strcmp ( name, "any")==0)
+ {
+ sprintf ( symbol[0], "*x");
+ n[0]=1;
+ }
+
+
+
+
+ return symbol;
+ }
+
+char *testdna2gene (char *dna)
+{
+ int *w,a,l;
+ l=strlen (dna);
+ HERE ("%s", dna);
+ w=vcalloc(l+1, sizeof (int));
+ for (a=0; a<l; a++)
+ {
+ w[a]=isupper (dna[a])?1:-1;
+ }
+ dna=dna2gene (dna,w);
+ vfree (w);
+ return dna;
+}
+
+Sequence *dnaseq2geneseq (Sequence *S, int **w)
+{
+ Sequence *PS;
+ int a;
+ char *p;
+
+ PS=duplicate_sequence (S);
+ for (a=0; a<S->nseq; a++)
+ {
+ p=dna2gene (S->seq[a], w[a]);
+ if (strstr (p, "F"))
+ {
+ HERE ("----FRAMESHIFT: %s", S->name[a]);
+ }
+ vfree (PS->seq[a]);
+ PS->len[a]=strlen(p);
+ PS->seq[a]=vcalloc (PS->len[a]+1, sizeof (char));
+ sprintf ( PS->seq[a], "%s", p);
+ vfree (p);
+ }
+ PS=reset_sequence_len (PS);
+ return PS;
+}
+
+char *dna2gene (char *dna, int *w)
+{
+ int a, b, c, ns,l,od;
+ int I1, I2, I3, START, NCE, NCS;
+ int C1, S1_1, S2_1, S3_1, S4_1,NC1;
+ int C2, S1_2, S2_2, S3_2, S4_2,NC2;
+ int C3, S1_3, S2_3, S3_3, S4_3,NC3;
+ int ST;
+ int st;
+
+ double p_C1, p_C2;
+ double **C1_mat, **C2_mat;
+ double *tb, **sc_mat, **tb_mat;
+ double **em, **trans;
+ double avg_w=0;
+
+ char **string;
+ double forbiden =-100000;
+ double frameshift1;
+ double frameshift2;
+ double exon_penalty;
+ double exon_reward;
+ double nostop_penalty;
+ double shiftw;
+ int frameshift_symbol='F';
+ char *out_dna;
+ int max=0;
+
+ char *three_dna;
+
+ three_dna=translate_dna_seq_on3frame (dna, 'x', NULL);
+ lower_string(three_dna);
+ l=strlen (dna);
+ for (a=0; a<l; a++){max=MAX(max,w[a]);avg_w+=(double)w[a];}
+ avg_w/=(double)l;
+ shiftw=avg_w*-2;
+
+ exon_penalty=-100*avg_w;
+ exon_reward=avg_w;
+ nostop_penalty=-100 *avg_w;
+ frameshift1=forbiden;
+ frameshift2=frameshift1;
+
+ out_dna=vcalloc ( 2*strlen (dna)+1, sizeof (char));
+ sprintf (out_dna, "%s", dna);
+ ns=0;
+ START=ns++; I1=ns++;I2=ns++;I3=ns++;NCE=ns++;NCS=ns++;
+
+ C1=ns++; S1_1=ns++;S2_1=ns++;NC1=ns++;S3_1=ns++;S4_1=ns++;
+ C2=ns++; S1_2=ns++;S2_2=ns++;NC2=ns++;S3_2=ns++;S4_2=ns++;
+ C3=ns++; S1_3=ns++;S2_3=ns++;NC3=ns++;S3_3=ns++;S4_3=ns++;
+ ST=ns++;
+
+ string=declare_char ( ns+1, 10);
+ sprintf (string [S1_1], "S1_1");
+ sprintf (string [S2_1], "S2_1");
+ sprintf (string [S3_1], "S3_1");
+ sprintf (string [S4_1], "S4_1");
+
+ sprintf (string [S1_2], "S1_2");
+ sprintf (string [S2_2], "S2_2");
+ sprintf (string [S3_2], "S3_2");
+ sprintf (string [S4_2], "S4_2");
+
+ sprintf (string [S1_3], "S1_3");
+ sprintf (string [S2_3], "S2_3");
+ sprintf (string [S3_3], "S3_3");
+ sprintf (string [S4_3], "S4_3");
+
+ sprintf (string [START], "START");
+ sprintf (string [NCE], "NCE");
+ sprintf (string [NCS], "NCS");
+ sprintf (string [NC1], "NC1");
+ sprintf (string [NC2], "NC2");
+ sprintf (string [NC3], "NC3");
+ sprintf (string [I1], "I1");
+ sprintf (string [I2], "I2");
+ sprintf (string [I3], "I3");
+
+ sprintf (string [C1], "C1");
+ sprintf (string [C2], "C2");
+ sprintf (string [C3], "C3");
+
+ sprintf (string [ST], "STOP");
+
+ trans=declare_double(ns,ns);
+ em=declare_double (ns,256);
+ tb=vcalloc ( l+1, sizeof (double));
+ sc_mat=declare_double (l+1, ns);
+ tb_mat=declare_double (l+1, ns);
+ C1_mat=declare_double (l+1, ns);
+ C2_mat=declare_double (l+1, ns);
+
+ for (a=0; a<ns; a++)
+ {
+ for (b=0; b<ns; b++)trans[a][b]=forbiden;
+ for (b=0; b<256; b++)em[a][b]=forbiden;
+ }
+
+ trans[START][I1]=0;
+ trans[START][NCS]=0;
+ trans[NCS][NCS]=0;
+ trans[NCS][NCE]=0;//allow sequence entirely non coding
+
+ trans[NCS][I1]=0;
+ trans[I1][I2]=0;
+ trans[I2][I3]=0;
+ trans[I3][C1]=0;
+
+ trans[C1][C2]=0;
+ trans[C1][C3]=frameshift1;
+ trans[C1][C1]=frameshift2;
+
+ trans[C2][C3]=0;
+ trans[C2][C1]=frameshift1;
+ trans[C2][C2]=frameshift2;
+
+
+ trans[C3][C1]=exon_reward;
+ trans[C3][C2]=frameshift1;
+ trans[C3][C3]=frameshift2;
+
+ trans[C3][NCE]=nostop_penalty;
+ trans[C3][ST] =0; //normal termination
+ trans[ST][NCE]=0;
+ trans[NCE][NCE]=0;
+
+ trans[C1][S1_1]=exon_penalty;
+ trans[S1_1][S2_1]=0;
+ trans[S2_1][NC1]=0;
+ trans[NC1][NC1]=0;
+ trans[NC1][S3_1]=0;
+ trans[S3_1][S4_1]=0;
+ trans[S4_1][C2]=0;
+ trans[S4_1][C3]=frameshift1;
+ trans[S4_1][C1]=frameshift2;
+
+
+ trans[C2][S1_2]=exon_penalty;
+ trans[S1_2][S2_2]=0;
+ trans[S2_2][NC2]=0;
+ trans[NC2][NC2]=0;
+ trans[NC2][S3_2]=0;
+ trans[S3_2][S4_2]=0;
+ trans[S4_2][C3]=0;
+ trans[S4_2][C1]=frameshift1;
+ trans[S4_2][C2]=frameshift2;
+
+ trans[C3][S1_3]=exon_penalty;
+ trans[S1_3][S2_3]=0;
+ trans[S2_3][NC3]=0;
+ trans[NC3][NC3]=0;
+ trans[NC3][S3_3]=0;
+ trans[S3_3][S4_3]=0;
+ trans[S4_3][C1]=0;
+ trans[S4_3][C2]=frameshift1;
+ trans[S4_3][C3]=frameshift2;
+
+ em[I1]['A']=1;
+ em[I2]['T']=1;
+ em[I3]['G']=1;
+
+ em[S1_1]['G']=1;
+ em[S2_1]['T']=1;
+ em[S3_1]['A']=1;
+ em[S4_1]['G']=1;
+
+ em[S1_2]['G']=1;
+ em[S2_2]['T']=1;
+ em[S3_2]['A']=1;
+ em[S4_2]['G']=1;
+
+ em[S1_3]['G']=1;
+ em[S2_3]['T']=1;
+ em[S3_3]['A']=1;
+ em[S4_3]['G']=1;
+
+
+ for (a=0; a<ns; a++)sc_mat[0][a]=tb_mat[0][a]=forbiden;
+ sc_mat[0][START]=tb_mat[0][START]=0;
+
+ for (a=1; a<=l ;a++)
+ {
+ int r;
+ r=toupper (dna[a-1]);
+ for (b=0; b<ns; b++)
+ {
+ double best_sc,e,lw;
+ int best_t;
+
+ lw=(double)w[a-1]+shiftw;
+
+ if (b==ST && three_dna[a-1]=='x')e=0;
+ else if (b==C1 || b == C2 || b== C3)e=lw;
+ else if ( b==NC1|| b==NC2 || b==NC3 || b==NCE || b==NCS)e=-lw;
+ else e=em[b][r];
+
+ if (e==forbiden)
+ {
+ sc_mat[a][b]=forbiden;
+ tb_mat[a][b]=0;
+ }
+ else
+ {
+ for (best_sc=forbiden,best_t=0,c=0; c<ns; c++)
+ {
+ double tr, sc, p_sc;
+ tr = trans[c][b];
+ p_sc=sc_mat[a-1][c];
+
+ //Frameshift handling
+
+ if ( tr== forbiden || p_sc==forbiden);
+ else if (tr!=forbiden)
+ {
+ if (b==C2 && c!=C1 && c!=S4_1){p_C1='N'; p_C2=r; }
+ else if(b==C3 && c!=C2 && c!=S4_2){p_C1='N'; p_C2='N';}
+ else
+ {
+ p_C1=C1_mat[a-1][c];
+ p_C2=C2_mat[a-1][c];
+ }
+
+ if (b==C3 && is_stop (p_C1, p_C2,r)){tr=forbiden;}
+ else
+ {
+ sc=tr+e+p_sc;
+ if (c==0 || sc>best_sc)
+ {
+ best_sc=sc;
+ best_t =c;
+ }
+ }
+ }
+ }
+
+ C1_mat[a][b]=(b==C1)?r:C1_mat[a-1][best_t];
+ C2_mat[a][b]=(b==C2)?r:C2_mat[a-1][best_t];
+ sc_mat[a][b]=best_sc;
+ tb_mat [a][b]=best_t;
+ }
+
+ }
+ }
+
+ a=l;
+ b=NCE;
+ c=sc_mat[a][NCE];
+
+ while (a>0)
+ {
+// HERE ("**%d [%s] %c in %d", b,string[b], dna[a-1], a);
+ tb[a]=b;
+ b=tb_mat[a][b];
+ a--;
+ }
+
+ od=0;
+ st=0;
+ for (a=0;a<l;a++)
+ {
+ int r,t,pt, coding;
+ t =tb[a+1];
+ pt=tb[a ];
+ r=dna[a];
+ if ( st || t==ST)st++;
+ coding=(t==C1 || t==C2 || t==C3 || t==I1 || t==I2 || t==I3 ||(st && st<=3))?1:0;
+
+
+
+ if (t==C1 && (pt==C2 || pt==S4_2)){out_dna[od++]=frameshift_symbol;}
+ else if (t==C1 && (pt==C1 || pt==S4_1)){out_dna[od++]=frameshift_symbol;out_dna[od++]=frameshift_symbol;}
+
+ else if (t==C2 && (pt==C3 || pt==S4_3)){out_dna[od++]=frameshift_symbol;}
+ else if (t==C2 && (pt==C2 || pt==S4_2)){out_dna[od++]=frameshift_symbol;out_dna[od++]=frameshift_symbol;}
+
+ else if (t==C3 && (pt==C1 || pt==S4_1)){out_dna[od++]=frameshift_symbol;}
+ else if (t==C3 && (pt==C3 || pt==S4_3)){out_dna[od++]=frameshift_symbol;out_dna[od++]=frameshift_symbol;}
+
+ if (coding)out_dna[od++]=toupper (r);
+ else out_dna[od++]=tolower(r);
+
+ }
+
+ free_double (tb_mat, -1);
+ free_double (sc_mat, -1);
+ free_double (trans, -1);
+ free_double (em, -1);
+ free_double (C1_mat, -1);
+ free_double (C2_mat, -1);
+ vfree (tb);
+ vfree (three_dna);
+ return out_dna;
+}
+
+
+int res_weights2avg(Sequence *R, int **w)
+{
+ int a, b;
+ double avg=0;
+ int n=0;
+
+ for (a=0; a<R->nseq; a++)
+ for (b=0; b<R->len[a]; b++){avg+=w[a][b];n++;}
+ return avg/n;
+}
+int res_weights2min(Sequence *R, int **w)
+{
+ int a,b;
+ int min=w[0][0];
+
+ for (a=0; a<R->nseq; a++)
+ for (b=0; b<R->len[a]; b++)min=MIN(min,(w[a][b]));
+ return min;
+}
+int res_weights2max(Sequence *R, int **w)
+{
+ int a, b;
+ int max=w[0][0];
+
+ for (a=0; a<R->nseq; a++)
+ for (b=0; b<R->len[a]; b++)max=MAX(max,(w[a][b]));
+ return max;
+}
+int scan_res_weights4ac (Sequence *R, int **w, int start, int end, int step)
+{
+ int best_t, a;
+ float best_ac=0;
+ float *count;
+ float *acc;
+ int avg;
+
+ avg=res_weights2avg(R,w);
+ best_t=start;
+ for (a=start; a<=end; a+=step)
+ {
+
+ count=res_weights2accuracy_counts (R,w,a,NULL);
+ acc=counts2accuracy (count);
+
+ if (acc[3]>best_ac)
+ {
+ best_ac=acc[3];
+ best_t=a;
+ }
+ vfree (count);vfree (acc);
+ }
+ count=res_weights2accuracy_counts (R,w,best_t,NULL);
+ acc=counts2accuracy (count);
+ fprintf (stderr, "\nBest_T: %d ", best_t);
+ display_accuracy (count,stderr);
+
+ count=res_weights2accuracy_counts (R,w,2*avg,NULL);
+ acc=counts2accuracy (count);
+ fprintf (stderr, " Avg_T: %d ", 2*avg);
+ display_accuracy (count,stderr);
+
+ vfree (acc); vfree (count);
+ return best_t;
+}
+int ** shift_res_weights ( Sequence *R, int **w, int shift)
+{
+ int a, b;
+ for (a=0; a<R->nseq; a++)
+ for (b=0; b<R->len[a]; b++)
+ w[a][b]+=shift;
+ return w;
+}
+float *res_weights2accuracy_counts ( Sequence *R, int **w,int T, float *result)
+{
+ int a, b, coding,pcoding;
+
+ if (!result)result=vcalloc (4, sizeof (float));
+
+ for (a=0; a<R->nseq; a++)
+ {
+ for (b=0; b<R->len[a]; b++)
+ {
+ coding=(isupper(R->seq[a][b]))?1:0;
+ pcoding=(w[a][b]>T)?1:0;
+ if ( coding && pcoding)result[0]++;//TP
+ else if ( !coding && !pcoding)result[1]++;//TN
+ else if ( !coding && pcoding)result[2]++;//FP
+ else if ( coding && !pcoding)result[3]++;//FN
+ }
+ }
+ return result;
+}
+
+void genepred_seq2accuracy_counts4all (Sequence *R, Sequence *T)
+{
+ int a,b;
+ float *result =vcalloc (4, sizeof (float));
+
+ fprintf ( stderr, "\n");
+
+ for (a=0; a<R->nseq; a++)
+ {
+ fprintf ( stderr, "gene: %s ", R->name[a]);
+ for (b=0; b<T->nseq; b++)
+ {
+ if ( strm (R->name[a], T->name[b]) && hasupper(R->seq[a]))
+ {
+ vfree (display_accuracy (genepred2accuracy_counts (R->seq[a], T->seq[b], NULL),stderr));
+ break;
+ }
+ }
+ }
+ vfree(result);
+}
+
+float* genepred_seq2accuracy_counts (Sequence *R, Sequence *T,float *result)
+{
+ int a,b;
+
+ if (!result)result=vcalloc (4, sizeof (float));
+
+ for (a=0; a<R->nseq; a++)
+ for (b=0; b<T->nseq; b++)
+ if ( strm (R->name[a], T->name[b]) && hasupper(R->seq[a]))
+ genepred2accuracy_counts (R->seq[a], T->seq[b], result);
+ return result;
+}
+
+float* genepred2accuracy_counts (char *ref, char *target , float *result)
+{
+ char *ref2, *target2;
+ int l,a;
+ if ( !result) result=vcalloc (4, sizeof (float));
+ ref2=vcalloc ( strlen (ref)+1, sizeof (char));
+ sprintf ( ref2, "%s", ref);
+
+ target2=vcalloc ( strlen (target)+1, sizeof (char));
+ sprintf ( target2, "%s", target);
+
+ remove_charset (ref2, "Ff");
+ remove_charset (target2, "Ff");
+
+ if ( strlen (target2) != strlen (ref2))
+ {fprintf (stderr, "ERROR: Gene and target have different length [FATAL]\n"); myexit (EXIT_FAILURE);}
+
+ l=strlen (ref2);
+ for (a=0; a<l; a++)
+ {
+ int coding, pcoding;
+ coding =isupper (ref2[a]);
+ pcoding=isupper (target2[a]);
+ if ( coding && pcoding)result[0]++;//TP
+ else if ( !coding && !pcoding)result[1]++;//TN
+ else if ( !coding && pcoding)result[2]++;//FP
+ else if ( coding && !pcoding)result[3]++;//FN
+ }
+
+ vfree (ref2);
+ vfree (target2);
+ return result;
+ }
+
+int is_stop( char r1, char r2, char r3)
+{
+ char codon[4];
+
+ if (!r2 || !r3) return 0;
+ else if (tolower (r1)=='n' || tolower(r2)=='n' || tolower(r3)=='n') return 0;
+ else
+ {
+ sprintf (codon, "%c%c%c", tolower(r1), tolower(r2), tolower(r3));
+ if (translate_dna_codon (codon, 'x')=='x')return 1;
+ else return 0;
+ }
+}
+
+
+char * translate_dna_seq_on3frame ( char *dna_seq, char stop, char *prot)
+ {
+ int a, l;
+ char *buf;
+
+ l=strlen (dna_seq);
+ if ( prot==NULL)prot=vcalloc ( l+2, sizeof (char));
+
+ buf=vcalloc (l+4, sizeof (char));
+ sprintf (buf, "%s", dna_seq);
+ lower_string ( buf);
+ for ( a=0; a< l; a++)buf[a]=(buf[a]=='t')?'u':buf[a];
+
+ for (a=0; a< l; a++)
+ prot[a]=translate_dna_codon (buf+a, stop);
+ vfree (buf);
+ prot[a]='\0';
+
+ return prot;
+ }
+char * translate_dna_seq ( char *dna_seq, int frame, char stop, char *prot)
+ {
+ //frame: 1->3
+ int a, b, l;
+ char *buf;
+
+ l=strlen (dna_seq);
+ if ( prot==NULL)prot=vcalloc ( l, sizeof (char));
+ frame--;
+ buf=vcalloc (l+4, sizeof (char));
+ sprintf (buf, "%s", dna_seq);
+ lower_string ( buf);
+ for ( a=0; a< l; a++)buf[a]=(buf[a]=='t')?'u':buf[a];
+
+
+ for ( b=0,a=0+frame; a< l; a+=3,b++)
+ {
+
+ prot[b]=translate_dna_codon (buf+a, stop);
+ }
+ vfree (buf);
+ prot[b]='\0';
+ upper_string (buf);
+ return prot;
+ }
+char * back_translate_dna_codon ( char aa, int deterministic)
+ {
+ static char *r;
+ int choice;
+
+ vsrand(0);
+ if ( r==NULL)r=vcalloc (4, sizeof (char));
+
+ if (!is_gap(aa))aa=tolower(aa);
+
+ if (is_gap(aa))sprintf (r, "---");
+ else if ( aa>=0 && aa<=9)
+ {
+ sprintf (r, "%d%d%d", aa, aa,aa);
+ }
+ else if ( aa>='0' && aa<='9')
+ {
+ sprintf (r, "%c%c%c", aa, aa,aa);
+ }
+ else if ( aa=='a')
+ {
+ choice=(deterministic)?0:rand()%4;
+ if ( choice==0)sprintf (r, "gca");
+ else if ( choice==1)sprintf (r, "gcg");
+ else if ( choice==2)sprintf (r, "gcc");
+ else if ( choice==3)sprintf (r, "gct");
+ }
+ else if ( aa=='c')
+ {
+ choice=(deterministic)?0:rand()%2;
+ if ( choice==0)sprintf (r, "tgc");
+ else if ( choice==1)sprintf (r, "tgt");
+ }
+ else if ( aa=='d')
+ {
+ choice=(deterministic)?0:rand()%2;
+ if ( choice==0)sprintf (r, "gac");
+ else if ( choice==1)sprintf (r, "gat");
+ }
+
+ else if ( aa=='e')
+ {
+ choice=(deterministic)?0:rand()%2;
+ if ( choice==0)sprintf (r, "gaa");
+ else sprintf (r, "gag");
+ }
+ else if ( aa=='f')
+ {
+ choice=(deterministic)?0:rand()%2;
+ if ( choice==0)sprintf (r, "ttc");
+ else sprintf (r, "ttt");
+ }
+ else if ( aa=='g')
+ {
+ choice=(deterministic)?0:rand()%4;
+ if ( choice==0) sprintf (r, "gga");
+ else if ( choice==1) sprintf (r, "ggg");
+ else if ( choice==2) sprintf (r, "ggc");
+ else if ( choice==3) sprintf (r, "ggt");
+ }
+ else if ( aa=='h')
+ {
+ choice =rand()%2;
+ if ( choice==0)sprintf (r, "cac");
+ else sprintf (r, "cat");
+ }
+ else if ( aa=='i')
+ {
+ choice=(deterministic)?0:rand()%3;
+ if ( choice==0) sprintf (r, "ata");
+ else if ( choice==1) sprintf (r, "atc");
+ else if ( choice==2) sprintf (r, "att");
+ }
+ else if ( aa=='k')
+ {
+ choice=(deterministic)?0:rand()%2;
+ if ( choice==0) sprintf (r, "aaa");
+ else if ( choice==1) sprintf (r, "aag");
+
+ }
+ else if ( aa=='l')
+ {
+ choice=(deterministic)?0:rand()%6;
+ if ( choice==0) sprintf (r, "cta");
+ else if ( choice==1) sprintf (r, "ctg");
+ else if ( choice==2) sprintf (r, "ctc");
+ else if ( choice==3) sprintf (r, "ctt");
+ else if ( choice==4) sprintf (r, "tta");
+ else if ( choice==5) sprintf (r, "ttg");
+ }
+ else if ( aa=='m')sprintf ( r, "atg");
+ else if ( aa=='n')
+ {
+ choice=(deterministic)?0:rand()%2;
+ if ( choice==0) sprintf (r, "aac");
+ else if ( choice==1) sprintf (r, "aat");
+ }
+ else if ( aa=='p')
+ {
+ choice=(deterministic)?0:rand()%4;
+ if ( choice==0) sprintf (r, "cca");
+ else if ( choice==1) sprintf (r, "ccg");
+ else if ( choice==2) sprintf (r, "ccc");
+ else if ( choice==3) sprintf (r, "cct");
+ }
+ else if ( aa=='q')
+ {
+ choice=(deterministic)?0:rand()%2;
+ if ( choice==0) sprintf (r, "caa");
+ else if ( choice==1) sprintf (r, "cag");
+ }
+ else if ( aa=='r')
+ {
+ choice=(deterministic)?0:rand()%6;
+ if ( choice==0) sprintf (r, "cga");
+ else if ( choice==1) sprintf (r, "cgg");
+ else if ( choice==2) sprintf (r, "cgc");
+ else if ( choice==3) sprintf (r, "cgt");
+ else if ( choice==4) sprintf (r, "aga");
+ else if ( choice==5) sprintf (r, "agg");
+
+ }
+ else if ( aa=='s')
+ {
+ choice=(deterministic)?0:rand()%6;
+ if ( choice==0) sprintf (r, "tca");
+ else if ( choice==1) sprintf (r, "tcg");
+ else if ( choice==2) sprintf (r, "tcc");
+ else if ( choice==3) sprintf (r, "tct");
+ else if ( choice==4) sprintf (r, "agt");
+ else if ( choice==5) sprintf (r, "agc");
+
+ }
+ else if ( aa=='t')
+ {
+ choice=(deterministic)?0:rand()%4;
+ if ( choice==0) sprintf (r, "aca");
+ else if ( choice==1) sprintf (r, "acg");
+ else if ( choice==2) sprintf (r, "acc");
+ else if ( choice==3) sprintf (r, "act");
+ }
+ else if ( aa=='v')
+ {
+ choice=(deterministic)?0:rand()%4;
+ if ( choice==0) sprintf (r, "gta");
+ else if ( choice==1) sprintf (r, "gtg");
+ else if ( choice==2) sprintf (r, "gtc");
+ else if ( choice==3) sprintf (r, "gtt");
+ }
+ else if ( aa=='w')
+ {
+ sprintf (r, "tgg");
+ }
+ else if ( aa=='y')
+ {
+ choice=(deterministic)?0:rand()%2;
+ if ( choice==0) sprintf (r, "tac");
+ else if ( choice==1) sprintf (r, "tat");
+ }
+ else
+ {
+ sprintf (r, "nnn");
+ }
+ return r;
+
+ }
+int translate_dna_codon ( char *sequence, char stop)
+ {
+ char seq[4];
+ int b;
+ int upper;
+ int ret;
+
+ if ( strlen (sequence)<1) return 'n';
+ upper=isupper (sequence[0])?1:0;
+
+ if ( (b=strlen (sequence))<3)
+ ret='x';
+ else
+ {
+ seq[0]=tolower(sequence[0]);
+ seq[1]=tolower(sequence[1]);
+ seq[2]=tolower(sequence[2]);
+ seq[3]='\0';
+
+ seq[0]=(seq[0]=='u')?'t':seq[0];
+ seq[1]=(seq[1]=='u')?'t':seq[1];
+ seq[2]=(seq[2]=='u')?'t':seq[2];
+ if ( strm5(seq, "gca", "gcg", "gcc", "gct","gcn"))ret='a';
+ else if ( strm2(seq, "tgc","tgt"))ret='c';
+ else if ( strm2(seq, "gac","gat"))ret='d';
+ else if ( strm2(seq, "gaa","gag"))ret='e';
+ else if ( strm2(seq, "ttc","ttt"))ret='f';
+ else if ( strm5(seq, "gga","ggg","ggc", "ggt", "ggn"))ret='g';
+ else if ( strm2(seq, "cac","cat"))ret='h';
+ else if ( strm3(seq, "ata","atc","att"))ret='i';
+ else if ( strm2(seq, "aaa","aag"))ret= 'k';
+ else if ( strm6(seq, "cta","ctg","ctc", "ctt", "tta", "ttg"))ret='l';
+ else if ( strm (seq, "ctn"))ret='l';
+ else if ( strm (seq, "atg"))ret='m';
+ else if ( strm2(seq, "aac","aat"))ret= 'n';
+ else if ( strm5(seq, "cca","ccg","ccc", "cct","ccn"))ret='p';
+ else if ( strm2(seq, "cag","caa"))ret='q';
+ else if ( strm6(seq, "cga","cgg","cgc", "cgt","aga","agg"))ret='r';
+ else if ( strm (seq, "cgn"))ret= 'r';
+ else if ( strm6(seq, "tca","tcg","tcc", "tct","agc","agt"))ret='s';
+ else if ( strm (seq, "ccn"))ret='s';
+ else if ( strm5(seq, "aca","acg","acc", "act", "acn"))ret='t';
+ else if ( strm5(seq, "gta","gtg","gtc", "gtt", "gtn"))ret='v';
+ else if ( strm (seq, "tgg"))ret='w';
+ else if ( strm2(seq, "tac","tat"))ret='y';
+ else if ( strm3(seq, "tag","taa","tga"))ret=stop;
+ else ret='x';
+
+ ret= (upper)?toupper(ret):ret;
+ }
+ return ret;
+ }
+
+int extend_seqaln (Sequence *S, Alignment *A)
+{
+ char **s;
+ int n,a;
+ if (S){s=S->seq;n=S->nseq;}
+ else if (A){s=A->seq_al;n=A->nseq;}
+ else return 0;
+
+ for (a=0; a<n;a++){extend_seq(s[a]);}
+ return 1;
+}
+int unextend_seqaln (Sequence *S, Alignment *A)
+{
+ char **s;
+ int n, a;
+ if (S){s=S->seq;n=S->nseq;}
+ else if (A){s=A->seq_al;n=A->nseq;}
+ else return 0;
+
+ for (a=0; a<n;a++){unextend_seq(s[a]);}
+ return 1;
+}
+
+
+char *extend_seq (char *seq)
+{
+ char *buf, *ebuf;
+ int l, lb, a, b, upper,v;
+ char r1, r2;
+
+ l=strlen (seq);
+ buf =vcalloc ( l+1, sizeof (char));
+ ebuf=vcalloc ( l+1, sizeof (char));
+ sprintf ( buf, "%s", seq);
+ sprintf ( ebuf, "%s", seq);
+
+ ungap ( buf);
+ ungap (ebuf);
+ lb=strlen (buf);
+
+ for (a=0; a<lb-1; a++)
+ {
+ r1=buf[a];
+ r2=buf[a+1];
+
+ upper=(isupper(r1))?1:0;
+ r1=tolower(r1);
+ r2=tolower(r2);
+
+ r1=(r1=='u')?'t':r1;
+ r2=(r2=='u')?'t':r2;
+
+ if (r1=='x' || r1=='n')v='x';
+ else if (r2=='n' || r2=='x')v=r1;
+
+ else if (r1=='a' && r2=='a')v='d';
+ else if (r1=='a' && r2=='c')v='e';
+ else if (r1=='a' && r2=='g')v='f';
+ else if (r1=='a' && r2=='t')v='h';
+
+ else if (r1=='c' && r2=='a')v='i';
+ else if (r1=='c' && r2=='c')v='k';
+ else if (r1=='c' && r2=='g')v='l';
+ else if (r1=='c' && r2=='t')v='m';
+
+ else if (r1=='g' && r2=='a')v='n';
+ else if (r1=='g' && r2=='c')v='p';
+ else if (r1=='g' && r2=='g')v='q';
+ else if (r1=='g' && r2=='t')v='r';
+
+ else if (r1=='t' && r2=='a')v='s';
+ else if (r1=='t' && r2=='c')v='v';
+ else if (r1=='t' && r2=='g')v='w';
+ else if (r1=='t' && r2=='t')v='y';
+ else
+ {
+ v='j';
+ }
+ ebuf[a]=(upper)?toupper(v):v;
+ }
+
+ for (b=0,a=0; a<l; a++)
+ {
+ if ( !is_gap(seq[a]))seq[a]=ebuf[b++];
+ }
+ vfree (ebuf);
+ vfree (buf);
+ return seq;
+}
+char *unextend_seq (char *seq)
+{
+ char *buf, *ebuf;
+ int l, lb, a, b, upper,v;
+ char r1, r2;
+
+ l=strlen (seq);
+ buf =vcalloc ( l+1, sizeof (char));
+ ebuf=vcalloc ( l+1, sizeof (char));
+ sprintf ( buf, "%s", seq);
+ sprintf ( ebuf, "%s", seq);
+
+ ungap ( buf);
+ ungap (ebuf);
+ lb=strlen (buf);
+
+ for (a=0; a<lb-1; a++)
+ {
+ r1=buf[a];
+ upper=(isupper(r1))?1:0;
+ r1=tolower(r1);
+ r1=(r1=='u')?'t':r1;
+
+ if (r1=='x')v='n';
+ else if (r1=='d' || r1=='e' || r1 == 'f' || r1 == 'h')v='a';
+ else if (r1=='i' || r1=='k' || r1 == 'l' || r1 == 'm')v='c';
+ else if (r1=='n' || r1=='p' || r1 == 'q' || r1 == 'r')v='g';
+ else if (r1=='s' || r1=='v' || r1 == 'w' || r1 == 'y')v='t';
+ else v='j';
+
+ ebuf[a]=(upper)?toupper(v):v;
+ }
+
+ for (b=0,a=0; a<l; a++)
+ {
+ if ( !is_gap(seq[a]))seq[a]=ebuf[b++];
+ }
+ vfree (ebuf);
+ vfree (buf);
+ return seq;
+}
+
+
+
+Alignment * mutate_aln ( Alignment *A, char *r)
+{
+ int a, b, c, mut,type, ratio;
+ char alp[30];
+ int alp_size;
+ Sequence *S;
+ Alignment*B;
+ int n_mut, tot;
+
+ vsrand(0);
+ if ( r[0]=='\0')ratio=0.01*RAND_MAX;
+ else ratio=atof(r)*RAND_MAX;
+
+ S=aln2seq(A);
+ S=get_sequence_type(S);
+
+
+
+ if ( strm(S->type, "DNA") || strm(S->type, "RNA"))sprintf (alp, "AGCT");
+ else if ( strm(S->type, "PROTEIN"))sprintf (alp, "ACDEFGHIKLMNPQRSTVWY");
+
+ alp_size=strlen(alp);
+
+ B=copy_aln (A,NULL);
+ B=realloc_aln(B, B->len_aln*2+1);
+
+ for ( a=0, b=0; a< A->len_aln; a++, b+=2)
+ {
+ for ( c=0; c< A->nseq; c++)
+ {
+ B->seq_al[c][b]=tolower(A->seq_al[c][a]);
+ B->seq_al[c][b+1]='~';
+ }
+ }
+
+ for ( c=0; c< A->nseq; c++)B->seq_al[c][b]='\0';
+ B->len_aln=A->len_aln*2;
+
+
+
+ tot=n_mut=0;
+ for (a=0; a< B->len_aln; a+=2)
+ for ( b=0; b<B->nseq; b++)
+ {
+ if ( is_gap(B->seq_al[b][a]))continue;
+ mut=((rand()%RAND_MAX)>ratio)?0:1;
+ tot++;
+ n_mut+=mut;
+
+ if (mut)
+ {
+ type=rand()%2;
+ if (type==0)/*deletion*/
+ {
+ B->seq_al[b][a]='.';
+ }
+ else if ( type==1)
+ {
+ B->seq_al[b][a+1]=alp[rand()%alp_size];
+ }
+ else if (type==2)
+ {
+ B->seq_al[b][a]=alp[rand()%alp_size];
+ }
+
+ }
+ }
+ ungap_aln (B);
+
+
+ free_sequence (S, S->nseq);
+ free_aln (A);
+ return B;
+
+}
+
+char* mutate_amino_acid ( char aa, char *mode)
+
+ {
+ int a, b, c, d;
+ char nucleotide[]="agct";
+ char amino_acid[]="acdefghiklmnpqrstvwy";
+ static char **triplet;
+ static char **cw_col;
+ int ng_cw_col;
+ static int **amino_acid_list;
+ static int *lu;
+ char a1, a2;
+ char *mat;
+
+ aa=tolower(aa);
+ declare_name(mat);
+ if ( !mode)sprintf (mat, "clustalw_col");
+ else sprintf (mat, "%s", mode);
+ if (!triplet)
+ {
+ triplet=declare_char ( 64, 4);
+ for (d=0, a=0; a< 4;a++)
+ for ( b=0; b< 4; b++)
+ for ( c=0; c< 4; c++, d++)
+ {
+ triplet[d][0]=nucleotide[a];
+ triplet[d][1]=nucleotide[b];
+ triplet[d][2]=nucleotide[c];
+ }
+ }
+ if ( !cw_col)cw_col=make_group_aa ( &ng_cw_col,mat);
+ if ( !amino_acid_list)
+ {
+ amino_acid_list=declare_int ( 20, 65);
+ for ( a=0; a< 20; a++)
+ for ( b=0; b< 64; b++)
+ {
+ a1=translate_dna_codon ( triplet[b], 'x');
+ a2=amino_acid[a];
+ for ( d=0; d< ng_cw_col; d++)
+ if ( is_in_set ( a1, cw_col[d]) && is_in_set ( a2, cw_col[d]))
+ {
+ amino_acid_list[a][++amino_acid_list[a][0]]=b;
+ }
+ }
+ lu=vcalloc ( 26, sizeof (int));
+ for ( a=0; a<20; a++)
+ {
+ lu[amino_acid[a]-'a']=a;
+ }
+ /*
+ for ( a=0; a< 20; a++)
+ {
+ fprintf ( stderr, "\n%c", amino_acid[a]);
+ for ( b=1; b<=amino_acid_list[a][0]; b++)
+ fprintf ( stderr, "\n\t%s %c", triplet[amino_acid_list[a][b]], translate_dna_codon (triplet[amino_acid_list[a][b]], 'x'));
+ }
+ */
+ }
+
+ return triplet [addrand((unsigned long)amino_acid_list[lu[aa-'a']][0])+1];
+ }
+
+/**************************************************************************************************/
+/******************************** ********************************************/
+/******************************** PROCESSING ********************************************/
+/******************************** ********************************************/
+
+
+
+void modify_data (Sequence_data_struc *D1in, Sequence_data_struc *D2in, Sequence_data_struc *DSTin, char **action_list,int n_actions, Action_data_struc *RAD)
+ {
+ Sequence *COOR=NULL, *NS=NULL,*BUFS=NULL, *OUT_S=NULL;
+ Constraint_list *CL;
+ char *s;
+ int value,upper_value, lower_value, start, end, a, b,c;
+ int *count_table=NULL;
+ char *action;
+ Sequence_data_struc *D1;
+ Sequence_data_struc *D2;
+ Sequence_data_struc *DST;
+ int s1, s2, r1, r2;
+ static int clean_flag;
+ Alignment *BUF;
+
+ /*Switches*/
+
+ action=action_list[0];
+
+ if (action[0]=='2')
+ {
+
+ D1=D2in;
+ D2=D1in;
+ DST=DSTin;
+ action++;
+ }
+ else if ( action[0]=='1')
+ {
+ D1=D1in;
+ D2=D2in;
+ DST=DSTin;
+ action++;
+ }
+ else if ( action[0]=='3')
+ {
+ D1=DSTin;
+ D2=D1in;
+ DST=DSTin;
+ action++;
+ }
+ else
+ {
+ D1=D1in;
+ D2=D2in;
+ DST=DSTin;
+ }
+ if (!D1->A)D1->A=copy_aln (D1in->A, NULL);
+
+ if ( strm(action, "seqnos"))
+ {
+ (D1->A)->output_res_num=1;
+ }
+ else if ( strm (action,"aln2bootstrap"))
+ {
+ (D1->A)=aln2bootstrap (D1->A, ATOI_ACTION (1));
+ D1->S=aln2seq (D1->A);
+ }
+ else if ( strm (action,"aln2sample"))
+ {
+ (D1->A)=aln2sample (D1->A, ATOI_ACTION (1));
+ D1->S=aln2seq (D1->A);
+ }
+ else if ( strm (action,"aln2random_aln"))
+ {
+ (D1->A)=aln2random_aln (D1->A, ACTION (1));
+ D1->S=aln2seq (D1->A);
+ }
+ else if ( strm (action, "or_scan"))
+ {
+ HERE ("OR SCAN");
+ D1->A=or_scan(D1->A, D2->A, ACTION(1));
+ D1->S=aln2seq (D1->A);
+ }
+ else if ( strm (action, "or_sar"))
+ {
+ D1->A=or_sar(D1->A, D2->A, ACTION(1), PRINT);
+ D1->S=aln2seq (D1->A);
+ }
+ else if ( strm ( action, "sar2subsar"))
+ {
+ /*in->sequences
+ in2->sar data
+ */
+ Alignment *subA, *subS;
+
+ if ( n_actions==1)
+ {
+ fprintf ( stderr, "\nin=aln, in2=sar sar2subsar [filter value compound1 compound2...] | [jack1] | [file]\n");
+ myexit (EXIT_FAILURE);
+ }
+
+ sarset2subsarset ( D1->A, D2->A, &subA, &subS, main_read_aln (action_list[2], NULL));
+ D1->A=subA;D2->A=subS;
+ }
+ else if ( strm (action, "display_sar"))
+ {
+ D1->A=display_sar (D1->A, D2->A, action_list[1]);
+ }
+ else if ( strm ( action, "sar2simpred"))
+ {
+ /*in->sequences
+ in2->sar data
+ */
+ sar2simpred ( D1->A, D2->A, action_list[1], action_list[2], atoi(action_list[3]), atoi (action_list[4]));
+ }
+ else if ( strm ( action, "sar2simpred2"))
+ {
+ /*in->sequences
+ in2->sar data
+ */
+ if ( n_actions!=5)
+ {
+ fprintf ( stderr, "\nERROR: +sar2simpred2 seqnamesfile posfile compound limit");
+ myexit (EXIT_FAILURE);
+ }
+ sar2simpred2 ( D1->A, D2->A, action_list[1], action_list[2], action_list[3], atoi (action_list[4]));
+ }
+ else if ( strm ( action, "sar_analyze"))
+ {
+ /*in->sequences
+ in2->sar data
+ */
+ sar_analyze ( D1->A, D2->A,action_list[1]);
+ }
+ else if ( strm ( action, "simple_sar_predict"))
+ {
+ //displays each column with ist score;
+ simple_sar_predict (D1->A, D2->A,ACTION(1));
+ myexit (EXIT_SUCCESS);
+ }
+ else if ( strm ( action, "display_sar_analyze"))
+ {
+ //displays each column with ist score;
+ display_simple_sar_analyze_col (D1->A, D2->A,ACTION(1));
+ myexit (EXIT_SUCCESS);
+ }
+ else if ( strm ( action, "display_sar_analyze_pc"))
+ {
+ //displays each column with ist score;
+ display_simple_sar_analyze_pair_col (D1->A, D2->A,ACTION(1));
+ myexit (EXIT_SUCCESS);
+ }
+ else if ( strm ( action, "weight2sar"))
+ {
+ /*in->sequences
+ in2->sar data
+ */
+ if ( n_actions!=3)
+ {
+ fprintf ( stderr, "\nERROR: +weight2sar <weight_file> <limit>");
+ myexit (EXIT_FAILURE);
+ }
+ D1->A=weight2sar ( D1->A,D2->A, action_list[1], atoi(action_list[2]));
+
+ }
+ else if ( strm ( action, "sar_weight"))
+ {
+ /*in->sequences
+ in2->sar data
+ */
+ if ( n_actions!=3)
+ {
+ fprintf ( stderr, "\nERROR: +sar_weight <sar_analyze> <compound>");
+ myexit (EXIT_FAILURE);
+ }
+ D1->A=aln2weighted_sar_score ( D1->A,D2->A, action_list[1], action_list[2]);
+ D1->S=aln2seq ( D1->A);
+ }
+
+ else if ( strm (action, "name2unique_name"))
+ {
+ char *tmp1, *tmp2;
+ char command[1000];
+ tmp1=vtmpnam (NULL); tmp2=vtmpnam (NULL);
+
+ output_fasta_aln (tmp1,D1->A);
+ free_aln (D1->A);free_sequence (D1->S, -1);
+ sprintf ( command, "fasta_aln2fasta_aln_unique_name.pl %s >%s", tmp1, tmp2);
+ my_system ( command);
+ D1->S=get_fasta_sequence ( tmp2, NULL);
+ D1->A=seq2aln (D1->S,NULL, 1);
+ }
+ else if ( strm (action, "rm_tag") || strm (action, "rm_template"))
+ {
+
+ char **temp_name=NULL,**temp_list=NULL, temp_nseq=0;
+ int z;
+
+ if ( D1 && D1->A){temp_name=(D1->A)->name;temp_nseq=(D1->A)->nseq;}
+ else if ( D1 && D1->S){temp_name=(D1->S)->name;temp_nseq=(D1->S)->nseq;}
+ temp_list=rm_name_tag (temp_name,temp_nseq, NULL);
+ if ( n_actions>1 && strm (action_list[1], "template"))
+ {
+
+ for ( z=0; z<temp_nseq; z++)
+ {
+ if (temp_list[z][0])
+ {fprintf (stdout, "%s\n", temp_list[z]);}
+ }
+ myexit (EXIT_SUCCESS);
+ }
+ }
+ else if (strm (action, "add_template") || strm (action, "swap_header"))
+ {
+ D1->S=seq2template_seq (D1->S, action_list[1], NULL);
+ D1->A=seq2aln(D1->S, NULL, 1);
+ }
+ else if ( strm ( action, "seq2year"))
+ {
+ D1->S=seq2year (D1->S, (n_actions>1)?atoi(action_list[1]):1);
+ D1->A=seq2aln(D1->S, NULL, 1);
+ }
+ else if ( strm (action, "swap_lib_header"))
+ {
+ Sequence *S;
+ S=main_read_seq (action_list[1]);
+ (D1->CL)->S=S;
+
+ }
+ else if ( strm (action, "weight_lib"))
+ {
+ int l;
+ int w;
+ w=atoi (action_list[1]);
+ if ( D1->CL)
+ {
+ int s1, s2,r1,r2;
+ Sequence *S=(D1->CL)->S;
+ int ***r=(D1->CL)->residue_index;
+
+ for (s1=0; s1<S->nseq; s1++)
+ for (r1=1; r1<=S->len[s1]; r1++)
+ for (b=1; b<r[s1][r1][0]; b+=3)
+ {
+ r[s1][r1][b+2]=w;
+ }
+ }
+ }
+ else if ( strm (action, "struc2nb"))
+ {
+ int c;
+ for ( c=0; c< (D1->S)->nseq; c++)
+ {
+ struclist2nb ((D1->S)->name[c],(D1->S)->seq[c], (D1->S)->seq_comment[c], atof(action_list[1]),ACTION(2),ACTION(3) );
+ }
+ myexit (EXIT_SUCCESS);
+ }
+
+
+
+ else if ( strm(action, "seq2contacts"))
+ {
+ int z;
+ D1->S=swap_header (D1->S, D2->S);
+ for ( z=0; z< (D1->S)->nseq; z++)sprintf ( (D1->A)->name[z], "%s", (D1->S)->name[z]);
+ DST->S=seq2contacts (D1->S, atof (action_list[1]));
+ DST->A=copy_aln (D1->A, NULL);
+ thread_seq_struc2aln ( DST->A,DST->S);
+ for (z=0; z< (D1->S)->nseq; z++)
+ (DST->A)->S=D1->S;
+
+ }
+ else if ( strm(action, "struc2contacts"))
+ {
+ char *seq;
+ if ( atof (action_list[3])>0)
+ {
+ seq=map_contacts (action_list[1], action_list[2], atof (action_list[3]));
+ fprintf ( stderr, "\n>%s %s\n%s",action_list[1], action_list[2],seq);
+ }
+ else
+ print_contacts (action_list[1], action_list[2], atof (action_list[3]));
+
+ myexit (EXIT_SUCCESS);
+ }
+ else if ( strm(action, "treelist_prune")|| strm(action, "prune_treelist"))
+ {
+ Sequence *TS;
+ if (D2 && D2->S)TS=D2->S;
+ else TS=treelist2sub_seq((D1->S),ATOI_ACTION(1));
+ treelist2prune_treelist ( D1->S,TS, NULL);
+ D1->A=seq2aln (D1->S, NULL, NO_PAD);
+ }
+ else if ( strm (action, "tree2unresolved_nodes"))
+ {
+ int ns;
+ int *l;
+ ns=tree2nseq (D1->T);
+ l=vcalloc (ns, sizeof (int));
+ tree2nnode_unresolved (D1->T, l);
+ for ( a=0; a<ns; a++)if (l[a])fprintf ( stdout, "SIZE: %d COUNT: %d\n", a, l[a]);
+ vfree (l);
+ myexit (EXIT_SUCCESS);
+ }
+ else if ( strm(action, "tree_prune") || strm(action, "prune_tree"))
+ {
+ D1->T=main_prune_tree ( D1->T, D2->S);
+ }
+ else if ( strm ( action, "tree2seq"))
+ {
+ D1->S=tree2seq(D1->T, NULL);
+ D1->A=seq2aln (D1->S, D1->A, 1);
+ (D1->A)->len_aln=1;
+ for ( a=0; a< (D1->A)->nseq; a++)sprintf ( (D1->A)->seq_al[a], "sequence");
+ }
+ else if ( strm (action, "seq2dpatree"))
+ {
+ D1->T= seq2dpa_tree(D1->S,"ktup");
+ }
+ else if ( strm (action, "tree2dpatree"))
+ {
+ D1->T= tree2dpa_tree(D1->T,(D2 && D2->A)?D2->A:D1->A, (n_actions==1)?"idmat":action_list[1]);
+ }
+ else if ( strm (action, "tree2group"))
+ {
+ vfclose (tree2group (D1->T, (tree2seq(D1->T,NULL)), atoi(action_list[1]), atoi(action_list[2]),(n_actions==4)?action_list[3]:NULL, stdout));
+ myexit (EXIT_SUCCESS);
+ }
+ else if ( strm(action, "unroot"))
+ {
+ D1->T=unroot_tree(D1->T);
+ }
+
+
+ else if ( strm(action, "treelist2group")|| strm(action, "treelist2groups") )
+ {
+ Sequence *TS;
+
+ if (D2 && D2->S)TS=D2->S;
+ else TS=treelist2seq((D1->S));
+ treelist2groups (D1->S, TS, ACTION(1), stdout);
+ myexit (EXIT_SUCCESS);
+
+ // treelist2groups (D1->S,(D2)?D2->S:NULL, ACTION(1), stdout );
+ //exit (EXIT_SUCCESS);
+ }
+ else if ( strm(action, "splits2tree"))
+ {
+
+ D1->T=split2tree ((D2)?D2->T:NULL,D1->S, ACTION(1));
+
+ }
+ else if ( strm(action, "count_splits"))
+ {
+
+ count_splits ((D2)?D2->T:NULL,D1->S, ACTION(1));
+ myexit (EXIT_SUCCESS);
+ }
+ else if ( strm(action, "count_groups"))
+ {
+ count_tree_groups (D1->S, ACTION(1));
+ }
+ else if ( strm (action, "tree2dist"))
+ {
+ int ta, tb, ***td;
+ Sequence *TS;
+
+ TS=(D2)?D2->S:NULL;
+ td=tree2dist (D1->T,TS, NULL);
+ if (!TS)TS=tree2seq(D1->T, NULL);
+ for (ta=0; ta<TS->nseq; ta++)
+ {
+ fprintf ( stdout, "%-15s ",TS->name[ta]);
+ for ( tb=0; tb<TS->nseq; tb++)
+ {
+ int n=0;
+ if ( ACTION(1) && strm (ACTION(1), "length"))n=1;
+
+ fprintf (stdout, " %4d", td [n][ta][tb]);
+ }
+ fprintf ( stdout, "\n");
+ }
+ myexit (EXIT_SUCCESS);
+ }
+ else if ( strm (action, "treelist2lti"))
+ {
+ Sequence *TS;
+ if (D2 && D2->S)TS=D2->S;
+ else TS=treelist2sub_seq((D1->S),ATOI_ACTION(2));
+ treelist2lti (D1->S,TS, (int)ATOI_ACTION(1), stdout );
+ myexit (0);
+ }
+ else if ( strm (action,"treelist2frame"))
+ {
+ Sequence *TS;
+ if (D2 && D2->S)TS=D2->S;
+ else TS=treelist2sub_seq((D1->S),ATOI_ACTION(1));
+ treelist2frame (D1->S, TS);
+ myexit (EXIT_SUCCESS);
+ }
+
+ else if ( strm (action, "treelist2seq"))
+ {
+ D1->S=treelist2sub_seq (D1->S,ATOI_ACTION(1));
+ D1->A=seq2aln(D1->S, NULL, 1);
+ }
+ else if ( strm (action, "treelist2leafgroup"))
+ {
+ treelist2leafgroup (D1->S, (D2)?D2->S:NULL, ACTION(1));
+ myexit (0);
+ }
+ else if ( strm(action, "treelist2splits"))
+ {
+ if (D1->T)D1->S=add_file2file_list ((D1->T)->file, NULL);
+ treelist2splits (D1->S, (D2)?D2->S:NULL);
+ }
+
+ else if ( strm(action, "treelist2dmat"))
+ {
+ treelist2dmat (D1->S);
+ }
+ else if ( strm(action, "tree2node") )
+ {
+ print_node_list ( D1->T,(DST)?DST->S:NULL);
+ myexit (EXIT_SUCCESS);
+ }
+ else if ( strm(action, "tree_cmp_list") )
+ {
+ D1->T=main_compare_trees_list ( D1->T, D2->S, stdout);
+ }
+ else if ( strm(action, "tree_cmp") || strm (action, "tree_compare"))
+ {
+ D1->T=main_compare_trees ( D1->T, D2->T, stdout);
+ }
+ else if ( strm (action, "tree_scan"))
+ {
+ D1->T=tree_scan (D1->A, D2->T, ACTION(1), ACTION(2));
+ }
+ else if ( strm (action, "split_cmp"))
+ {
+ main_compare_splits (D1->T, D2->T, ACTION(1), stdout);
+ }
+
+ else if ( strm(action, "node_sort"))
+ {
+ node_sort ( action_list[1], D1->T);
+ myexit (EXIT_SUCCESS);
+ }
+
+ else if ( strm ( action, "avg_bootstrap"))
+ {
+ display_avg_bootstrap (D1->T);
+ myexit (EXIT_SUCCESS);
+ }
+ else if ( strm (action, "genepred2acc"))
+ {
+ //D2->S=reference
+ //D1->S=prediction
+ vfree (display_accuracy (genepred_seq2accuracy_counts (D2->S, D1->S, NULL),stderr));
+ myexit (EXIT_SUCCESS);
+ }
+ else if ( strm (action, "tree_cog_cmp"))
+ {
+ main_compare_cog_tree (D1->T,action_list[1]);
+ myexit (EXIT_SUCCESS);
+ }
+ else if ( strm (action, "tree_aln_cmp"))
+ {
+ main_compare_aln_tree (D1->T, D2->A, stdout);
+ myexit (EXIT_SUCCESS);
+ }
+ else if ( strm(action, "change_bootstrap"))
+ {
+ D1->T=reset_boot_tree ( D1->T, (n_actions>=2)?atoi(action_list[1]):0);
+ }
+ else if ( strm(action, "change_distances"))
+ {
+ D1->T=reset_dist_tree ( D1->T, (n_actions>=2)?atof(action_list[1]):0.00);
+ }
+
+ else if ( strm(action, "aln2tree"))
+ {
+ D1->T=tree_compute (D1->A, n_actions-1, action_list+1);
+ }
+ else if ( strm(action, "similarities2tree"))
+ {
+ D1->T=similarities_file2tree (ACTION(1));
+ }
+
+ else if ( strm(action, "original_seqnos"))
+ {
+ (D1->A)->output_res_num=2;
+ }
+
+ else if ( strm (action, "aln2pred"))
+ {
+ aln2pred (D1->A, D2->A, ACTION (1));
+ myexit (EXIT_SUCCESS);
+ }
+ else if ( strm(action, "evaluate"))
+ {
+ Alignment *A;
+
+
+ DST->A=copy_aln (D1->A, NULL);
+ DST->S=aln2seq(DST->A);
+ if (n_actions>1 && strm ( action_list[1], "categories"))
+ {
+ CL=declare_constraint_list ( DST->S,NULL, NULL, 0,NULL, read_matrice("pam250mt"));
+ DST->A= main_coffee_evaluate_output(DST->A, CL, "categories");
+ }
+ else if (n_actions>1 && strm ( action_list[1], "sar"))
+ {
+ CL=declare_constraint_list ( DST->S,NULL, NULL, 0,NULL, read_matrice("pam250mt"));
+ DST->A= main_coffee_evaluate_output(DST->A, CL, "sar");
+ }
+ else if (n_actions>1 && strstr ( action_list[1], "boxshade"))
+ {
+ char color_mode[1000];
+ sprintf (color_mode,"boxshade_%d", atoi(ACTION2(2,"30")));
+ CL=declare_constraint_list ( DST->S,NULL, NULL, 0,NULL, read_matrice("pam250mt"));
+ DST->A= main_coffee_evaluate_output(DST->A, CL, color_mode);
+ }
+ else
+ {
+ CL=declare_constraint_list ( DST->S,NULL, NULL, 0,NULL, read_matrice((n_actions==1)?"pam250mt":action_list[1]));
+ DST->A= main_coffee_evaluate_output(DST->A, CL, "matrix");
+ }
+
+ DST->S=aln2seq ( DST->A);
+
+ A=D1->A;
+
+ sprintf ( A->name[A->nseq], "cons");
+ sprintf ( A->seq_al[A->nseq], "%s", aln2cons_seq_mat (A, "idmat"));
+
+ }
+ else if ( strm (action, "sp_evaluate"))
+ {
+ fprintf ( stdout, "SP Score: %.2f", sum_pair ((DST && DST->A)?DST->A:D1->A,ACTION(1),atoi(ACTION2(2,"0")),atoi(ACTION2(3,"0"))));
+ myexit (EXIT_SUCCESS);
+ }
+ else if ( strm (action, "lat_evaluate"))
+ {
+ float score;
+ score=lat_sum_pair ( D1->A, action_list[1]);
+ fprintf ( stdout, "\nLAT_SCORE: %.2f", score);
+ myexit (EXIT_SUCCESS);
+
+ }
+ else if ( strm (action, "add_scale"))
+ {
+ D1->A=aln2scale (D1->A, ACTION(1));
+ }
+ else if ( strm (action, "RNAfold_cmp"))
+ {
+ D1->A=compare_RNA_fold (D1->A, D2->A);
+ }
+ else if ( strm (action, "aln2alifold"))
+ {
+ D1->A=aln2alifold (D1->A);
+ D1->S=aln2seq ( D1->A);
+ }
+
+
+ else if ( strm (action, "add_alifold"))
+ {
+ D1->A=add_alifold2aln (D1->A, (D2)?D2->A:NULL);
+
+ }
+ else if ( strm (action, "alifold2analyze"))
+ {
+ D1->A=alifold2analyze (D1->A, (D2)?D2->A:NULL, ACTION(1));
+ D1->S=aln2seq(D1->A);
+ }
+ else if ( strm (action, "aln2conservation"))
+ {
+ D1->A=aln2conservation ( D1->A, ATOI_ACTION (1), ACTION (2));
+ myexit (EXIT_FAILURE);
+ }
+ else if ( strm (action, "aln2cons"))
+ {
+ char *cons_seq;
+ char *cons_name;
+ cons_name=vcalloc (100, sizeof (char));
+ sprintf(cons_name, "%s", (n_actions<=2)?"Cons":action_list[2]);
+ cons_seq=aln2cons_seq_mat (D1->A, (n_actions==1)?"blosum62mt":action_list[1]);
+ free_aln (D1->A);free_sequence(D1->S, -1);
+ D1->S=fill_sequence_struc (1, &cons_seq, &cons_name);
+ /*keep the gaps*/
+ (D1->S)->len[0]=strlen (cons_seq); sprintf ( (D1->S)->seq[0], "%s", cons_seq);
+ D1->A=seq2aln (D1->S, NULL, KEEP_GAP);
+ vfree (cons_name);vfree (cons_seq);
+ }
+ else if ( strm (action, "seq2filter"))
+ {
+ D1->S=seq2filter ( D1->S, atoi(action_list[1]), atoi(action_list[2]));
+
+ }
+ else if ( strm (action, "aln2resindex"))
+ {
+ //-in: aln, file: ref_seq ref_res target_seq
+ //-in2 target sequences
+ aln2resindex (D1->A, (D2)?D2->A:NULL, stdout);
+ myexit (EXIT_SUCCESS);
+ }
+ else if (strm(action, "keep_name"))
+ {
+ RAD->keep_name=1-RAD->keep_name;
+ }
+ else if (strm(action, "use_consensus") ||strm(action, "use_cons") )
+ {
+ RAD->use_consensus=1-RAD->use_consensus;
+ }
+ else if ( strm(action, "ungap"))
+ {
+ seq2aln (D1->S, D1->A, 1);
+ }
+ else if ( strm2(action, "rmgap", "rm_gap"))
+ {
+
+ ungap_aln_n (D1->A, (n_actions==1)?100:atoi(action_list[1]));
+ //free_sequence ( D1->S, (D1->S)->nseq);
+ D1->S=aln2seq ( D1->A);
+ (D1->A)->S=D1->S;
+ }
+ else if ( strm(action, "rmgap_col"))
+ {
+ D1->A=remove_gap_column ( D1->A,action_list[1]);
+ }
+ else if ( strm(action,"random"))
+ {
+
+ D1->A= make_random_aln(NULL,(n_actions==1)?1:atoi(action_list[1]),(n_actions==2)?100:atoi(action_list[2]),"acdefghiklmnpqrstvwy");
+
+ D1->S=aln2seq ( D1->A);
+ }
+
+ else if ( strm(action, "landscape"))
+ {
+
+ set_landscape_msa ((n_actions==1)?0:atoi(action_list[1]));
+ }
+ else if ( strm(action, "clean_maln"))
+ {
+ if ( !DST)
+ {
+ fprintf ( stderr,"\n[You Need an evaluation File: Change the output format][FATAL:%s]\n", PROGRAM);
+ myexit(EXIT_FAILURE);
+ }
+ (DST->A)=aln2number (DST->A);
+ D1->A=clean_maln(D1->A, DST->A,(n_actions==1)?1:atoi(action_list[1]),(n_actions==1)?1:atoi(action_list[2]));
+ }
+ else if ( strm (action, "extract"))
+ {
+
+ COOR=get_pir_sequence (RAD->coor_file, NULL);
+ D1->S=extract_sub_seq ( COOR, D1->S);
+ free_aln (D1->A);
+ D1->A=declare_Alignment(D1->S);
+ seq2aln (D1->S, D1->A, RAD->rm_gap);
+ free_sequence (COOR, COOR->nseq);
+ }
+ else if ( strm (action, "reorder_column"))
+ {
+
+
+
+ Alignment *RO1, *RO2;
+ Sequence *OUT_S;
+ int s;
+
+ RO1=rotate_aln (D1->A,NULL);
+ if (ACTION(1) && strm (ACTION(1), "tree"))
+ {
+ D1->T=tree_compute (RO1,n_actions-2, action_list+2);
+ OUT_S=tree2seq(D1->T, NULL);
+ RO1=reorder_aln(RO1, OUT_S->name, OUT_S->nseq);
+ }
+ else if ( ACTION(1) && strm (ACTION(1), "random"))
+ {
+ RO1=reorder_aln ( RO1, NULL, RO1->nseq);
+ }
+
+ RO2=rotate_aln (RO1, NULL);
+ for (s=0; s< RO2->nseq; s++)
+ sprintf ( RO2->name[s], "%s", (D1->A)->name[s]);
+ free_aln (RO1);
+ free_aln (D1->A);
+ D1->A=RO2;
+ D1->S=aln2seq(D1->A);
+ }
+
+ else if ( strm (action, "reorder"))
+ {
+
+ if ( n_actions==2 && strm (action_list[1], "random"))
+ {
+ D1->A=reorder_aln ( D1->A, NULL, (D1->A)->nseq);
+ }
+ else if (n_actions==2 && strm (action_list[1], "invert"))
+ {
+ char **nname;
+ int z, y;
+
+ nname=declare_char ((D1->A)->nseq, 100);
+ for ( z=0,y=(D1->A)->nseq-1; z<(D1->A)->nseq; z++, y--)
+ {
+ sprintf (nname[z], "%s",(D1->A)->name[y]);
+ }
+
+ D1->A=reorder_aln ( D1->A, nname, (D1->A)->nseq);
+ free_char (nname, -1);
+ }
+ else if (n_actions==2 && strm (action_list[1], "scramble"))
+ {
+ D1->A=aln2scramble_seq(D1->A);
+ }
+
+ else if ( n_actions==2 && strm (action_list[1], "tree"))
+ {
+
+ OUT_S=tree2seq (D2->T, NULL);
+ D1->A=reorder_aln(D1->A, OUT_S->name, OUT_S->nseq);
+ free_sequence (D1->S,(D1->S)->nseq);
+ D1->S=aln2seq (D1->A);
+ }
+ else
+ {
+ (D2->A)->S=aln2seq (D2->A);
+ (D1->A)->S=aln2seq (D1->A);
+ OUT_S=trim_aln_seq_name(D2->A, D1->A);
+ D1->A=reorder_aln(D1->A, OUT_S->name, OUT_S->nseq);
+ free_sequence (D1->S,(D1->S)->nseq);
+ D1->S=aln2seq (D1->A);
+ }
+ }
+ else if ( strm (action, "aln2replicate"))
+ {
+ aln2N_replicate (D1->A, ACTION(1), ACTION(2));
+ }
+ else if ( strm (action, "paralogous_cat"))
+ {
+ D1->A=orthologous_concatenate_aln (D1->A,D2->S, ACTION (1));
+ }
+
+ else if ( strm (action, "cat_aln"))
+ {
+ /*D1->A=aln_cat ( D1->A, D2 ->A);*/
+
+ if (D2 && D2->A && !ACTION(1))
+ D1->A=concatenate_aln (D1->A, D2->A, ACTION(1));
+ else if (ACTION(1) && is_aln(ACTION(1)))
+ {
+ Alignment *B;
+ int n=1;
+
+ while (ACTION(n))
+ {
+
+ B=main_read_aln (ACTION(n), NULL);
+ D1->A=concatenate_aln (D1->A, B, NULL);
+ n++;
+ }
+ D1->S=aln2seq(D1->A);
+ }
+
+ else
+ {
+ Alignment *A, *B;
+
+ A=main_read_aln ((D1->A)->name[0], NULL);
+
+ for ( a=1; a<(D1->A)->nseq; a++)
+ {
+ B=main_read_aln ((D1->A)->name[a], NULL);
+ A=concatenate_aln (A, B, ACTION(1));
+
+ }
+ D1->A=A;
+ D1->S=aln2seq(D1->A);
+ }
+ }
+
+ else if ( strm ( action, "msalist2cat_pwaln"))
+ {
+ int a, b, c;
+ int sim, min, max;
+
+ if (n_actions!=3)
+ {
+ min=0;
+ max=100;
+ }
+ else
+ {
+ min=atoi(action_list[1]);
+ max=atoi(action_list[2]);
+ }
+
+ fprintf ( stdout, ">A\n");
+ for (a=0;a<(D1->S)->nseq; a++)
+ {
+ Alignment *A;
+ HERE ("process %s", (D1->S)->name[a]);
+ A=main_read_aln((D1->S)->name[a],NULL);
+ for (b=0; b<A->nseq-1; b++)
+ {
+ for ( c=b+1; c<A->nseq; c++)
+ {
+ sim=get_seq_sim (A->seq_al[b], A->seq_al[c], "-", "");
+ if (sim>=min && sim<=max)fprintf (stdout, "xxx%s", A->seq_al[b]);
+ }
+ }
+ free_aln (A);
+ }
+ fprintf ( stdout, "\n>B\n");
+ for (a=0;a<(D1->S)->nseq; a++)
+ {
+ Alignment *A;
+ HERE ("process %s", (D1->S)->name[a]);
+ A=main_read_aln((D1->S)->name[a],NULL);
+ for (b=0; b<A->nseq-1; b++)
+ {
+ for ( c=b+1; c<A->nseq; c++)
+ {
+ sim=get_seq_sim (A->seq_al[b], A->seq_al[c], "-", "");
+ if (sim>=min && sim<=max)fprintf (stdout, "xxx%s", A->seq_al[c]);
+ }
+ }
+ free_aln (A);
+ }
+
+ fprintf ( stdout, "\n");
+ myexit (EXIT_SUCCESS);
+ }
+
+ else if ( strm (action, "collapse_tree"))
+ {
+ D1->T=tree2collapsed_tree (D1->T, n_actions-1, action_list+1);
+ }
+ else if ( strm (action, "collapse_aln"))
+ {
+ D1->A=aln2collapsed_aln (D1->A, n_actions-1, action_list+1);
+ }
+ else if ( strm (action, "extract_aln"))
+ {
+ D1->A=aln2sub_aln_file (D1->A, n_actions-1, action_list+1);
+ myexit (EXIT_SUCCESS);
+ }
+
+
+
+ else if ( strm (action, "remove_aa"))
+ {
+ int pos,len, n;
+ pos=atoi(action_list[1]);
+ len=atoi(action_list[2]);
+ n=atoi (action_list[3]);
+ if ( atoi (action_list[4])==1)len=-len;
+ if (pos && n>1)
+ {
+ fprintf ( stderr, "\nWARNING: rm_aa, position (pos) and iteration number (n) simulatneously defined. Iteration number reset to 1 [%s]\n", PROGRAM);
+ n=1;
+ }
+ for ( a=0; a< n; a++)
+ D1->A=probabilistic_rm_aa (D1->A, pos, len);
+ }
+ else if ( strm (action, "remove_nuc"))
+ {
+ int pos;
+ pos=atoi(action_list[1]);
+
+ if ( pos>3 || pos<1)
+ printf_exit (EXIT_FAILURE, stderr, "Remove_nuc: indicate a number between 1 and 3\n");
+
+ pos--;
+ for ( c=0,a=0; a<(D1->A)->len_aln; a++, c++)
+ {
+ if (c==3)c=0;
+ for (b=0; b<(D1->A)->nseq; b++)
+ {
+ if (c==pos)
+ {
+ (D1->A)->seq_al[b][a]='-';
+ }
+ }
+ }
+
+ D1->S=aln2seq (D1->A);
+ }
+
+ else if (strm ( action, "conserved_positions"))
+ {
+ Alignment *A;
+ int a, b, c;
+ int *cache=NULL;
+
+
+ A=D1->A;
+ for ( a=0; a< A->nseq && !cache; a++)
+ {
+ if ( strm (action_list[1], A->name[a]))
+ {
+ cache=vcalloc ( A->len_aln+1, sizeof (int));
+ for ( c=0,b=0; b<A->len_aln; b++)
+ {
+ if ( is_gap (A->seq_al[a][b]))cache[b]=-1;
+ else cache[b]=++c;
+ }
+ }
+ }
+
+ for ( a=0; a< A->len_aln; a++)
+ {
+ r1=A->seq_al[0][a];
+ if ( is_gap(r1))continue;
+ for ( c=0,b=0; b<A->nseq; b++)
+ {
+ r2=A->seq_al[b][a];
+ c+=(r1==r2)?1:0;
+ }
+ if ( (c*100)/A->nseq>=atoi(action_list[2]))
+ fprintf ( stdout, "COL: %d Res: %c %s %d\n", a+1, r1, action_list[1], cache[a]+atoi(action_list[3]));
+ }
+ myexit (EXIT_FAILURE);
+ }
+ else if (strm ( action, "extract_block") )
+ {
+
+ BUF=copy_aln (D1->A, NULL);
+ if ( check_file_exists(action_list[1]))
+ BUF=extract_aln3(BUF,action_list[1]);
+ else
+ BUF=extract_aln2(BUF,atoi(action_list[2]),atoi(action_list[3]),action_list[1]);
+ D1->A=copy_aln (BUF,D1->A);
+
+ }
+ else if ( strm ( action, "extract_pos_list"))
+ {
+ D1->A=alnpos_list2block (D1->A, n_actions-1, action_list+1);
+ }
+ else if ( strm ( action, "seq2msa"))
+ {
+ D1->A=simple_progressive_aln ( D1->S, NULL, NULL, action_list[1]);
+ }
+ else if ( strm ( action, "realign_block") )
+ {
+ D1->A=realign_block ( D1->A, atoi (action_list[1]), atoi (action_list[2]), (n_actions==4)?action_list[3]:NULL);
+ }
+ else if ( strm (action, "extract_seq"))
+ {
+ int is_file;
+ if ( check_file_exists (action_list[1])&& format_is_fasta (action_list[1]))
+ {
+ is_file=1;
+ BUFS=main_read_seq (action_list[1]);
+ action_list=BUFS->name;
+ n_actions=BUFS->nseq;
+ }
+ else
+ {
+ is_file=0;
+ action_list++;
+ n_actions--;
+ }
+
+ for ( a=0; a< n_actions;)
+ {
+ s=action_list[a];
+
+ if ( n_actions==1 || is_file==1)
+ {
+ start=1;
+ end=0;
+ a+=1;
+ }
+ else
+ {
+
+ start=(strm2 (s,"#","*"))?1:(atoi(action_list[a+1]));
+ end= (strm2 (action_list[a+2],"#","*"))?0:(atoi(action_list[a+2]));
+ a+=3;
+ }
+
+ if ( strm2 (s, "#", "*"))
+ {
+ OUT_S=extract_one_seq((D1->A)->name[0],start, end, D1->A, RAD->keep_name);
+ for (b=1; b< (D1->A)->nseq; b++)
+ {
+ NS=extract_one_seq((D1->A)->name[b],start, end, D1->A, RAD->keep_name);
+ if (count_n_res_in_array(NS->seq[0], -1))
+ OUT_S=add_sequence ( NS,OUT_S, 0);
+ }
+ }
+ else
+ {
+ if ( a==1)OUT_S=extract_one_seq(s,start, end, D1->A, RAD->keep_name);
+ else
+ {
+ NS=extract_one_seq(s,start, end, D1->A, RAD->keep_name);
+ OUT_S=add_sequence ( NS,OUT_S, 0);
+ }
+ }
+ }
+ D1->S=OUT_S;
+ free_aln (D1->A);
+ D1->A=declare_Alignment(D1->S);
+ seq2aln (D1->S, D1->A, RAD->rm_gap);
+ }
+
+ else if ( strm (action, "extract_seq_list"))
+ {
+ if ( check_file_exists (action_list[1]) && format_is_fasta (action_list[1]))
+ {
+
+ BUFS=main_read_seq (action_list[1]);
+ action_list=BUFS->name;
+ n_actions=BUFS->nseq;
+ }
+ else
+ {
+ action_list++;
+ n_actions--;
+ }
+
+ for ( a=0; a< n_actions;a++)
+ {
+
+ NS=extract_one_seq(action_list[a],1,0, D1->A, KEEP_NAME);
+ OUT_S=add_sequence ( NS,OUT_S, 0);
+
+ }
+
+ D1->S=OUT_S;
+ free_aln (D1->A);
+ D1->A=declare_Alignment(D1->S);
+ seq2aln (D1->S, D1->A, RAD->rm_gap);
+ }
+ else if ( strm (action, "remove_seq") || strm (action, "rm_seq"))
+ {
+ char *buf;
+ char **list;
+ int n;
+ int l;
+
+ list=declare_char ((D1->S)->nseq, 200);
+
+ buf=vcalloc ((D1->S)->max_len+1, sizeof (char));
+ for ( n=0,a=0; a< (D1->A)->nseq; a++)
+ {
+
+ sprintf (buf, "%s", (D1->S)->seq[a]);
+ ungap (buf);
+ l=strlen(buf);
+
+ for (c=1, b=1; b< n_actions; b++)
+ {
+ if ( strm (action_list[b], (D1->S)->name[a])){(D1->S)->seq[a]=NULL;break;}
+ else if ( strm (action_list[b], "empty") && l==0)
+ {
+ fprintf ( stderr, "WARNING: Sequence %s does not contain any residue: automatically removed from the set [WARNING:%s]\n",(D1->S)->name[a], PROGRAM);
+ (D1->S)->seq[a]=NULL;break;
+ }
+ else if ( strm (action_list[b], "unique"))
+ {
+ if ( name_is_in_list ((D1->S)->name[a], list,n, 100)!=-1)
+ {
+ (D1->S)->seq[a]=NULL;break;
+ }
+ else
+ {
+ sprintf ( list[n++], "%s", (D1->S)->name[a]);
+ }
+ }
+ }
+ }
+ D1->S=duplicate_sequence (D1->S);
+ free_aln (D1->A);
+ free_char ( list, -1);
+ D1->A=declare_Alignment(D1->S);
+ seq2aln (D1->S, D1->A, RAD->rm_gap);
+ }
+
+ else if ( strm (action, "aln2overaln")|| strm (action,"overaln_param"))
+ {
+ //mode (lower|number|uanlign) Penalty (0-100) Thresold (0-9)
+ int p1,p2,p3,f, t;
+ char *s;
+ int eb=0;
+ char clean_mode[100];
+ OveralnP *F;
+
+ F=vcalloc (1, sizeof (OveralnP));
+ if ( D2 && D2->A)
+ {
+ D1->A=mark_exon_boundaries (D1->A, D2->A);
+ eb=1;
+ }
+ else if ( (s=get_string_variable ("exon_boundaries")))
+ {
+ Sequence *S;
+ Alignment *EB;
+ EB=seq2aln(S=main_read_seq(s),NULL, 0);
+ D1->A=mark_exon_boundaries (D1->A, EB);
+ free_sequence (S, S->nseq); free_aln (EB);
+ eb=1;
+ }
+
+
+ if (ACTION(1)==NULL)sprintf (F->mode, "lower");
+ else if (strstr (ACTION(1), "h"))
+ {
+ fprintf ( stdout, "aln2unalign lower|number|unalign|uanlign2 F P1 P2 P3 T\n");
+ myexit (EXIT_SUCCESS);
+ }
+ else sprintf (F->mode, "%s", ACTION(1));
+
+ F->t=ATOI_ACTION(2);
+ F->f=ATOI_ACTION(3);
+ F->p1=ATOI_ACTION(4);
+ F->p2=ATOI_ACTION(5);
+ F->p3=ATOI_ACTION(6);
+ F->p3=ATOI_ACTION(7);
+
+ if (int_variable_isset ("overaln_target"))f=get_int_variable ("overaln_target");
+ if (int_variable_isset ("overaln_threshold"))t=get_int_variable ("overaln_threshold");
+ if (eb)sprintf (F->model, "fsa2");
+ else sprintf (F->model, "fsa1");
+
+ D1->A=aln2clean_pw_aln (D1->A, F);
+
+ }
+ else if ( strm (action, "unalign_groups"))
+ {
+ //unalign everything in lower case
+ unalign_aln_2 (D1->A, NULL, 0);
+ }
+ else if ( strm (action,"aln2unalign"))
+ {
+ Alignment *SA;
+ Sequence *SS;
+ SA=copy_aln (D1->A, NULL);
+ SS=aln2seq(SA);
+
+ thread_seq_struc2aln (SA, SS);
+ D1->A=unalign_aln (D1->A,SA, ATOI_ACTION(1));
+ D1->S=aln2seq ( D1->A);
+ }
+ else if ( strm (action, "clean_cdna"))
+ {
+ Alignment *A;
+ A=D1->A;
+ for (a=0; a< A->nseq; a++)
+ {
+ char *d, *buf, f;
+
+ d=A->seq_al[a];
+ f=get_longest_frame (d, 3);
+ buf=vcalloc ( strlen (d)+1, sizeof (char));
+ sprintf (buf, "%s", d+f);
+ sprintf (d, "%s", buf);
+ vfree (buf);
+ }
+ }
+ else if ( strm (action, "clean_cdna2"))
+ {
+ D1->A=clean_cdna_aln ( D1->A);
+ free_sequence ( D1->S, (D1->S)->nseq);
+ D1->S=aln2seq ( D1->A);
+ }
+ else if ( strm (action, "aln2short_aln"))
+ {
+ D1->A=aln2short_aln (D1->A, action_list[1], action_list[2], atoi(action_list[3]));
+ free_sequence ( D1->S, (D1->S)->nseq);
+ D1->S=aln2seq ( D1->A);
+ }
+ else if ( strm ( action, "complement"))
+ {
+ D1->A=complement_aln (D1->A);
+ free_sequence ( D1->S, (D1->S)->nseq);
+ D1->S=aln2seq ( D1->A);
+ }
+ else if ( strm ( action, "extend"))
+ {
+ extend_seqaln( NULL,D1->A);
+ free_sequence ( D1->S, (D1->S)->nseq);
+ D1->S=aln2seq ( D1->A);
+ }
+ else if ( strm ( action, "unextend"))
+ {
+ unextend_seqaln( NULL,D1->A);
+ free_sequence ( D1->S, (D1->S)->nseq);
+ D1->S=aln2seq ( D1->A);
+ }
+ else if ( strm ( action, "translate"))
+ {
+ D1->A=translate_dna_aln( D1->A,(n_actions==1)?0:atoi(action_list[1]));
+ free_sequence ( D1->S, (D1->S)->nseq);
+ D1->S=aln2seq ( D1->A);
+ }
+ else if (strm2 ( action, "back_translate","backtranslate"))
+ {
+ D1->A=back_translate_dna_aln( D1->A);
+ free_sequence ( D1->S, (D1->S)->nseq);
+ D1->S=aln2seq ( D1->A);
+ }
+ else if (strm ( action, "rotate"))
+ {
+ D1->A=rotate_aln( D1->A, action_list[1]);
+ free_sequence ( D1->S, (D1->S)->nseq);
+ D1->S=aln2seq ( D1->A);
+ }
+ else if (strm ( action, "invert"))
+ {
+ D1->A=invert_aln( D1->A);
+ free_sequence ( D1->S, (D1->S)->nseq);
+ D1->S=aln2seq ( D1->A);
+ }
+ else if (strm ( action, "test_dna2gene"))
+ {
+ testdna2gene ((D1->S)->seq[0]);
+ }
+ else if (strm ( action, "code_dna_aln"))
+ {
+ D1->A=code_dna_aln( D1->A);
+ free_sequence ( D1->S, (D1->S)->nseq);
+ D1->S=aln2seq ( D1->A);
+ }
+
+ else if ( strm ( action, "mutate"))
+ {
+ D1->A=mutate_aln( D1->A,(n_actions==1)?"0":action_list[1]);
+ free_sequence ( D1->S, (D1->S)->nseq);
+ D1->S=aln2seq (D1->A);
+ }
+ else if ( strm ( action, "thread_profile_on_msa"))
+ {
+ (D1->A)->S=NULL;
+ D1->A=thread_profile_files2aln (D1->A, action_list[1], NULL);
+ D1->S=aln2seq(D1->A);
+ }
+ else if ( strm ( action, "thread_dna_on_prot_aln"))
+ {
+ D1->A=thread_dnaseq_on_prot_aln (D1->S, D2->A);
+ free_sequence (D1->S,(D1->S)->nseq);
+ D1->S=aln2seq (D1->A);
+ }
+ else if ( strm ( action, "thread_struc_on_aln"))
+ {
+ thread_seq_struc2aln ( D2->A, D1->S);
+ D1->A=copy_aln(D2->A, D1->A);
+ free_sequence ( D1->S, (D1->S)->nseq);
+ D1->S=aln2seq (D1->A);
+ }
+ else if ( strm (action, "sim_filter"))
+ {
+ D1->A=sim_filter (D1->A, action_list[1], ACTION (2));
+ free_sequence (D1->S,(D1->S)->nseq);
+ D1->S=aln2seq (D1->A);
+ }
+ else if ( strm (action, "seq2blast"))
+ {
+ D1->A=seq2blast (D1->S);
+ free_sequence (D1->S,(D1->S)->nseq);
+ D1->S=aln2seq (D1->A);
+ }
+
+ else if ( strm (action, "trim"))
+ {
+ D1->A=simple_trimseq (D1->A,(D2)?D2->A:NULL, action_list[1], ACTION (2), NULL);
+
+ free_sequence (D1->S,(D1->S)->nseq);
+ D1->S=aln2seq (D1->A);
+ }
+
+ else if (strm ( action, "trimTC"))
+ {
+ value=(n_actions==1)?10:atoi(action_list[1]);
+
+ D1->A=tc_trimseq(D1->A,D1->S,action_list[1]);
+ free_sequence (D1->S,(D1->S)->nseq);
+ D1->S=aln2seq (D1->A);
+ }
+ else if (strm ( action, "trimTC2"))
+ {
+ char *group_file;
+ Alignment *B=NULL;
+ char trim_mode[100];
+ if ( n_actions==1 || !(strm (action_list[1], "NSEQ") ||strm (action_list[1], "MINID")) )
+ {
+ fprintf ( stderr, "\nTrimTC2 <NSEQ | MINID> <number sequences| minimum identity> (<matrix>)\n");
+ myexit (EXIT_FAILURE);
+ }
+ sprintf (trim_mode, "%s", action_list[1]);action_list+=2; n_actions-=2;
+
+ if ( strm ( trim_mode, "NSEQ"))
+ {
+ group_file=tree2Ngroup( (D1)?D1->A:NULL, (D2)?D2->T:NULL, atoi (action_list[0]), vtmpnam(NULL), (n_actions==1)?"idmat":action_list[1]);
+ }
+ else
+ {
+ group_file=tree2Ngroup( (D1)?D1->A:NULL, (D2)?D2->T:NULL, -1*atoi (action_list[0]), vtmpnam(NULL), (n_actions==1)?"idmat":action_list[1]);
+ }
+
+ B=copy_aln (D1->A, B);
+ B=aln2sub_aln_file (B,1,&group_file);
+ B=aln2sub_seq (B, 1, &group_file);
+ D1->A=extract_sub_aln2 (D1->A, B->nseq, B->name);
+ }
+ else if ( strm (action, "chain"))
+ {
+ D1->A=seq2seq_chain (D1->A,D2->A, ACTION(2));
+ }
+
+
+ else if (strm ( action, "master_trim"))
+ {
+ value=(n_actions==1)?10:atoi(action_list[1]);
+
+ D1->A=master_trimseq(D1->A,D1->S,action_list[1]);
+ free_sequence (D1->S,(D1->S)->nseq);
+ D1->S=aln2seq (D1->A);
+ }
+ else if ( strm (action, "force_aln"))
+ {
+ char ***rlist=NULL;
+ int count=0;
+
+ if ( n_actions==2)
+ {
+ if (!is_lib_02(action_list[1]))
+ {
+ fprintf ( stderr, "\nERROR: force_aln requires files in TC_LIB_FORMAT_02 [FATAL:%s]", PROGRAM);
+ myexit (EXIT_FAILURE);
+ }
+ else
+ rlist=file2list (action_list[1], " ");
+ }
+ else
+ {
+ rlist=declare_arrayN(3, sizeof (char),3,7, 10);
+
+ strcat (rlist[1][1],action_list[1]);strcat (rlist[1][3],action_list[2]);
+ strcat (rlist[1][4],action_list[3]);strcat (rlist[1][6],action_list[4]);
+ sprintf ( rlist[2][0], "-1");
+ }
+ count=1;
+ while (rlist[count] && atoi(rlist[count][0])!=-1)
+ {
+ char st1[100], st2[100], st3[100], st4[100];
+
+ sprintf ( st1, "%s", rlist[count][1]);sprintf ( st2, "%s", rlist[count][3]);
+ sprintf ( st3, "%s", rlist[count][4]);sprintf ( st4, "%s", rlist[count][6]);
+ fprintf ( stderr, "\nFORCE: %s %s %s %s", st1, st2, st3, st4);
+
+ if (is_number (st1))s1=atoi (st1)-1;
+ else s1=name_is_in_list (st1,(D1->A)->name, (D1->A)->nseq, 100);
+ if ( s1<0 || s1>= (D1->A)->nseq)crash ("wrong sequence index");
+ r1=atoi (st2)-1;
+
+ if (is_number (st3))s2=atoi (st3)-1;
+ else s2=name_is_in_list (st3,(D1->A)->name, (D1->A)->nseq, 100);
+ if ( s2<0 || s2>= (D1->A)->nseq)crash ("wrong sequence index");
+ r2=atoi (st4)-1;
+
+ (D1->A)=add_constraint2aln ((D1->A), s1, r1, s2, r2);
+ count++;
+ }
+ fprintf ( stderr, "\n");
+ free_arrayN((void*)rlist,3);
+ }
+
+ else if (strm ( action, "grep"))
+ {
+ D1->A=grep_seq (D1->A, ACTION(1),ACTION(2), ACTION(3));
+ if (D1->A==NULL) myexit (EXIT_SUCCESS);
+ else D1->S=aln2seq (D1->A);
+ }
+
+ else if (strm (action, "find"))
+ {
+ int r, l;
+ char *search_string;
+
+ search_string=vcalloc ( 30, sizeof (char));
+ if ( strm (action_list[1], "lower"))sprintf ( search_string, "abcdefghijklmnopqrstuvwxyz");
+ else if ( strm ( action_list[1], "upper"))sprintf ( search_string, "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
+ else
+ {
+ vfree (search_string);search_string=vcalloc ( strlen (action_list[1])+1, sizeof (char));
+ sprintf (search_string, "%s", action_list[1]);
+ }
+
+ for (a=0; a<(D1->A)->nseq; a++)
+ for ( l=0,b=0; b< (D1->A)->len_aln; b++)
+ {
+ r=(D1->A)->seq_al[a][b];
+ l+=!is_gap(r);
+ if ( r!='\0' && strrchr (search_string, r))
+ {
+ /*fprintf ( stdout, "%-15s res %c alnpos %4d seqpos %4d\n", (D1->A)->name[a], r, b+1, l);*/
+ fprintf ( stdout, "%s %d %d\n", (D1->A)->name[a], l, l+1);
+ }
+ }
+ myexit (EXIT_SUCCESS);
+ }
+ else if ( strm (action, "merge_annotation"))
+ {
+ D1->A=merge_annotation (D1->A, DST?DST->A:NULL, ACTION(1));
+ D1->S=aln2seq (D1->A);
+ }
+ else if ( strm (action, "color_residue"))
+ {
+ int i;
+ Alignment *A;
+ A=D1->A;
+
+ DST->A=copy_aln (D1->A, NULL);
+ DST->S=aln2seq (DST->A);
+ for (a=0; a< (DST->S)->nseq; a++)ungap ((DST->S)->seq[a]);
+
+ if (n_actions>2)
+ {
+ for (a=1; a<n_actions; a+=3)
+ {
+ i=name_is_in_list(action_list[a], (D1->A)->name, (D1->A)->nseq, 100);
+ if (i!=-1)
+ {
+ (DST->S)->seq[i][atoi(action_list[a+1])-1]='0'+atoi(action_list[a+2])-1;
+ }
+ else fprintf (stderr, "\nWARNING: Could not find Sequence %s", action_list[a]);
+ }
+ }
+ else
+ {
+ char name[1000];
+ int pos, val;
+ FILE *fp;
+
+ fp=vfopen (action_list[1], "r");
+ while (fscanf (fp, "%s %d %d\n", name, &pos, &val)==3)
+ {
+
+ i=name_is_in_list(name, (D1->A)->name, (D1->A)->nseq, 100);
+ if (i!=-1)(DST->S)->seq[i][pos-1]='0'+val;
+ else fprintf (stderr, "\nWARNING: Could not find Sequence %s", action_list[a]);
+ }
+ vfclose (fp);
+ }
+ DST->A=seq2aln (DST->S, NULL, 1);
+ }
+ else if ( strm (action, "edit_residue"))
+ {
+ FILE *fp;
+ int i, pos;
+ int **p;
+ char mod[100], name[100];
+ Alignment *A;
+
+ A=D1->A;
+
+ p=aln2inv_pos (A);
+ if (n_actions>2)
+ {
+ for (a=1; a<n_actions; a+=3)
+ {
+
+ i=name_is_in_list(action_list[a], (D1->A)->name, (D1->A)->nseq, 100);
+ if (i!=-1)
+ {
+ pos=atoi(action_list[a+1]);
+
+ pos=p[i][pos]-1;
+ sprintf (mod, "%s", action_list[a+2]);
+ if ( strm (mod, "upper"))(D1->A)->seq_al[i][pos]=toupper((D1->A)->seq_al[i][pos]);
+ else if ( strm (mod, "lower"))(D1->A)->seq_al[i][pos]=tolower((D1->A)->seq_al[i][pos]);
+ else (D1->A)->seq_al[i][pos]=mod[0];
+ }
+ else fprintf (stderr, "\nWARNING: Could not find Sequence %s", action_list[a]);
+
+ }
+ }
+ else
+ {
+ fp=vfopen (action_list[1], "r");
+ while (fscanf (fp, "%s %d %s\n", name, &pos, mod)==3)
+ {
+
+ i=name_is_in_list(name, (D1->A)->name, (D1->A)->nseq, 100);
+ if (i!=-1)
+ {
+ pos=p[i][pos]-1;
+ if ( strm (mod, "upper"))(D1->A)->seq_al[i][pos]=toupper(A->seq_al[i][pos]);
+ else if ( strm (mod, "lower"))A->seq_al[i][pos]=tolower(A->seq_al[i][pos]);
+ else A->seq_al[i][pos]=mod[0];
+ }
+ else fprintf(stderr, "\nWARNING: Could not find Sequence %s", action_list[1]);
+ }
+ vfclose (fp);
+ }
+ D1->S=aln2seq (D1->A);
+ }
+ else if ( strm (action, "clean_flag"))
+ {
+ clean_flag=1-clean_flag;
+ }
+ else if ( strm (action, "aln2case"))
+ {
+ D1->A=aln2case_aln (D1->A, ACTION(1), ACTION(2));
+ D1->S=aln2seq(D1->A);
+ }
+
+ else if ( strm5 (action, "convert","upper","lower", "keep", "switchcase"))
+ {
+ b=1;
+
+ if ( n_actions>1 && is_number (action_list[b]))
+ {
+ lower_value=upper_value=atoi(action_list[b++]);
+ }
+ else if ( n_actions>1 && strm (action_list[b], "gap"))
+ {
+ DST=vcalloc (1,sizeof(Sequence_data_struc));
+ DST->A=aln2gap_cache (D1->A,0);
+ lower_value=0;
+ upper_value=0;
+ b++;
+ }
+ else if (n_actions>1 && action_list[b] && action_list[b][0]=='[')
+
+ {
+ lower_value=atoi(strtok (action_list[b]+1, "-[]"));
+ upper_value=atoi(strtok (NULL, "-[]"));
+
+ b++;
+ }
+ else
+ {
+ lower_value=upper_value=-1;
+ }
+
+ if ( n_actions >b ||strm (action, "keep") )
+ {
+ if ( !RAD->symbol_list)RAD->symbol_list=declare_char (STRING, STRING);
+ RAD->n_symbol=0;
+ if ( strm (action, "keep") )sprintf ( RAD->symbol_list[RAD->n_symbol++], "#-");
+ else
+ {
+ for (a=b; a< n_actions; a++)
+ {
+ sprintf ( RAD->symbol_list[RAD->n_symbol], "%s", action_list[a]);
+ RAD->n_symbol++;
+ }
+ }
+ }
+
+ for ( value=0; value<=9; value++)
+ {
+ if ( lower_value==-1)value=-1;
+
+ if ( (value>=lower_value && value<=upper_value)|| value==-1)
+ {
+ if (strm(action,"convert")) D1->A=filter_aln_convert (D1->A, DST?DST->A:NULL,RAD->use_consensus,value,RAD->n_symbol, RAD->symbol_list);
+ else if (strm(action,"upper"))D1->A=filter_aln_lower_upper (D1->A, DST?DST->A:NULL,RAD->use_consensus,value);
+ else if (strm(action,"lower"))D1->A=filter_aln_upper_lower (D1->A, DST?DST->A:NULL,RAD->use_consensus,value);
+ else if (strm(action,"switchcase"))D1->A=filter_aln_switchcase (D1->A, DST?DST->A:NULL,RAD->use_consensus,value);
+ }
+ else
+ {
+ if (strm(action,"keep")) D1->A=filter_aln_convert (D1->A, DST?DST->A:NULL,RAD->use_consensus,value,RAD->n_symbol, RAD->symbol_list);
+ }
+ if (value==-1)break;
+
+ }
+
+ /*free_sequence (D1->S,(D1->S)->nseq);*/
+ if (!D1->S)D1->S=aln2seq (D1->A);
+ }
+ else if ( strm ( action, "count_pairs"))
+ {
+ int a, b,c,v, **matrix;
+ Alignment *A;
+ matrix=declare_int (300,300);
+ A=D1->A;
+ for ( a=0; a< A->nseq-1; a++)
+ for (b=0; b< A->nseq; b++)
+ for (c=0; c<A->len_aln; c++)
+ matrix[(int)A->seq_al[a][c]][(int)A->seq_al[b][c]]++;
+ for ( a=0; a<255; a++)
+ for ( b=a; b<256; b++)
+ {
+ v=matrix[a][b]+matrix[b][a];
+ if (v)fprintf ( stdout, "\n%c %c %d", a, b, v);
+ }
+ myexit (EXIT_SUCCESS);
+ }
+ else if ( strm (action, "count_misc"))
+ {
+ count_misc (D1->A, (!D2)?NULL:D2->A);
+ }
+ else if ( strm (action, "count"))
+ {
+ b=1;
+ if ( n_actions>1 && is_number (action_list[b]))
+ {
+ lower_value=upper_value=atoi(action_list[b++]);
+ }
+ else if (n_actions>1 && action_list[b] && action_list[b] && action_list[b][0]=='[')
+
+ {
+ lower_value=atoi(strtok (action_list[b]+1, "-[]"));
+ upper_value=atoi(strtok (NULL, "-[]"));
+
+ b++;
+ }
+ else
+ {
+ lower_value=upper_value=-1;
+ }
+ if ( n_actions >b)
+ {
+ if ( !RAD->symbol_list)RAD->symbol_list=declare_char (STRING, STRING);
+ RAD->n_symbol=0;
+ for (a=b; a< n_actions; a++)
+ {
+ sprintf ( RAD->symbol_list[RAD->n_symbol], "%s", action_list[a]);
+ RAD->n_symbol++;
+ }
+ }
+ for ( value=lower_value; value<=upper_value; value++)
+ {
+ count_table=count_in_aln (D1->A, DST?DST->A:NULL,value,RAD->n_symbol, RAD->symbol_list, count_table);
+ }
+ for ( a=0; a<RAD->n_symbol; a++)
+ {
+ fprintf ( stdout, "%s %d\n", RAD->symbol_list[a], count_table[a]);
+ }
+ free_sequence (D1->S,(D1->S)->nseq);
+ D1->S=aln2seq (D1->A);
+ vfree(count_table);
+ myexit(EXIT_SUCCESS);
+ }
+ else if ( strm (action, "species_weight"))
+ {
+ seq_weight2species_weight (D1->A, D2->S);
+ exit (0);
+ }
+ else if ( strm (action, "aln2voronoi"))
+ {
+ aln2voronoi_weights (D1->A);
+
+ }
+ else if ( strm (action, "msa_weight"))
+ {
+ int random_value;
+ char command [LONG_STRING];
+ char aln_name[FILENAMELEN];
+ char tree_name[FILENAMELEN];
+ char dist_matrix_name[FILENAMELEN];
+ char weight_name[FILENAMELEN];
+ char method_4_msa_weights[1000];
+
+ if ( n_actions==1)
+ {
+ fprintf ( stderr, "\nError: msa_weight requires a weight_method");
+ }
+
+ sprintf ( method_4_msa_weights, "%s", (get_env_variable ("METHOD_4_MSA_WEIGHTS",NO_REPORT))?get_env_variable ("METHOD_4_MSA_WEIGHTS",NO_REPORT):METHOD_4_MSA_WEIGHTS);
+
+ /*1 Computation of the tree and the distance matrix*/
+ random_value=addrand ((unsigned long) 100000)+1;
+ sprintf (aln_name, "%d.aln", random_value);
+ sprintf (tree_name, "%d.ph", random_value);
+ sprintf (dist_matrix_name, "%d.dst", random_value);
+ sprintf (weight_name, "%d.weight", random_value);
+ output_fasta_aln (aln_name, D1->A);
+
+ sprintf ( command, "clustalw -infile=%s -tree -outputtree=dist %s", aln_name, TO_NULL_DEVICE);
+ my_system ( command);
+ sprintf ( command, "%s -method %s -aln %s -tree %s -dmatrix %s -weightfile %s %s",method_4_msa_weights, action_list[1],aln_name, tree_name, dist_matrix_name,weight_name, TO_NULL_DEVICE);
+ my_system ( command);
+
+ (D1->A)->S=aln2seq (D1->A);
+ ((D1->A)->S)->W=read_seq_weight ( (D1->A)->name, (D1->A)->nseq,weight_name);
+ vremove (weight_name);
+ vremove (aln_name);
+ vremove (tree_name);
+ vremove (dist_matrix_name);
+ }
+ else if ( strm (action, "pavie_seq2random_seq"))
+ {
+ D1->S=pavie_seq2random_seq (D1->S, action_list[1]);
+ D1->A=seq2aln (D1->S,NULL,1);
+ }
+ else if ( strm ( action, "pavie_seq2noisy_seq"))
+ {
+ /*<amount of noise: 0-100> (<alp>)*/
+
+ D1->S=pavie_seq2noisy_seq (D1->S, atoi(action_list[1]),ACTION(2));
+ D1->A=seq2aln (D1->S,NULL,1);
+ }
+ else if ( strm (action, "pavie_seq2pavie_mat"))
+ {
+
+ pavie_seq2trained_pavie_mat ( D1->S, (n_actions==2)?action_list[1]:NULL);
+ myexit (EXIT_SUCCESS);
+ }
+ else if ( strm (action, "pavie_seq2pavie_aln"))
+ {
+
+ pavie_seq2pavie_aln ( D1->S, action_list[1], ACTION(2));
+ myexit (EXIT_SUCCESS);
+ }
+ else if ( strm (action, "pavie_seq2pavie_dm"))
+ {
+ if (strstr (ACTION2(2,""), "_MSA_"))
+ D1->S=aln2seq_main(D1->A, KEEP_GAP);
+
+
+ pavie_seq2pavie_aln ( D1->S, action_list[1],(n_actions==3)?action_list[2]:"_MATDIST_");
+ myexit (EXIT_SUCCESS);
+ }
+ else if ( strm (action, "pavie_seq2pavie_msa"))
+ {
+ D1->A=pavie_seq2pavie_msa ( D1->S, action_list[1], (n_actions==3)?action_list[2]:NULL);
+ }
+ else if ( strm (action, "pavie_seq2pavie_tree"))
+ {
+ D1->T=pavie_seq2pavie_tree ( D1->S, action_list[1], (n_actions==3)?action_list[2]:NULL);
+ }
+ else if ( strm (action, "pavie_seq2pavie_sort"))
+ {
+ D1->A=pavie_seq2pavie_sort ( D1->S, action_list[1], (n_actions==3)?action_list[2]:NULL);
+ }
+
+ else if ( strm (action, "aln2mat_diaa"))
+ {
+ aln2mat_diaa (D1->S);
+ }
+ else if ( strm (action, "aln2mat"))
+ {
+ aln2mat(D1->S);
+ }
+
+ else if ( strm (action, "seq2latmat"))
+ {
+ seq2latmat ( D1->S, "stdout");
+ myexit (EXIT_SUCCESS);
+ }
+ else if ( strm (action , "rm_target_pdb"))
+ {
+ int i, j;
+ char *buf;
+
+ for (i=0; i< (D1->A)->nseq; i++)
+ {
+ j=1;buf=(D1->A)->name[i];
+ while (buf[j]!='_' && buf[j-1]!='_' && buf[j]!='\0')j++;
+ buf[j]='\0';
+ }
+ }
+ else if ( strm ( action, "mat2cmp"))
+ {
+ double *r;
+ r=mat2cmp (D1->M, D2->M);
+ fprintf ( stdout, "\nMATRIX COMPARISON: R=%.3f R2=%.3f On %d pairs of values\n", (float)r[0], (float)r[1], (int)r[2]);
+ myexit (EXIT_SUCCESS);
+ }
+//Special modes
+ else if ( strm ( action, "overaln_list"))
+ {
+ float *re, tre=0,sn, tsn=0, sp, tsp=0;
+ int p1,p2,p3, t, f;
+ FILE *fp;
+ char fname [100];
+ Alignment **LA;
+ Alignment **LB;
+
+ HERE ("F P1 P2 P3 T");
+
+ t=ATOI_ACTION(1);
+ f=ATOI_ACTION(2);
+ p1=ATOI_ACTION(3);
+ p2=ATOI_ACTION(4);
+ p3=ATOI_ACTION(5);
+
+
+
+ LA=vcalloc ((D1->A)->nseq, sizeof (Alignment*));
+ LB=vcalloc ((D2->A)->nseq, sizeof (Alignment*));
+ for (a=0; a<(D1->A)->nseq; a++)
+ {
+ LA[a]=main_read_aln ((D1->A)->name[a], NULL);
+ LB[a]=main_read_aln ((D2->A)->name[a], NULL);
+ }
+
+ for ( a=0; a<(D1->A)->nseq; a++)
+ {
+ Alignment *A, *B;
+ A=LA[a];
+ B=LB[a];
+ re=analyze_overaln (A, B, "_case_l_",t,f,p1,p2,p3);
+ fprintf (stdout, "\n%d: sn: %.2f sp: %.2f re: %.2f F: %d P: %d P2: %d T: %d",a, re[0],re[1],re[2],f, p1,p2,t);
+ tsn+=re[0];
+ tsp+=re[1];
+ tre+=re[2];
+ vfree(re);
+ }
+ fprintf (stdout, "\nTOT: sn: %.2f sp: %.2f re: %.2f F: %d P: %d P2: %d T: %d", tsn/(D1->A)->nseq,tsp/(D1->A)->nseq, tre/(D1->A)->nseq,f,p1,p2,t);
+
+ myexit (0);
+ }
+ else if ( strm ( action, "overaln_list_scan"))
+ {
+ float *re, tre=0, tsn=0, tsp;
+ int p1,p2, p3, t, f;
+ FILE *fp;
+ char fname [100];
+ Alignment **LA;
+ Alignment **LB;
+
+ if ( ACTION(1))sprintf ( fname, "%s", ACTION(1));
+ else sprintf ( fname, "scan_results.txt");
+
+ fprintf ( stdout, "SCAN Results will be ouput in %s\n", fname);
+
+
+ LA=vcalloc ((D1->A)->nseq, sizeof (Alignment*));
+ LB=vcalloc ((D2->A)->nseq, sizeof (Alignment*));
+ for (a=0; a<(D1->A)->nseq; a++)
+ {
+ LA[a]=main_read_aln ((D1->A)->name[a], NULL);
+ LB[a]=main_read_aln ((D2->A)->name[a], NULL);
+ }
+ for (f=32; f<=40; f++)
+ {
+ for (p1=90; p1<=100; p1+=5)
+ {
+ for ( t=1; t<=3; t++)
+ {
+ for (p2=0; p2<=40; p2+=5)
+ {
+ for (p3=0;p3<=0;p3+=5)
+ {
+ tre=tsn=tsp=0;
+ for ( a=0; a<(D1->A)->nseq; a++)
+ {
+ Alignment *A, *B;
+ A=LA[a];
+ B=LB[a];
+ re=analyze_overaln (A, B, "_case_l_",t,f,p1,p2,p3);
+
+ tsn+=re[0];
+ tsp+=re[1];
+ tre+=re[2];
+ vfree (re);
+ }
+ fp=vfopen (fname, "a");
+ fprintf (fp, "\nTOT: sn: %.2f sp: %.2f re: %.2f P: %d P2: %d P3: %d T: %d F: %d", tsn/(D1->A)->nseq,tsp/(D1->A)->nseq, tre/(D1->A)->nseq, p1,p2, p3,t,f);
+ fprintf (stderr, "\nTOT: sn: %.2f sp: %.2f re: %.2f P: %d P2: %d P3: %d T: %d F: %d", tsn/(D1->A)->nseq,tsp/(D1->A)->nseq, tre/(D1->A)->nseq, p1,p2, p3,t,f);
+ vfclose (fp);
+ }
+ }
+ }
+ }
+ }
+ myexit (0);
+ }
+ else if ( strm ( action, "overaln"))//Evaluate the capacity to predict over-aligned regions
+ {
+ OveralnP *F;
+ F=vcalloc (1, sizeof (OveralnP));
+ //al1: ref
+ //al2: alignment
+ //ATOI(1): P (0-100)
+ //ATOI(2): T (0-9)
+
+ float *r;
+ DST=vcalloc (1,sizeof(Sequence_data_struc));
+ DST->A=aln2gap_cache (D1->A,0);
+ lower_value=0;
+ upper_value=0;
+ D1->A=filter_aln_upper_lower (D1->A, DST->A, 0, 0);
+
+ sprintf (F->mode, "%s", ((s=get_string_variable ("overaln_mode")))?s:"lower");
+ if (!strm (F->mode, "lower") && !strstr (F->mode, "unalign"))printf_exit (EXIT_FAILURE,stderr,"\nERROR: unknown overal_mode in overal output [%s] [FATAL:%s]", F->mode, PROGRAM);
+
+ if (int_variable_isset ("overaln_threshold"))F->t=get_int_variable ("overaln_threshold");
+ if (int_variable_isset ("overaln_target"))F->f=get_int_variable ("overaln_target");
+ if (int_variable_isset ("overaln_P1"))F->f=get_int_variable ("overaln_P1");
+ if (int_variable_isset ("overaln_P1"))F->f=get_int_variable ("overaln_P2");
+ if (int_variable_isset ("overaln_P1"))F->f=get_int_variable ("overaln_P3");
+ if (int_variable_isset ("overaln_P1"))F->f=get_int_variable ("overaln_P4");//F P1 P2 P3 T;
+
+ D2->A=aln2clean_pw_aln (D2->A, F);
+ r=aln2pred (D1->A, D2->A,"case_l_");
+ fprintf ( stdout, "sn %.2f sp %.2f re %.2f\n", r[0], r[1], r[2]);
+ myexit (0);
+ }
+
+
+//JM_START
+ else if ( strm ( action, "aln2hitMat"))
+ {
+ aln2hitMat(D1->A, ACTION(1));
+ myexit (EXIT_SUCCESS);
+ }
+//JM_END
+
+ else
+ {
+ fprintf ( stderr, "\nWARNING: ACTION %s UNKNOWN and IGNORED\n", action);
+ }
+
+ }
+
+
+void aln2mat_diaa (Sequence *S)
+{
+ int a, aa1, aa2, aa3, aa4;
+ int s1, s2, p;
+ Alignment *A;
+
+ int ****m;
+ int **c;
+ int naa=0;
+ int count=0;
+ double Delta=0.00001;
+ int *alp;
+ int tot,u;
+ double observed, expected, f_diaa1, f_diaa2, v;
+
+
+ alp=vcalloc (256, sizeof (int));
+ for (a=0; a<26; a++)alp[a+'a']=1;
+ alp['b']=0;
+ alp['j']=0;
+ alp['o']=0;
+ alp['u']=0;
+ alp['x']=0;
+ alp['z']=0;
+
+ m=declare_arrayN (4,sizeof (int),26,26,26,26);
+ c=declare_arrayN (2,sizeof (int),26,26);
+
+ for ( a=0; a< S->nseq; a++)
+ {
+ fprintf ( stderr, "%s\n", S->name[a]);
+ A=main_read_aln (S->name[a],NULL);
+ for (s1=0; s1<A->nseq; s1++)lower_string (A->seq_al[s1]);
+
+ for ( s1=0; s1<A->nseq-1; s1++)
+ for (s2=s1+1; s2<A->nseq; s2++)
+ {
+ for (p=0; p<A->len_aln-1; p++)
+ {
+
+ u =alp[aa1=A->seq_al[s1][p]];
+ u+=alp[aa2=A->seq_al[s1][p+1]];
+ u+=alp[aa3=A->seq_al[s2][p]];
+ u+=alp[aa4=A->seq_al[s2][p+1]];
+
+ if ( u==4)
+ {
+ aa1-='a';aa2-='a';aa3-='a'; aa4-='a';
+
+ c[aa1][aa2]++;
+ c[aa3][aa4]++;
+ m[aa1][aa2][aa3][aa4]++;
+ count+=2;
+ }
+ }
+ }
+ free_aln (A);
+ }
+ fprintf ( stdout, "# DIAA_MATRIX_FORMAT_01\n");
+ naa=26;
+ for (aa1=0; aa1<naa; aa1++)
+ for (aa2=0; aa2<naa; aa2++)
+ for (aa3=0; aa3<naa; aa3++)
+ for (aa4=0; aa4<naa;aa4++)
+ {
+ u =alp[aa1+'a'];
+ u+=alp[aa2+'a'];
+ u+=alp[aa3+'a'];
+ u+=alp[aa4+'a'];
+
+ if ( u==4)
+ {
+ tot=m[aa1][aa2][aa3][aa4]+m[aa3][aa4][aa1][aa2];
+ observed=((double)tot)/(double)((double)count/(double)2);
+ f_diaa1=(double)c[aa1][aa2]/(double)count;
+ f_diaa2=(double)c[aa3][aa4]/(double)count;
+
+ expected=f_diaa1*f_diaa2;
+ if (expected<Delta)v=0;
+ else if (observed<Delta)v=-100;
+ else
+ {
+ v=log(observed/expected)*10;
+ }
+ // if (tot>0)fprintf ( stdout, "TEST C=%d expected=%.4f observed=%.4f v=%.4f [%d %d %d][%d] tot=%d\n", count, (float)expected, (float)observed, (float) v, c[aa1][aa2], c[aa3][aa4], count, m[aa1][aa2][aa3][aa4], tot);
+ fprintf ( stdout, "%c%c %c%c %d %d\n", aa1+'a', aa2+'a', aa3+'a', aa4+'a', (int)v, m[aa1][aa2][aa3][aa4]+ m[aa3][aa4][aa1][aa2]);
+ }
+ }
+ myexit (EXIT_SUCCESS);
+}
+void aln2mat (Sequence *S)
+{
+ int a, aa1, aa3;
+ int s1, s2, p;
+ Alignment *A;
+ int **mat;
+ int **m;
+ int *c;
+ int naa=0;
+ int count=0;
+ double Delta=0.00001;
+ int *alp;
+ int tot,u;
+ double observed, expected, f_diaa1, f_diaa2, v;
+ char *balp;
+
+ balp=vcalloc ( 256, sizeof (char));
+ for (a=0; a<strlen (BLAST_AA_ALPHABET); a++)balp[BLAST_AA_ALPHABET[a]]=a;
+
+ mat=declare_int (256, 256);
+ alp=vcalloc (256, sizeof (int));
+ for (a=0; a<26; a++)alp[a+'a']=1;
+ alp['b']=0;
+ alp['j']=0;
+ alp['o']=0;
+ alp['u']=0;
+ alp['x']=0;
+ alp['z']=0;
+
+ m=declare_arrayN (2,sizeof (int),26,26);
+ c=declare_arrayN (1,sizeof (int),26);
+
+ for ( a=0; a< S->nseq; a++)
+ {
+ fprintf ( stderr, "%s\n", S->name[a]);
+ A=main_read_aln (S->name[a],NULL);
+ for (s1=0; s1<A->nseq; s1++)lower_string (A->seq_al[s1]);
+
+ for ( s1=0; s1<A->nseq-1; s1++)
+ for (s2=s1+1; s2<A->nseq; s2++)
+ {
+ for (p=0; p<A->len_aln-1; p++)
+ {
+
+ u =alp[aa1=A->seq_al[s1][p]];
+ u+=alp[aa3=A->seq_al[s2][p]];
+
+ if ( u==2)
+ {
+ aa1-='a';aa3-='a';
+
+ c[aa1]++;
+ c[aa3]++;
+ m[aa1][aa3]++;
+ count+=2;
+ }
+ }
+ }
+ free_aln (A);
+ }
+ fprintf ( stdout, "# MONOAA_MATRIX_FORMAT_01\n");
+ naa=26;
+ for (aa1=0; aa1<naa; aa1++)
+ for (aa3=0; aa3<naa; aa3++)
+ {
+ u =alp[aa1+'a'];
+ u+=alp[aa3+'a'];
+
+ if ( u==2)
+ {
+ tot=m[aa1][aa3]+m[aa3][aa1];
+ observed=((double)tot)/(double)((double)count/(double)2);
+ f_diaa1=(double)c[aa1]/(double)count;
+ f_diaa2=(double)c[aa3]/(double)count;
+
+ expected=f_diaa1*f_diaa2;
+ if (expected<Delta)v=0;
+ else if (observed<Delta)v=-100;
+ else
+ {
+ v=log(observed/expected)/(log(2)/2);
+ }
+ // if (tot>0)fprintf ( stdout, "TEST C=%d expected=%.4f observed=%.4f v=%.4f [%d %d %d][%d] tot=%d\n", count, (float)expected, (float)observed, (float) v, c[aa1][aa2], c[aa3][aa4], count, m[aa1][aa2][aa3][aa4], tot);
+ //fprintf ( stdout, "%c %c %d %d\n", aa1+'A', aa3+'A', (int)v, m[aa1][aa3]+ m[aa3][aa1]);
+ mat[aa1][aa3]=(int)v;
+ }
+ }
+ output_blast_mat (mat, "stdout");
+ myexit (EXIT_SUCCESS);
+}
+
+
+int **seq2latmat ( Sequence *S, char *fname)
+{
+ int a, b, r0, r1;
+ char *aa;
+ int naa;
+ int *count, tot;
+ int **mat;
+ double observed, expected;
+ FILE *fp;
+
+ fp=vfopen (fname, "w");
+
+ count=vcalloc ( 256, sizeof (int));
+ mat=declare_int (256, 256);
+
+ naa=strlen ( BLAST_AA_ALPHABET);
+ aa=vcalloc ( naa+2, sizeof (char));
+ sprintf ( aa, "%s", BLAST_AA_ALPHABET);
+ lower_string (aa);
+
+ for ( tot=0,a=0; a< S->nseq; a++)
+ {
+ ungap (S->seq[a]);
+ for ( b=1; b<S->len[a]; b++)
+ {
+ r0=tolower(S->seq[a][b-1]);
+ r1=tolower(S->seq[a][b]);
+
+ mat[r0][r1]++;
+ //count[r0]++;
+ count[r1]++;
+ tot++;
+ }
+ }
+ for ( a=0; a< naa; a++)
+ for (b=0; b< naa; b++)
+ {
+ if ( aa[a]=='*' || aa[b]=='*');
+ else
+ {
+ expected=((double)count[(int)aa[a]]/(double)tot)* ((double)count[(int)aa[b]]/(double)tot)*(double)tot;
+ observed=((double)mat[(int)aa[a]][(int)aa[b]]);
+
+ /*
+ fprintf ( stderr, "\n%c=%d %c=%d Tot=%d Obs=%d Exp=%d\n", aa[a],count[aa[a]], aa[b],count[aa[b]],tot, mat[aa[a]][aa[b]],(int)expected);
+ fprintf ( stderr, "\n%d", mat[aa[a]][aa[b]]);
+ fprintf ( stderr, "\n%d", mat[aa[a]][aa[b]]);
+ */
+ mat[(int)aa[a]][(int)aa[b]]=(expected==0 || observed==0)?0:((int)10*log((observed/expected)));
+ }
+ }
+
+ fprintf (fp,"# BLAST_MATRIX FORMAT\n#ALPHABET=%s\n#TRANSITION MATRIX TRAINED ON %d Sequence\n#", BLAST_AA_ALPHABET, S->nseq);
+ for (a=0; a< naa; a++)fprintf ( fp, "%3c ", toupper(aa[a]));
+ fprintf (fp,"\n");
+ for (a=0; a< naa; a++)
+ {
+
+ fprintf (fp, "%c", toupper(aa[a]));
+ for ( b=0; b< naa; b++)
+ {
+ fprintf (fp, "%3d ", mat[(int)aa[a]][(int)aa[b]]);
+ }
+ fprintf ( fp, "\n");
+ }
+ vfclose (fp);
+ vfree (count);
+ vfree (aa);
+
+ return mat;
+}
+
+double* mat2cmp ( int **mat1, int **mat2)
+{
+ int a, b, n, x, y;
+ double **list, *r;
+ if ( !mat1 || !mat2)
+ {
+ fprintf ( stderr, "\nERROR: mat2cmp needs two matrices [FATAL:%s]", PROGRAM);
+ myexit (EXIT_FAILURE);
+ }
+
+ for (n=0, a=0; a< 256; a++)
+ for ( b=0; b<256; b++)
+ {
+ x=mat1[a][b];
+ y=mat2[a][b];
+ if ( x|| y)n++;
+ }
+ if ( n==0) return 0;
+ list=declare_double (n, 2);
+
+ for (n=0, a=0; a<256; a++)
+ for ( b=0; b<256; b++)
+ {
+ x=mat1[a][b];
+ y=mat2[a][b];
+ if ( x || y)
+ {
+ list[n][0]=x;
+ list[n][1]=y;
+ n++;
+ }
+ }
+ r=return_r (list, n);
+ free_double(list, -1);
+ return r;
+}
+
+int ** read_blast_matrix ( char *mat_name)
+ {
+ FILE *fp;
+ int n_aa,aa1, aa2;
+ int a, b, c;
+ int **matrix;
+ int value;
+ char sbuf[VERY_LONG_STRING];
+ char buf[2];
+ char alp[257];
+
+ matrix=declare_int (256,256);
+ vfree ( matrix[30]);
+ matrix[30]=vcalloc(10000, sizeof (int));
+ fp=vfopen ( mat_name, "r");
+ while ( (c=fgetc(fp))=='#' || isspace(c) )
+ {
+ char *p;
+ fgets ( sbuf, VERY_LONG_STRING, fp);
+ if ( (p=strstr (sbuf, "ALPHABET")))
+ sscanf (p, "ALPHABET=%s", alp);
+ }
+ ungetc(c, fp);
+ lower_string (alp);
+ n_aa=strlen (alp);
+
+ for ( a=0; a< n_aa; a++)
+ {
+ fscanf ( fp, "%s ", buf);
+
+ aa1=tolower(buf[0]);
+
+ if ( aa1!=alp[a])
+ {
+ fprintf ( stderr, "\nParsing_error when reading blast_matrix %s:\n%c %c",mat_name, aa1,alp[a]);
+ fprintf ( stderr, "\n%c ", fgetc(fp));
+ myexit (EXIT_FAILURE);
+ }
+ for ( b=0; b<n_aa; b++)
+ {
+ aa2=tolower ((char) alp[b]);
+ fscanf ( fp, "%d ", &value);
+ if (is_gap(aa1) || is_gap(aa2))
+ {
+ int c1, c2;
+ c1=(is_gap(aa1))?GAP_CODE:aa1;
+ c2=(is_gap(aa2))?GAP_CODE:aa2;
+ if ( c1==GAP_CODE && c2==GAP_CODE)
+ matrix[c1][c2]=value;
+ else if ( c1==GAP_CODE)
+ {
+ matrix[c1][tolower(c2)]=value;
+ matrix[c1][toupper(c2)]=value;
+ }
+ else
+ {
+ matrix[tolower(c1)][c2]=value;
+ matrix[toupper(c1)][c2]=value;
+ }
+ }
+ else if ( aa1!='*' && aa2!='*')
+ {
+ matrix[tolower(aa1)-'A'][tolower(aa2)-'A']=value;
+ matrix[toupper(aa1)-'A'][toupper(aa2)-'A']=value;
+ matrix[tolower(aa1)-'A'][toupper(aa2)-'A']=value;
+ matrix[toupper(aa1)-'A'][tolower(aa2)-'A']=value;
+ }
+ }
+ fscanf(fp, "\n");
+ }
+ fclose (fp);
+
+ return matrix;
+ }
+
+int output_blast_mat (int **mat, char *fname)
+{
+ return output_mat(mat, fname, BLAST_AA_ALPHABET, 'a');
+
+}
+int output_header_mat (int **mat, char *fname, char *alp)
+{
+ int a, b,l;
+ FILE *fp;
+ int naa;
+
+ char raa[]="ABCDEFGHIKLMNPQRSTVWXYZ";
+ char *aa;
+
+ naa=strlen (raa);
+ aa=vcalloc ( naa+2, sizeof (char));
+ sprintf ( aa, "%s",raa);
+ lower_string (aa);
+
+ fp=vfopen (fname, "w");
+ fprintf ( fp, "int new_mat[]={\n");
+ l=strlen (aa);
+ for (a=0; a<naa; a++)
+ {
+ for (b=0; b<=a; b++)
+ {
+ fprintf (fp, "%3d, ", mat[aa[a]-'a'][aa[b]-'a']);
+ }
+ fprintf (fp, "\n");
+ }
+ fprintf ( fp, "}");
+ vfclose (fp);
+}
+int output_mat (int **mat, char *fname, char *alp, int offset)
+{
+ char *aa;
+ int a,b, naa;
+ FILE *fp;
+
+
+
+ naa=strlen (alp);
+ aa=vcalloc ( naa+2, sizeof (char));
+ sprintf ( aa, "%s",alp);
+ lower_string (aa);
+ if (!(fp=vfopen (fname, "w")))return 0;
+ fprintf (fp,"# BLAST_MATRIX FORMAT\n#ALPHABET=%s\n ",alp);
+ for (a=0; a< naa; a++)fprintf ( fp, "%5c ", toupper(aa[a]));
+ fprintf (fp,"\n");
+ for (a=0; a< naa; a++)
+ {
+
+ fprintf (fp, "%c", toupper(aa[a]));
+ for ( b=0; b< naa; b++)
+ {
+ if (aa[a]!='*' && aa[b]!='*')
+ fprintf (fp, " %5d", mat[aa[a]-offset][aa[b]-offset]);
+ else
+ fprintf (fp, " %5d", 0);
+ }
+ fprintf ( fp, "\n");
+ }
+ vfree (aa);
+ vfclose (fp);
+ return 1;
+}
+
+void output_pavie_mat (int **mat, char *fname, double gep, char *alp)
+{
+ int n, a, b;
+ FILE *fp;
+
+ n=strlen (alp);
+ fp=vfopen (fname, "w");
+ fprintf (fp,"# PAVIE_MATRIX FORMAT\n#ALPHABET=%s\n",alp);
+
+ for(a=0; a< n; a++)
+ {
+ for ( b=a; b<n; b++)
+ {
+ fprintf (fp, "%c %c %.3f\n", toupper(alp[a]), toupper(alp[b]), (float)mat[alp[a]-'A'][alp[b]-'A']/PAVIE_MAT_FACTOR);
+ }
+ }
+ if ( gep!=UNDEFINED)fprintf ( fp, "- - %.3f\n", gep/PAVIE_MAT_FACTOR);
+ vfclose(fp);
+ }
+
+int ** read_pavie_matrix ( char *mat_name)
+ {
+ FILE *fp;
+ int c, n_aa;
+ char aa1, aa2;
+ float v;
+ int **matrix;
+ char sbuf[VERY_LONG_STRING];
+ char alp[257];
+ int gep=UNDEFINED;
+
+ matrix=declare_int (256,256);
+
+
+ fp=vfopen ( mat_name, "r");
+ while ( (c=fgetc(fp))=='#' || isspace(c) )
+ {
+ fgets ( sbuf, VERY_LONG_STRING, fp);
+ if ( sscanf (sbuf, "ALPHABET=%s", alp)==1);
+ }
+ ungetc(c, fp);
+
+ n_aa=strlen (alp);
+ while ( fgets ( sbuf, VERY_LONG_STRING, fp)!=NULL)
+ {
+ aa1=aa2='Z';
+ if (sscanf (sbuf, "%c %c %f",&aa1, &aa2, &v)==3)
+ {
+ v*=PAVIE_MAT_FACTOR;
+ if (aa1=='-' && aa2=='-')gep=v;
+ else
+ {
+ matrix[tolower(aa1)-'A'][tolower(aa2)-'A']=v;
+ matrix[toupper(aa1)-'A'][toupper(aa2)-'A']=v;
+ matrix[tolower(aa1)-'A'][toupper(aa2)-'A']=v;
+ matrix[toupper(aa1)-'A'][tolower(aa2)-'A']=v;
+
+ matrix[tolower(aa2)-'A'][tolower(aa1)-'A']=v;
+ matrix[toupper(aa2)-'A'][toupper(aa1)-'A']=v;
+ matrix[tolower(aa2)-'A'][toupper(aa1)-'A']=v;
+ matrix[toupper(aa2)-'A'][tolower(aa1)-'A']=v;
+ }
+ }
+ }
+ if ( gep!=UNDEFINED)
+ {
+ int a;
+ for (a=0; a< n_aa; a++)
+ {
+ if (!matrix[tolower(alp[a])-'A'][GAP_CODE])
+ {
+ matrix[tolower(alp[a])-'A'][GAP_CODE]=gep;
+ matrix[toupper(alp[a])-'A'][GAP_CODE]=gep;
+ }
+ }
+ }
+ vfclose (fp);
+ return matrix;
+ }
+
+Sequence *seq2year ( Sequence *S, int modulo)
+{
+ int a, b, y;
+ int first;
+ char *s;
+ char new_channel[100];
+
+ sprintf( new_channel, "_agechannel%d",modulo);
+
+ for ( a=0; a<S->nseq; a++)
+ {
+ if (S->seq_comment[a] && (s=strstr(S->seq_comment[a], "_FIRSTYEAR")))
+ {
+ sscanf (s, "_FIRSTYEAR%d_", &first);
+ }
+ else first=1;
+
+ for ( y=first,b=0; b<S->len[a]; b++)
+ {
+ if ( !is_gap(S->seq[a][b]))
+ {
+ S->seq[a][b]='a'+((y/modulo))%10;
+ y++;
+ }
+ }
+ if ( (s=strstr ( S->name[a], "_agechannel")))
+ {
+ sprintf ( s, "%s", new_channel);
+ }
+ else strcat (S->name[a], new_channel);
+ }
+ return S;
+}
+
+Sequence* output_n_pavie_age_channel (Sequence *S, char *name, int n)
+{
+ int x, a;
+ if (!n)n=2;
+
+
+ for ( x=1,a=0; a< n; a++, x*=10)
+ {
+ S=output_pavie_age_channel(S, name,x);
+ }
+return S;
+}
+
+
+
+
+Sequence* output_pavie_age_channel (Sequence *S, char *name, int modulo)
+ {
+ Alignment *A;
+ FILE *fp;
+ static int display;
+ char mat_list_name[100];
+ char seq_list[1000];
+ char mat_name[1000];
+ char *tmp;
+
+ sprintf ( mat_list_name, "%s_pavie_age_matrix.mat_list", name);
+ sprintf (seq_list, "%s_age_channel.fasta",name);
+
+ if ( display==0 )
+ {
+ if (check_file_exists(seq_list))vremove (seq_list);
+ if (check_file_exists(mat_list_name))vremove (mat_list_name);
+ }
+ sprintf (mat_name, "%s_age_mat_mod%d.mat",name, modulo);
+ output_age_matrix ( mat_name, modulo);
+
+ fp=vfopen ( mat_list_name,"a");
+ fprintf ( fp, "%s\n", mat_name);
+ vfclose ( fp);
+
+ S=seq2year (S,modulo);
+ A=seq2aln (S, NULL, KEEP_GAP);
+ output_fasta_seq (tmp=vtmpnam (NULL),A);
+ file_cat ( tmp, seq_list);
+
+ if ( display==0)
+ {
+ display_output_filename ( stdout, "AGE_MAT_LIST", "MAT_LIST", mat_list_name, CHECK);
+ display_output_filename ( stdout, "AGE_SEQ", "FASTA", seq_list, CHECK);
+ display=1;
+ }
+ fprintf ( stderr, "\nModulo:%d years", modulo);
+ fprintf ( stderr, "\n");
+ free_aln (A);
+ return S;
+ }
+//
+// Name MAnipulation
+//
+
+Alignment *clean_aln (Alignment *A)
+{
+ if ( A)
+ {
+ A->seq_comment=clean_string (A->nseq, A->seq_comment);
+ A->aln_comment=clean_string (A->nseq, A->aln_comment);
+ A->name=translate_names(A->nseq, A->name);
+ (A->S)=clean_sequence ((A->S));
+ }
+ return A;
+}
+Sequence *clean_sequence ( Sequence *S)
+{
+ if ( !S) return S;
+
+ S->seq_comment=clean_string (S->nseq, S->seq_comment);
+ S->name=translate_names(S->nseq, S->name);
+ return S;
+}
+char ** translate_names (int n, char **name)
+{
+ int a;
+ for ( a=0; a<n; a++)
+ name[a]=translate_name(name[a]);
+ return name;
+}
+char * translate_name ( char *name)
+ {
+
+ int len;
+ int a;
+ char buf[1000];
+
+ len=strlen (name);
+
+ //if ( name[0]=='\'')return name;
+
+ for ( a=0; a<len; a++)
+ {
+ if ( isspace(name[a]))name[a]='\0';
+ else if (strchr (";(),:#><'�", name[a]))name[a]='_';
+
+ }
+ sprintf (buf,"%s",decode_name (name, DECODE));
+ if ( strlen (buf)>read_array_size_new ((char *)name))
+ {
+ name=vrealloc (name, sizeof (char)*(strlen (buf)+1));
+ }
+ sprintf (name, "%s", buf);
+
+ return name;
+ }
+char *decode_name (char *name, int mode)
+{
+ static char ***name_list;
+ static int n;
+ static char tag[100];
+ int a;
+
+ if (mode==CLEAN)
+ {
+ for (a=0; a<n; a++)
+ {
+ vfree (name_list[a][0]);
+ vfree (name_list[a][1]);
+ vfree (name_list[a]);
+ }
+ vfree (name_list);
+ tag[0]='\0';
+ }
+
+ //spacial modes
+ if ( mode == CODELIST)
+ {
+ char *file;
+ file=vtmpnam (NULL);
+ for (a=0; a< n; a++)
+ printf_file(file, "a", "#CODE: %s <=> %s\n", name_list[a][0], name_list[a][1]);
+ return file;
+ }
+ if (mode ==DECODE && name_list==NULL)return name;
+ if ( name==NULL) return name;
+
+
+
+ if (!tag[0])
+ {
+ vsrand (0);
+ sprintf ( tag, "TCTAG_%d",rand ()%100000);
+ }
+
+ if ( mode==CODE)
+ {
+ for (a=0; a< n; a++)
+ if ( strm (name, name_list[a][0]))return name_list[a][1];
+
+
+ name_list=realloc (name_list, sizeof (char**)*(n+1));
+ name_list[n]=vcalloc (2, sizeof (char*));
+ name_list[n][0]=vcalloc (strlen (name)+1, sizeof (char));
+ name_list[n][1]=vcalloc (100, sizeof (char));
+ sprintf ( name_list[n][0], "%s", name);
+ sprintf ( name_list[n][1], "%s_%d", tag,n+1);
+ return name_list[n++][1];
+ }
+ else if ( mode ==DECODE)
+ {
+ char *p;
+ int i;
+ if ( !(p=after_strstr (name, tag)))return name;
+ else
+ {
+ sscanf (p, "_%d", &i);
+ return name_list[i-1][0];
+ }
+ }
+ else
+ {
+ printf_exit (EXIT_FAILURE, stderr,"Unknown Mode for Decode_name [FATAL:%s]", PROGRAM);
+ }
+ return NULL;
+}
+
+
+FILE * display_sequences_names (Sequence *S, FILE *fp, int check_pdb_status, int print_templates)
+ {
+ int a;
+ int max_len;
+ char *r;
+
+ if ( !S)
+ {
+ fprintf (fp,"\nERROR: NO SEQUENCE READ [FATAL:%s]\n", PROGRAM); myexit (EXIT_FAILURE);
+ }
+ for ( a=0, max_len=0; a< S->nseq; a++)max_len=MAX(max_len, strlen (S->name[a]));
+ fprintf ( fp, "\nINPUT SEQUENCES: %d SEQUENCES [%s]", S->nseq,(S->type)?S->type:"Unknown type");
+ for ( a=0; a< S->nseq; a++)
+ {
+ fprintf (fp, "\n Input File %-*s Seq %-*s Length %4d type %s",max_len,S->file[a], max_len,S->name[a],(int)strlen ( S->seq[a]), S->type);
+ if (check_pdb_status)
+ {
+ if ((r=seq_is_pdb_struc (S, a)))fprintf (fp, " Struct Yes PDBID %s", get_pdb_id(r));
+ else fprintf (fp, " Struct No");
+ /*
+ if (is_pdb_struc (S->name[a])||is_pdb_struc (S->file[a]) )fprintf (fp, " Struct Yes");
+ else fprintf (fp, " Struct No");
+ */
+ }
+ else fprintf (fp, " Struct Unchecked");
+ if ( print_templates)fp=display_sequence_templates (S, a, fp);
+
+
+ }
+ fprintf ( fp, "\n");
+ return fp;
+
+ }
+Sequence *add_file2file_list (char *name, Sequence *S)
+{
+
+ if (!S) S=declare_sequence (1,1,10);
+ else S=realloc_sequence (S,S->nseq+1,0);S->nseq=0;
+
+ sprintf ( S->name[S->nseq++], "%s", name);
+ return S;
+
+}
+#ifdef DO_PHECOMP
+int parse_phecomp_data (char *in, char *out)
+{
+ static char *buffer;
+ in=quick_find_token_in_file (in, "[EXPERIMENT HEADER]");
+ while (fgets (buffer,fp,MAX_LINE_LENGTH));
+}
+FILE * quick_find_token_in_file (FILE *fp, char *token)
+{
+ //returns fp pointing to the begining of the line FOLLOWING the line containing token
+ static char *buffer;
+ if (!line) line=vcalloc (MAX_LINE_LENGTH+1, sizeof (char));
+ while (fgets (buffer,MAX_LINE_LENGTH, fp)!=NULL)
+ if (strstr (buffer,token))return fp;
+ vfclose (fp);
+ return NULL;
+}
+
+int * file2cage (char *file, int cage)
+{
+
+
+
+
+
+
+
+
+
+
+#endif
+/******************************COPYRIGHT NOTICE*******************************/
+/*© Centro de Regulacio Genomica */
+/*and */
+/*Cedric Notredame */
+/*Fri Feb 18 08:27:45 CET 2011 - Revision 596. */
+/*All rights reserved.*/
+/*This file is part of T-COFFEE.*/
+/**/
+/* T-COFFEE is free software; you can redistribute it and/or modify*/
+/* it under the terms of the GNU General Public License as published by*/
+/* the Free Software Foundation; either version 2 of the License, or*/
+/* (at your option) any later version.*/
+/**/
+/* T-COFFEE is distributed in the hope that it will be useful,*/
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of*/
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the*/
+/* GNU General Public License for more details.*/
+/**/
+/* You should have received a copy of the GNU General Public License*/
+/* along with Foobar; if not, write to the Free Software*/
+/* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA*/
+/*............................................... |*/
+/* If you need some more information*/
+/* cedric.notredame@europe.com*/
+/*............................................... |*/
+/**/
+/**/
+/* */
+/******************************COPYRIGHT NOTICE*******************************/
git://source.jalview.org / jabaws.git / blobdiff