/*--------------------------------------------------------------------------*/
int main(int argc, char *argv[]){
struct RNAalifold_args_info args_info;
unsigned int input_type;
char ffname[FILENAME_MAX_LENGTH], gfname[FILENAME_MAX_LENGTH], fname[FILENAME_MAX_LENGTH];
char *input_string, *string, *structure, *cstruc, *ParamFile, *ns_bases, *c;
int n_seq, i, length, sym, r, noPS, with_sci;
int endgaps, mis, circular, doAlnPS, doColor, doMEA, n_back, eval_energy, pf, istty;
double min_en, real_en, sfact, MEAgamma, bppmThreshold, betaScale;
char *AS[MAX_NUM_NAMES]; /* aligned sequences */
char *names[MAX_NUM_NAMES]; /* sequence names */
FILE *clust_file = stdin;
pf_paramT *pf_parameters;
model_detailsT md;
fname[0] = ffname[0] = gfname[0] = '\0';
string = structure = cstruc = ParamFile = ns_bases = NULL;
pf_parameters = NULL;
endgaps = mis = pf = circular = doAlnPS = doColor = n_back = eval_energy = oldAliEn = doMEA = ribo = noPS = 0;
do_backtrack = 1;
dangles = 2;
gquad = 0;
sfact = 1.07;
bppmThreshold = 1e-6;
MEAgamma = 1.0;
betaScale = 1.;
with_sci = 0;
set_model_details(&md);
/*
#############################################
# check the command line prameters
#############################################
*/
if(RNAalifold_cmdline_parser (argc, argv, &args_info) != 0) exit(1);
/* temperature */
if(args_info.temp_given) temperature = args_info.temp_arg;
/* structure constraint */
if(args_info.constraint_given) fold_constrained=1;
/* do not take special tetra loop energies into account */
if(args_info.noTetra_given) md.special_hp = tetra_loop=0;
/* set dangle model */
if(args_info.dangles_given){
if((args_info.dangles_arg != 0) && (args_info.dangles_arg != 2))
warn_user("required dangle model not implemented, falling back to default dangles=2");
else
md.dangles = dangles=args_info.dangles_arg;
}
/* do not allow weak pairs */
if(args_info.noLP_given) md.noLP = noLonelyPairs = 1;
/* do not allow wobble pairs (GU) */
if(args_info.noGU_given) md.noGU = noGU = 1;
/* do not allow weak closing pairs (AU,GU) */
if(args_info.noClosingGU_given) md.noGUclosure = no_closingGU = 1;
/* gquadruplex support */
if(args_info.gquad_given) md.gquad = gquad = 1;
/* sci computation */
if(args_info.sci_given) with_sci = 1;
/* do not convert DNA nucleotide "T" to appropriate RNA "U" */
/* set energy model */
if(args_info.energyModel_given) energy_set = args_info.energyModel_arg;
/* take another energy parameter set */
if(args_info.paramFile_given) ParamFile = strdup(args_info.paramFile_arg);
/* Allow other pairs in addition to the usual AU,GC,and GU pairs */
if(args_info.nsp_given) ns_bases = strdup(args_info.nsp_arg);
/* set pf scaling factor */
if(args_info.pfScale_given) sfact = args_info.pfScale_arg;
/* assume RNA sequence to be circular */
if(args_info.circ_given) circular=1;
/* do not produce postscript output */
if(args_info.noPS_given) noPS = 1;
/* partition function settings */
if(args_info.partfunc_given){
pf = 1;
if(args_info.partfunc_arg != -1)
do_backtrack = args_info.partfunc_arg;
}
/* MEA (maximum expected accuracy) settings */
if(args_info.MEA_given){
pf = doMEA = 1;
if(args_info.MEA_arg != -1)
MEAgamma = args_info.MEA_arg;
}
if(args_info.betaScale_given) betaScale = args_info.betaScale_arg;
/* set the bppm threshold for the dotplot */
if(args_info.bppmThreshold_given)
bppmThreshold = MIN2(1., MAX2(0.,args_info.bppmThreshold_arg));
/* set cfactor */
if(args_info.cfactor_given) cv_fact = args_info.cfactor_arg;
/* set nfactor */
if(args_info.nfactor_given) nc_fact = args_info.nfactor_arg;
if(args_info.endgaps_given) endgaps = 1;
if(args_info.mis_given) mis = 1;
if(args_info.color_given) doColor=1;
if(args_info.aln_given) doAlnPS=1;
if(args_info.old_given) oldAliEn = 1;
if(args_info.stochBT_given){
n_back = args_info.stochBT_arg;
do_backtrack = 0;
pf = 1;
init_rand();
}
if(args_info.stochBT_en_given){
n_back = args_info.stochBT_en_arg;
do_backtrack = 0;
pf = 1;
eval_energy = 1;
init_rand();
}
if(args_info.ribosum_file_given){
RibosumFile = strdup(args_info.ribosum_file_arg);
ribo = 1;
}
if(args_info.ribosum_scoring_given){
RibosumFile = NULL;
ribo = 1;
}
if(args_info.layout_type_given)
rna_plot_type = args_info.layout_type_arg;
/* alignment file name given as unnamed option? */
if(args_info.inputs_num == 1){
clust_file = fopen(args_info.inputs[0], "r");
if (clust_file == NULL) {
fprintf(stderr, "can't open %s\n", args_info.inputs[0]);
}
}
/* free allocated memory of command line data structure */
RNAalifold_cmdline_parser_free (&args_info);
/*
#############################################
# begin initializing
#############################################
*/
if(circular && gquad){
nrerror("G-Quadruplex support is currently not available for circular RNA structures");
}
make_pair_matrix();
if (circular && noLonelyPairs)
warn_user("depending on the origin of the circular sequence, "
"some structures may be missed when using --noLP\n"
"Try rotating your sequence a few times\n");
if (ParamFile != NULL) read_parameter_file(ParamFile);
if (ns_bases != NULL) {
nonstandards = space(33);
c=ns_bases;
i=sym=0;
if (*c=='-') {
sym=1; c++;
}
while (*c!='\0') {
if (*c!=',') {
nonstandards[i++]=*c++;
nonstandards[i++]=*c;
if ((sym)&&(*c!=*(c-1))) {
nonstandards[i++]=*c;
nonstandards[i++]=*(c-1);
}
}
c++;
}
}
istty = isatty(fileno(stdout))&&isatty(fileno(stdin));
/*
########################################################
# handle user input from 'stdin' if necessary
########################################################
*/
if(fold_constrained){
if(istty){
print_tty_constraint_full();
print_tty_input_seq_str("");
}
input_type = get_input_line(&input_string, VRNA_INPUT_NOSKIP_COMMENTS);
if(input_type & VRNA_INPUT_QUIT){ return 0;}
else if((input_type & VRNA_INPUT_MISC) && (strlen(input_string) > 0)){
cstruc = strdup(input_string);
free(input_string);
}
else warn_user("constraints missing");
}
if (istty && (clust_file == stdin))
print_tty_input_seq_str("Input aligned sequences in clustalw or stockholm format\n(enter a line starting with \"//\" to indicate the end of your input)");
n_seq = read_clustal(clust_file, AS, names);
if (n_seq==0) nrerror("no sequences found");
if (clust_file != stdin) fclose(clust_file);
/*
########################################################
# done with 'stdin' handling, now init everything properly
########################################################
*/
length = (int) strlen(AS[0]);
structure = (char *)space((unsigned) length+1);
if(fold_constrained && cstruc != NULL)
strncpy(structure, cstruc, length);
if (endgaps)
for (i=0; i<n_seq; i++) mark_endgaps(AS[i], '~');
/*
########################################################
# begin actual calculations
########################################################
*/
if (circular) {
int i;
double s = 0;
min_en = circalifold((const char **)AS, structure);
for (i=0; AS[i]!=NULL; i++)
s += energy_of_circ_structure(AS[i], structure, -1);
real_en = s/i;
} else {
float *ens = (float *)space(2*sizeof(float));
min_en = alifold((const char **)AS, structure);
if(md.gquad)
energy_of_ali_gquad_structure((const char **)AS, structure, n_seq, ens);
else
energy_of_alistruct((const char **)AS, structure, n_seq, ens);
real_en = ens[0];
free(ens);
}
string = (mis) ? consens_mis((const char **) AS) : consensus((const char **) AS);
printf("%s\n%s", string, structure);
if(istty){
if(with_sci){
float sci = min_en;
float e_mean = 0;
for (i=0; AS[i]!=NULL; i++){
char *seq = get_ungapped_sequence(AS[i]);
char *str = (char *)space(sizeof(char) * (strlen(seq) + 1));
e_mean += fold(seq, str);
free(seq);
free(str);
}
e_mean /= i;
sci /= e_mean;
printf( "\n minimum free energy = %6.2f kcal/mol (%6.2f + %6.2f)"
"\n SCI = %2.4f\n",
min_en, real_en, min_en-real_en, sci);
} else
printf("\n minimum free energy = %6.2f kcal/mol (%6.2f + %6.2f)\n",
min_en, real_en, min_en - real_en);
} else {
if(with_sci){
float sci = min_en;
float e_mean = 0;
for (i=0; AS[i]!=NULL; i++){
char *seq = get_ungapped_sequence(AS[i]);
char *str = (char *)space(sizeof(char) * (strlen(seq) + 1));
e_mean += fold(seq, str);
free(seq);
free(str);
}
e_mean /= i;
sci /= e_mean;
printf(" (%6.2f = %6.2f + %6.2f) [%2.4f]\n", min_en, real_en, min_en-real_en, sci);
}
else
printf(" (%6.2f = %6.2f + %6.2f) \n", min_en, real_en, min_en-real_en );
}
strcpy(ffname, "alirna.ps");
strcpy(gfname, "alirna.g");
if (!noPS) {
char **A;
A = annote(structure, (const char**) AS);
if(md.gquad){
if (doColor)
(void) PS_rna_plot_a_gquad(string, structure, ffname, A[0], A[1]);
else
(void) PS_rna_plot_a_gquad(string, structure, ffname, NULL, A[1]);
} else {
if (doColor)
(void) PS_rna_plot_a(string, structure, ffname, A[0], A[1]);
else
(void) PS_rna_plot_a(string, structure, ffname, NULL, A[1]);
}
free(A[0]); free(A[1]); free(A);
}
if (doAlnPS)
PS_color_aln(structure, "aln.ps", (const char const **) AS, (const char const **) names);
/* free mfe arrays */
free_alifold_arrays();
if (pf) {
float energy, kT;
char * mfe_struc;
mfe_struc = strdup(structure);
kT = (betaScale*((temperature+K0)*GASCONST))/1000.; /* in Kcal */
pf_scale = exp(-(sfact*min_en)/kT/length);
if (length>2000) fprintf(stderr, "scaling factor %f\n", pf_scale);
fflush(stdout);
if (cstruc!=NULL) strncpy(structure, cstruc, length+1);
pf_parameters = get_boltzmann_factors_ali(n_seq, temperature, betaScale, md, pf_scale);
energy = alipf_fold_par((const char **)AS, structure, NULL, pf_parameters, do_backtrack, fold_constrained, circular);
if (n_back>0) {
/*stochastic sampling*/
for (i=0; i<n_back; i++) {
char *s;
double prob=1.;
s = alipbacktrack(&prob);
printf("%s ", s);
if (eval_energy ) printf("%6g %.2f ",prob, -1*(kT*log(prob)-energy));
printf("\n");
free(s);
}
}
if (do_backtrack) {
printf("%s", structure);
if (!istty) printf(" [%6.2f]\n", energy);
else printf("\n");
}
if ((istty)||(!do_backtrack))
printf(" free energy of ensemble = %6.2f kcal/mol\n", energy);
printf(" frequency of mfe structure in ensemble %g\n",
exp((energy-min_en)/kT));
if (do_backtrack) {
FILE *aliout;
cpair *cp;
char *cent;
double dist;
FLT_OR_DBL *probs = export_ali_bppm();
plist *pl, *mfel;
assign_plist_from_pr(&pl, probs, length, bppmThreshold);
assign_plist_from_db(&mfel, mfe_struc, 0.95*0.95);
if (!circular){
float *ens;
cent = get_centroid_struct_pr(length, &dist, probs);
ens=(float *)space(2*sizeof(float));
energy_of_alistruct((const char **)AS, cent, n_seq, ens);
/*cent_en = energy_of_struct(string, cent);*/ /*ali*/
printf("%s %6.2f {%6.2f + %6.2f}\n",cent,ens[0]-ens[1],ens[0],(-1)*ens[1]);
free(cent);
free(ens);
}
if(doMEA){
float mea, *ens;
plist *pl2;
assign_plist_from_pr(&pl2, probs, length, 1e-4/(1+MEAgamma));
mea = MEA(pl2, structure, MEAgamma);
ens = (float *)space(2*sizeof(float));
if(circular)
energy_of_alistruct((const char **)AS, structure, n_seq, ens);
else
ens[0] = energy_of_structure(string, structure, 0);
printf("%s {%6.2f MEA=%.2f}\n", structure, ens[0], mea);
free(ens);
free(pl2);
}
if (fname[0]!='\0') {
strcpy(ffname, fname);
strcat(ffname, "_ali.out");
} else strcpy(ffname, "alifold.out");
aliout = fopen(ffname, "w");
if (!aliout) {
fprintf(stderr, "can't open %s skipping output\n", ffname);
} else {
print_aliout(AS, pl, bppmThreshold, n_seq, mfe_struc, aliout);
}
fclose(aliout);
if (fname[0]!='\0') {
strcpy(ffname, fname);
strcat(ffname, "_dp.ps");
} else strcpy(ffname, "alidot.ps");
cp = make_color_pinfo(AS,pl, bppmThreshold, n_seq, mfel);
(void) PS_color_dot_plot(string, cp, ffname);
free(cp);
free(pl);
free(mfel);
}
free(mfe_struc);
free_alipf_arrays();
free(pf_parameters);
}
if (cstruc!=NULL) free(cstruc);
(void) fflush(stdout);
free(string);
free(structure);
for (i=0; AS[i]; i++) {
free(AS[i]); free(names[i]);
}
return 0;
}
int main(int argc, char *argv[]){
struct RNA2Dfold_args_info args_info;
unsigned int input_type;
char *string, *input_string, *orig_sequence;
char *mfe_structure=NULL, *structure1=NULL, *structure2=NULL, *reference_struc1=NULL, *reference_struc2=NULL;
char *ParamFile=NULL;
int i, j, length, l;
double min_en;
double kT, sfact=1.07;
int pf=0,istty;
int noconv=0;
int circ=0;
int maxDistance1 = -1;
int maxDistance2 = -1;
int do_backtrack = 1;
int stBT = 0;
int nstBT = 0;
string=NULL;
dangles = 2;
struct nbhoods *neighborhoods = NULL;
struct nbhoods *neighborhoods_cur = NULL;
string = input_string = orig_sequence = NULL;
/*
#############################################
# check the command line prameters
#############################################
*/
if(RNA2Dfold_cmdline_parser (argc, argv, &args_info) != 0) exit(1);
/* temperature */
if(args_info.temp_given)
temperature = args_info.temp_arg;
/* max distance to 1st reference structure */
if(args_info.maxDist1_given)
maxDistance1 = args_info.maxDist1_arg;
/* max distance to 2nd reference structure */
if(args_info.maxDist2_given)
maxDistance2 = args_info.maxDist2_arg;
/* compute partition function and boltzmann probabilities */
if(args_info.partfunc_given)
pf = 1;
/* do stachastic backtracking */
if(args_info.stochBT_given){
pf = 1;
stBT = 1;
nstBT = args_info.stochBT_arg;
}
if(args_info.noTetra_given)
tetra_loop=0;
/* assume RNA sequence to be circular */
if(args_info.circ_given)
circ=1;
/* dangle options */
if(args_info.dangles_given)
dangles=args_info.dangles_arg;
/* set number of threads for parallel computation */
if(args_info.numThreads_given)
#ifdef _OPENMP
omp_set_num_threads(args_info.numThreads_arg);
#else
nrerror("\'j\' option is available only if compiled with OpenMP support!");
#endif
/* get energy parameter file name */
if(args_info.parameterFile_given)
ParamFile = strdup(args_info.parameterFile_arg);
/* do not allow GU pairs ? */
if(args_info.noGU_given)
noGU = 1;
/* do not allow GU pairs at the end of helices? */
if(args_info.noClosingGU_given)
no_closingGU = 1;
/* pf scaling factor */
if(args_info.pfScale_given)
sfact = args_info.pfScale_arg;
/* do not backtrack structures ? */
if(args_info.noBT_given)
do_backtrack = 0;
for (i = 0; i < args_info.neighborhood_given; i++){
int kappa, lambda;
kappa = lambda = 0;
if(sscanf(args_info.neighborhood_arg[i], "%d:%d", &kappa, &lambda) == 2);
if ((kappa>-2) && (lambda>-2)){
if(neighborhoods_cur != NULL){
neighborhoods_cur->next = (nbhoods *)space(sizeof(nbhoods));
neighborhoods_cur = neighborhoods_cur->next;
}
else{
neighborhoods = (nbhoods *)space(sizeof(nbhoods));
neighborhoods_cur = neighborhoods;
}
neighborhoods_cur->k = kappa;
neighborhoods_cur->l = lambda;
neighborhoods_cur->next = NULL;
}
}
/* free allocated memory of command line data structure */
RNA2Dfold_cmdline_parser_free (&args_info);
/*
#############################################
# begin actual program code
#############################################
*/
if (ParamFile != NULL)
read_parameter_file(ParamFile);
istty = isatty(fileno(stdout))&&isatty(fileno(stdin));
/*
#############################################
# main loop, continue until end of file
#############################################
*/
do {
if (istty)
print_tty_input_seq_str("Input strings\n1st line: sequence (upper or lower case)\n2nd + 3rd line: reference structures (dot bracket notation)\n@ to quit\n");
while((input_type = get_input_line(&input_string, 0)) & VRNA_INPUT_FASTA_HEADER){
printf(">%s\n", input_string); /* print fasta header if available */
free(input_string);
}
/* break on any error, EOF or quit request */
if(input_type & (VRNA_INPUT_QUIT | VRNA_INPUT_ERROR)){ break;}
/* else assume a proper sequence of letters of a certain alphabet (RNA, DNA, etc.) */
else{
length = (int) strlen(input_string);
string = strdup(input_string);
free(input_string);
}
mfe_structure = (char *) space((unsigned) length+1);
structure1 = (char *) space((unsigned) length+1);
structure2 = (char *) space((unsigned) length+1);
input_type = get_input_line(&input_string, VRNA_INPUT_NOSKIP_COMMENTS);
if(input_type & VRNA_INPUT_QUIT){ break;}
else if((input_type & VRNA_INPUT_MISC) && (strlen(input_string) > 0)){
reference_struc1 = strdup(input_string);
free(input_string);
if(strlen(reference_struc1) != length)
nrerror("sequence and 1st reference structure have unequal length");
}
else nrerror("1st reference structure missing\n");
strncpy(structure1, reference_struc1, length);
input_type = get_input_line(&input_string, VRNA_INPUT_NOSKIP_COMMENTS);
if(input_type & VRNA_INPUT_QUIT){ break;}
else if((input_type & VRNA_INPUT_MISC) && (strlen(input_string) > 0)){
reference_struc2 = strdup(input_string);
free(input_string);
if(strlen(reference_struc2) != length)
nrerror("sequence and 2nd reference structure have unequal length");
}
else nrerror("2nd reference structure missing\n");
strncpy(structure2, reference_struc2, length);
/* convert DNA alphabet to RNA if not explicitely switched off */
if(!noconv) str_DNA2RNA(string);
/* store case-unmodified sequence */
orig_sequence = strdup(string);
/* convert sequence to uppercase letters only */
str_uppercase(string);
if (istty) printf("length = %d\n", length);
min_en = (circ) ? circfold(string, mfe_structure) : fold(string, mfe_structure);
printf("%s\n%s", orig_sequence, mfe_structure);
if (istty)
printf("\n minimum free energy = %6.2f kcal/mol\n", min_en);
else
printf(" (%6.2f)\n", min_en);
printf("%s (%6.2f) <ref 1>\n", structure1, (circ) ? energy_of_circ_structure(string, structure1, 0) : energy_of_structure(string,structure1, 0));
printf("%s (%6.2f) <ref 2>\n", structure2, (circ) ? energy_of_circ_structure(string, structure2, 0) : energy_of_structure(string,structure2, 0));
/* get all variables need for the folding process (some memory will be preallocated here too) */
TwoDfold_vars *mfe_vars = get_TwoDfold_variables(string, structure1, structure2, circ);
mfe_vars->do_backtrack = do_backtrack;
TwoDfold_solution *mfe_s = TwoDfoldList(mfe_vars, maxDistance1, maxDistance2);
if(!pf){
#ifdef COUNT_STATES
printf("k\tl\tn\tMFE\tMFE-structure\n");
for(i = 0; mfe_s[i].k != INF; i++){
printf("%d\t%d\t%lu\t%6.2f\t%s\n", mfe_s[i].k, mfe_s[i].l, mfe_vars->N_F5[length][mfe_s[i].k][mfe_s[i].l/2], mfe_s[i].en, mfe_s[i].s);
if(mfe_s[i].s) free(mfe_s[i].s);
}
free(mfe_s);
#else
printf("k\tl\tMFE\tMFE-structure\n");
for(i = 0; mfe_s[i].k != INF; i++){
printf("%d\t%d\t%6.2f\t%s\n", mfe_s[i].k, mfe_s[i].l, mfe_s[i].en, mfe_s[i].s);
if(mfe_s[i].s) free(mfe_s[i].s);
}
free(mfe_s);
#endif
}
if(pf){
int maxD1 = (int) mfe_vars->maxD1;
int maxD2 = (int) mfe_vars->maxD2;
float mmfe = INF;
double Q;
for(i = 0; mfe_s[i].k != INF; i++){
if(mmfe > mfe_s[i].en) mmfe = mfe_s[i].en;
}
kT = (temperature+K0)*GASCONST/1000.0; /* in Kcal */
pf_scale = exp(-(sfact*mmfe)/kT/length);
if (length>2000)
fprintf(stdout, "scaling factor %f\n", pf_scale);
/* get all variables need for the folding process (some memory will be preallocated there too) */
//TwoDpfold_vars *q_vars = get_TwoDpfold_variables_from_MFE(mfe_vars);
/* we dont need the mfe vars and arrays anymore, so we can savely free their occupying memory */
destroy_TwoDfold_variables(mfe_vars);
TwoDpfold_vars *q_vars = get_TwoDpfold_variables(string, structure1, structure2, circ);
TwoDpfold_solution *pf_s = TwoDpfoldList(q_vars, maxD1, maxD2);
Q = 0.;
for(i = 0; pf_s[i].k != INF; i++){
Q += pf_s[i].q;
}
double fee = (-log(Q)-length*log(pf_scale))*kT;
if(!stBT){
printf("free energy of ensemble = %6.2f kcal/mol\n",fee);
printf("k\tl\tP(neighborhood)\tP(MFE in neighborhood)\tP(MFE in ensemble)\tMFE\tE_gibbs\tMFE-structure\n");
for(i=0; pf_s[i].k != INF;i++){
float free_energy = (-log((float)pf_s[i].q)-length*log(pf_scale))*kT;
if((pf_s[i].k != mfe_s[i].k) || (pf_s[i].l != mfe_s[i].l))
nrerror("This should never happen!");
fprintf(stdout,
"%d\t%d\t%2.8f\t%2.8f\t%2.8f\t%6.2f\t%6.2f\t%s\n",
pf_s[i].k,
pf_s[i].l,
(float)(pf_s[i].q)/(float)Q,
exp((free_energy-mfe_s[i].en)/kT),
exp((fee-mfe_s[i].en)/kT),
mfe_s[i].en,
free_energy,
mfe_s[i].s);
}
}
else{
init_rand();
if(neighborhoods != NULL){
nbhoods *tmp, *tmp2;
for(tmp = neighborhoods; tmp != NULL; tmp = tmp->next){
int k,l;
k = tmp->k;
l = tmp->l;
for(i = 0; i < nstBT; i++){
char *s = TwoDpfold_pbacktrack(q_vars, k, l);
printf("%d\t%d\t%s\t%6.2f\n", k, l, s, q_vars->circ ? energy_of_circ_structure(q_vars->sequence, s, 0) : energy_of_structure(q_vars->sequence, s, 0));
}
}
}
else{
for(i=0; pf_s[i].k != INF;i++){
for(l = 0; l < nstBT; l++){
char *s = TwoDpfold_pbacktrack(q_vars, pf_s[i].k, pf_s[i].l);
printf("%d\t%d\t%s\t%6.2f\n", pf_s[i].k, pf_s[i].l, s, q_vars->circ ? energy_of_circ_structure(q_vars->sequence, s, 0) : energy_of_structure(q_vars->sequence, s, 0));
}
}
}
}
free_pf_arrays();
for(i=0; mfe_s[i].k != INF;i++){
if(mfe_s[i].s) free(mfe_s[i].s);
}
free(pf_s);
free(mfe_s);
/* destroy the q_vars */
destroy_TwoDpfold_variables(q_vars);
}
else
destroy_TwoDfold_variables(mfe_vars);
free_arrays();
free(string);
free(orig_sequence);
free(mfe_structure);
free(structure1);
free(structure2);
free(reference_struc1);
free(reference_struc2);
string = orig_sequence = mfe_structure = NULL;
} while (1);
return 0;
}
int main(int argc, char *argv[]){
struct RNAeval_args_info args_info;
char *string, *structure, *orig_sequence, *tmp;
char *rec_sequence, *rec_id, **rec_rest;
char fname[FILENAME_MAX_LENGTH];
char *ParamFile;
int i, length1, length2;
float energy;
int istty;
int circular=0;
int noconv=0;
int verbose = 0;
unsigned int rec_type, read_opt;
string = orig_sequence = ParamFile = NULL;
gquad = 0;
dangles = 2;
/*
#############################################
# check the command line parameters
#############################################
*/
if(RNAeval_cmdline_parser (argc, argv, &args_info) != 0) exit(1);
/* temperature */
if(args_info.temp_given) temperature = args_info.temp_arg;
/* do not take special tetra loop energies into account */
if(args_info.noTetra_given) tetra_loop=0;
/* set dangle model */
if(args_info.dangles_given){
if((args_info.dangles_arg < 0) || (args_info.dangles_arg > 3))
warn_user("required dangle model not implemented, falling back to default dangles=2");
else
dangles = args_info.dangles_arg;
}
/* do not convert DNA nucleotide "T" to appropriate RNA "U" */
if(args_info.noconv_given) noconv = 1;
/* set energy model */
if(args_info.energyModel_given) energy_set = args_info.energyModel_arg;
/* take another energy parameter set */
if(args_info.paramFile_given) ParamFile = strdup(args_info.paramFile_arg);
/* assume RNA sequence to be circular */
if(args_info.circ_given) circular=1;
/* logarithmic multiloop energies */
if(args_info.logML_given) logML = 1;
/* be verbose */
if(args_info.verbose_given) verbose = 1;
/* gquadruplex support */
if(args_info.gquad_given) gquad = 1;
/* free allocated memory of command line data structure */
RNAeval_cmdline_parser_free (&args_info);
/*
#############################################
# begin initializing
#############################################
*/
if (ParamFile!=NULL) read_parameter_file(ParamFile);
rec_type = read_opt = 0;
rec_id = rec_sequence = NULL;
rec_rest = NULL;
istty = isatty(fileno(stdout)) && isatty(fileno(stdin));
if(circular && gquad){
nrerror("G-Quadruplex support is currently not available for circular RNA structures");
}
/* set options we wanna pass to read_record */
if(istty){
read_opt |= VRNA_INPUT_NOSKIP_BLANK_LINES;
print_tty_input_seq_str("Use '&' to connect 2 sequences that shall form a complex.\n"
"Input sequence (upper or lower case) followed by structure");
}
/*
#############################################
# main loop: continue until end of file
#############################################
*/
while(
!((rec_type = read_record(&rec_id, &rec_sequence, &rec_rest, read_opt))
& (VRNA_INPUT_ERROR | VRNA_INPUT_QUIT))){
if(rec_id){
if(!istty) printf("%s\n", rec_id);
(void) sscanf(rec_id, ">%" XSTR(FILENAME_ID_LENGTH) "s", fname);
}
else fname[0] = '\0';
cut_point = -1;
string = tokenize(rec_sequence);
length2 = (int) strlen(string);
tmp = extract_record_rest_structure((const char **)rec_rest, 0, (rec_id) ? VRNA_OPTION_MULTILINE : 0);
if(!tmp)
nrerror("structure missing");
structure = tokenize(tmp);
length1 = (int) strlen(structure);
if(length1 != length2)
nrerror("structure and sequence differ in length!");
free(tmp);
/* convert DNA alphabet to RNA if not explicitely switched off */
if(!noconv) str_DNA2RNA(string);
/* store case-unmodified sequence */
orig_sequence = strdup(string);
/* convert sequence to uppercase letters only */
str_uppercase(string);
if(istty){
if (cut_point == -1)
printf("length = %d\n", length1);
else
printf("length1 = %d\nlength2 = %d\n", cut_point-1, length1-cut_point+1);
}
if(gquad)
energy = energy_of_gquad_structure(string, structure, verbose);
else
energy = (circular) ? energy_of_circ_structure(string, structure, verbose) : energy_of_structure(string, structure, verbose);
if (cut_point == -1)
printf("%s\n%s", orig_sequence, structure);
else {
char *pstring, *pstruct;
pstring = costring(orig_sequence);
pstruct = costring(structure);
printf("%s\n%s", pstring, pstruct);
free(pstring);
free(pstruct);
}
if (istty)
printf("\n energy = %6.2f\n", energy);
else
printf(" (%6.2f)\n", energy);
/* clean up */
(void) fflush(stdout);
if(rec_id) free(rec_id);
free(rec_sequence);
free(structure);
/* free the rest of current dataset */
if(rec_rest){
for(i=0;rec_rest[i];i++) free(rec_rest[i]);
free(rec_rest);
}
rec_id = rec_sequence = structure = NULL;
rec_rest = NULL;
free(string);
free(orig_sequence);
string = orig_sequence = NULL;
/* print user help for the next round if we get input from tty */
if(istty){
print_tty_input_seq_str("Use '&' to connect 2 sequences that shall form a complex.\n"
"Input sequence (upper or lower case) followed by structure");
}
}
return EXIT_SUCCESS;
}