PRIVATE void heat_capacity(char *string, float T_min, float T_max, float h, int m) { int length, i; char *structure; float hc, kT, min_en; length = (int) strlen(string); do_backtrack = 0; temperature = T_min -m*h; /* initialize_fold(length); <- obsolete */ structure = (char *) vrna_alloc((unsigned) length+1); min_en = fold(string, structure); free(structure); free_arrays(); kT = (temperature+K0)*GASCONST/1000; /* in kcal */ pf_scale = exp(-(1.07*min_en)/kT/length ); /* init_pf_fold(length); <- obsolete */ vrna_exp_param_t *pf_parameters = NULL; vrna_md_t md; set_model_details(&md); pf_parameters = get_boltzmann_factors(temperature, 1.0, md, pf_scale); update_pf_params_par(length, pf_parameters); for (i=0; i<2*m+1; i++) { F[i] = pf_fold_par(string, NULL, pf_parameters, 0, 0, 0); /* T_min -2h */ md.temperature = temperature += h; kT = (temperature+K0)*GASCONST/1000; pf_scale=exp(-(F[i]/length +h*0.00727)/kT); /* try to extrapolate F */ free(pf_parameters); pf_parameters = get_boltzmann_factors(temperature, 1.0, md, pf_scale); update_pf_params_par(length, pf_parameters); } while (temperature <= (T_max+m*h+h)) { hc = - ddiff(F,h,m)* (temperature +K0 - m*h -h); printf("%g %g\n", (temperature-m*h-h), hc); for (i=0; i<2*m; i++) F[i] = F[i+1]; F[2*m] = pf_fold_par(string, NULL, pf_parameters, 0, 0, 0); /* printf("%g\n", F[2*m]);*/ temperature += h; kT = (temperature+K0)*GASCONST/1000; pf_scale=exp(-(F[i]/length +h*0.00727)/kT); free(pf_parameters); md.temperature = temperature; pf_parameters = get_boltzmann_factors(temperature, 1.0, md, pf_scale); update_pf_params_par(length, pf_parameters); } free_pf_arrays(); }
int main(int argc, char *argv[]) { struct RNAcofold_args_info args_info; unsigned int input_type; char *string, *input_string; char *structure, *cstruc, *rec_sequence, *orig_sequence, *rec_id, **rec_rest; char fname[FILENAME_MAX_LENGTH], ffname[FILENAME_MAX_LENGTH]; char *ParamFile; char *ns_bases, *c; char *Concfile; int i, length, l, sym, r, cl; double min_en; double kT, sfact, betaScale; int pf, istty; int noconv, noPS; int doT; /*compute dimere free energies etc.*/ int doC; /*toggle to compute concentrations*/ int doQ; /*toggle to compute prob of base being paired*/ int cofi; /*toggle concentrations stdin / file*/ plist *prAB; plist *prAA; /*pair probabilities of AA dimer*/ plist *prBB; plist *prA; plist *prB; plist *mfAB; plist *mfAA; /*pair mfobabilities of AA dimer*/ plist *mfBB; plist *mfA; plist *mfB; double *ConcAandB; unsigned int rec_type, read_opt; pf_paramT *pf_parameters; model_detailsT md; /* ############################################# # init variables and parameter options ############################################# */ dangles = 2; sfact = 1.07; bppmThreshold = 1e-5; noconv = 0; noPS = 0; do_backtrack = 1; pf = 0; doT = 0; doC = 0; doQ = 0; cofi = 0; betaScale = 1.; gquad = 0; ParamFile = NULL; pf_parameters = NULL; string = NULL; Concfile = NULL; structure = NULL; cstruc = NULL; ns_bases = NULL; rec_type = read_opt = 0; rec_id = rec_sequence = orig_sequence = NULL; rec_rest = NULL; set_model_details(&md); /* ############################################# # check the command line prameters ############################################# */ if(RNAcofold_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 > 3)) 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; /* enforce canonical base pairs in any case? */ if(args_info.canonicalBPonly_given) md.canonicalBPonly = canonicalBPonly = 1; /* 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; /* */ if(args_info.noPS_given) noPS = 1; /* 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; if(args_info.all_pf_given) doT = pf = 1; /* concentrations from stdin */ if(args_info.concentrations_given) doC = doT = pf = 1; /* set the bppm threshold for the dotplot */ if(args_info.bppmThreshold_given) bppmThreshold = MIN2(1., MAX2(0.,args_info.bppmThreshold_arg)); /* concentrations in file */ if(args_info.betaScale_given) betaScale = args_info.betaScale_arg; if(args_info.concfile_given){ Concfile = strdup(args_info.concfile_arg); doC = cofi = doT = pf = 1; } /* partition function settings */ if(args_info.partfunc_given){ pf = 1; if(args_info.partfunc_arg != -1) do_backtrack = args_info.partfunc_arg; } /* free allocated memory of command line data structure */ RNAcofold_cmdline_parser_free (&args_info); /* ############################################# # begin initializing ############################################# */ if(pf && gquad){ nrerror("G-Quadruplex support is currently not available for partition function computations"); } 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)); /* print user help if we get input from tty */ if(istty){ printf("Use '&' to connect 2 sequences that shall form a complex.\n"); if(fold_constrained){ print_tty_constraint(VRNA_CONSTRAINT_DOT | VRNA_CONSTRAINT_X | VRNA_CONSTRAINT_ANG_BRACK | VRNA_CONSTRAINT_RND_BRACK); print_tty_input_seq_str("Input sequence (upper or lower case) followed by structure constraint\n"); } else print_tty_input_seq(); } /* set options we wanna pass to read_record */ if(istty) read_opt |= VRNA_INPUT_NOSKIP_BLANK_LINES; if(!fold_constrained) read_opt |= VRNA_INPUT_NO_REST; /* ############################################# # 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))){ /* ######################################################## # init everything according to the data we've read ######################################################## */ 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; rec_sequence = tokenize(rec_sequence); /* frees input_string and sets cut_point */ length = (int) strlen(rec_sequence); structure = (char *) space((unsigned) length+1); /* parse the rest of the current dataset to obtain a structure constraint */ if(fold_constrained){ cstruc = NULL; int cp = cut_point; unsigned int coptions = (rec_id) ? VRNA_CONSTRAINT_MULTILINE : 0; coptions |= VRNA_CONSTRAINT_DOT | VRNA_CONSTRAINT_X | VRNA_CONSTRAINT_ANG_BRACK | VRNA_CONSTRAINT_RND_BRACK; getConstraint(&cstruc, (const char **)rec_rest, coptions); cstruc = tokenize(cstruc); if(cut_point != cp) nrerror("cut point in sequence and structure constraint differs"); cl = (cstruc) ? (int)strlen(cstruc) : 0; if(cl == 0) warn_user("structure constraint is missing"); else if(cl < length) warn_user("structure constraint is shorter than sequence"); else if(cl > length) nrerror("structure constraint is too long"); if(cstruc) strncpy(structure, cstruc, sizeof(char)*(cl+1)); } /* convert DNA alphabet to RNA if not explicitely switched off */ if(!noconv) str_DNA2RNA(rec_sequence); /* store case-unmodified sequence */ orig_sequence = strdup(rec_sequence); /* convert sequence to uppercase letters only */ str_uppercase(rec_sequence); if(istty){ if (cut_point == -1) printf("length = %d\n", length); else printf("length1 = %d\nlength2 = %d\n", cut_point-1, length-cut_point+1); } /* ######################################################## # begin actual computations ######################################################## */ if (doC) { FILE *fp; if (cofi) { /* read from file */ fp = fopen(Concfile, "r"); if (fp==NULL) { fprintf(stderr, "could not open concentration file %s", Concfile); nrerror("\n"); } ConcAandB = read_concentrations(fp); fclose(fp); } else { printf("Please enter concentrations [mol/l]\n format: ConcA ConcB\n return to end\n"); ConcAandB = read_concentrations(stdin); } } /*compute mfe of AB dimer*/ min_en = cofold(rec_sequence, structure); assign_plist_from_db(&mfAB, structure, 0.95); { char *pstring, *pstruct; if (cut_point == -1) { pstring = strdup(orig_sequence); pstruct = strdup(structure); } else { pstring = costring(orig_sequence); pstruct = costring(structure); } printf("%s\n%s", pstring, pstruct); if (istty) printf("\n minimum free energy = %6.2f kcal/mol\n", min_en); else printf(" (%6.2f)\n", min_en); (void) fflush(stdout); if (!noPS) { char annot[512] = ""; if (fname[0]!='\0') { strcpy(ffname, fname); strcat(ffname, "_ss.ps"); } else { strcpy(ffname, "rna.ps"); } if (cut_point >= 0) sprintf(annot, "1 %d 9 0 0.9 0.2 omark\n%d %d 9 1 0.1 0.2 omark\n", cut_point-1, cut_point+1, length+1); if(gquad){ if (!noPS) (void) PS_rna_plot_a_gquad(pstring, pstruct, ffname, annot, NULL); } else { if (!noPS) (void) PS_rna_plot_a(pstring, pstruct, ffname, annot, NULL); } } free(pstring); free(pstruct); } if (length>2000) free_co_arrays(); /*compute partition function*/ if (pf) { cofoldF AB, AA, BB; FLT_OR_DBL *probs; if (dangles==1) { dangles=2; /* recompute with dangles as in pf_fold() */ min_en = energy_of_structure(rec_sequence, structure, 0); dangles=1; } 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); pf_parameters = get_boltzmann_factors(temperature, betaScale, md, pf_scale); if (cstruc!=NULL) strncpy(structure, cstruc, length+1); AB = co_pf_fold_par(rec_sequence, structure, pf_parameters, do_backtrack, fold_constrained); if (do_backtrack) { char *costruc; costruc = (char *) space(sizeof(char)*(strlen(structure)+2)); if (cut_point<0) printf("%s", structure); else { strncpy(costruc, structure, cut_point-1); strcat(costruc, "&"); strcat(costruc, structure+cut_point-1); printf("%s", costruc); } if (!istty) printf(" [%6.2f]\n", AB.FAB); else printf("\n");/*8.6.04*/ } if ((istty)||(!do_backtrack)) printf(" free energy of ensemble = %6.2f kcal/mol\n", AB.FAB); printf(" frequency of mfe structure in ensemble %g", exp((AB.FAB-min_en)/kT)); printf(" , delta G binding=%6.2f\n", AB.FcAB - AB.FA - AB.FB); probs = export_co_bppm(); assign_plist_from_pr(&prAB, probs, length, bppmThreshold); /* if (doQ) make_probsum(length,fname); */ /*compute prob of base paired*/ /* free_co_arrays(); */ if (doT) { /* cofold of all dimers, monomers */ int Blength, Alength; char *Astring, *Bstring, *orig_Astring, *orig_Bstring; char *Newstring; char Newname[30]; char comment[80]; if (cut_point<0) { printf("Sorry, i cannot do that with only one molecule, please give me two or leave it\n"); free(mfAB); free(prAB); continue; } if (dangles==1) dangles=2; Alength=cut_point-1; /*length of first molecule*/ Blength=length-cut_point+1; /*length of 2nd molecule*/ Astring=(char *)space(sizeof(char)*(Alength+1));/*Sequence of first molecule*/ Bstring=(char *)space(sizeof(char)*(Blength+1));/*Sequence of second molecule*/ strncat(Astring,rec_sequence,Alength); strncat(Bstring,rec_sequence+Alength,Blength); orig_Astring=(char *)space(sizeof(char)*(Alength+1));/*Sequence of first molecule*/ orig_Bstring=(char *)space(sizeof(char)*(Blength+1));/*Sequence of second molecule*/ strncat(orig_Astring,orig_sequence,Alength); strncat(orig_Bstring,orig_sequence+Alength,Blength); /* compute AA dimer */ AA=do_partfunc(Astring, Alength, 2, &prAA, &mfAA, pf_parameters); /* compute BB dimer */ BB=do_partfunc(Bstring, Blength, 2, &prBB, &mfBB, pf_parameters); /*free_co_pf_arrays();*/ /* compute A monomer */ do_partfunc(Astring, Alength, 1, &prA, &mfA, pf_parameters); /* compute B monomer */ do_partfunc(Bstring, Blength, 1, &prB, &mfB, pf_parameters); compute_probabilities(AB.F0AB, AB.FA, AB.FB, prAB, prA, prB, Alength); compute_probabilities(AA.F0AB, AA.FA, AA.FA, prAA, prA, prA, Alength); compute_probabilities(BB.F0AB, BB.FA, BB.FA, prBB, prA, prB, Blength); printf("Free Energies:\nAB\t\tAA\t\tBB\t\tA\t\tB\n%.6f\t%6f\t%6f\t%6f\t%6f\n", AB.FcAB, AA.FcAB, BB.FcAB, AB.FA, AB.FB); if (doC) { do_concentrations(AB.FcAB, AA.FcAB, BB.FcAB, AB.FA, AB.FB, ConcAandB); free(ConcAandB);/*freeen*/ } if (fname[0]!='\0') { strcpy(ffname, fname); strcat(ffname, "_dp5.ps"); } else strcpy(ffname, "dot5.ps"); /*output of the 5 dot plots*/ /*AB dot_plot*/ /*write Free Energy into comment*/ sprintf(comment,"\n%%Heterodimer AB FreeEnergy= %.9f\n", AB.FcAB); /*reset cut_point*/ cut_point=Alength+1; /*write New name*/ strcpy(Newname,"AB"); strcat(Newname,ffname); (void)PS_dot_plot_list(orig_sequence, Newname, prAB, mfAB, comment); /*AA dot_plot*/ sprintf(comment,"\n%%Homodimer AA FreeEnergy= %.9f\n",AA.FcAB); /*write New name*/ strcpy(Newname,"AA"); strcat(Newname,ffname); /*write AA sequence*/ Newstring=(char*)space((2*Alength+1)*sizeof(char)); strcpy(Newstring,orig_Astring); strcat(Newstring,orig_Astring); (void)PS_dot_plot_list(Newstring, Newname, prAA, mfAA, comment); free(Newstring); /*BB dot_plot*/ sprintf(comment,"\n%%Homodimer BB FreeEnergy= %.9f\n",BB.FcAB); /*write New name*/ strcpy(Newname,"BB"); strcat(Newname,ffname); /*write BB sequence*/ Newstring=(char*)space((2*Blength+1)*sizeof(char)); strcpy(Newstring,orig_Bstring); strcat(Newstring,orig_Bstring); /*reset cut_point*/ cut_point=Blength+1; (void)PS_dot_plot_list(Newstring, Newname, prBB, mfBB, comment); free(Newstring); /*A dot plot*/ /*reset cut_point*/ cut_point=-1; sprintf(comment,"\n%%Monomer A FreeEnergy= %.9f\n",AB.FA); /*write New name*/ strcpy(Newname,"A"); strcat(Newname,ffname); /*write BB sequence*/ (void)PS_dot_plot_list(orig_Astring, Newname, prA, mfA, comment); /*B monomer dot plot*/ sprintf(comment,"\n%%Monomer B FreeEnergy= %.9f\n",AB.FB); /*write New name*/ strcpy(Newname,"B"); strcat(Newname,ffname); /*write BB sequence*/ (void)PS_dot_plot_list(orig_Bstring, Newname, prB, mfB, comment); free(Astring); free(Bstring); free(orig_Astring); free(orig_Bstring); free(prAB); free(prAA); free(prBB); free(prA); free(prB); free(mfAB); free(mfAA); free(mfBB); free(mfA); free(mfB); } /*end if(doT)*/ free(pf_parameters); }/*end if(pf)*/ if (do_backtrack) { if (fname[0]!='\0') { strcpy(ffname, fname); strcat(ffname, "_dp.ps"); } else strcpy(ffname, "dot.ps"); if (!doT) { if (pf) { (void) PS_dot_plot_list(rec_sequence, ffname, prAB, mfAB, "doof"); free(prAB);} free(mfAB); } } if (!doT) free_co_pf_arrays(); (void) fflush(stdout); /* clean up */ if(cstruc) free(cstruc); if(rec_id) free(rec_id); free(rec_sequence); free(orig_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 = orig_sequence = structure = cstruc = NULL; rec_rest = NULL; /* print user help for the next round if we get input from tty */ if(istty){ printf("Use '&' to connect 2 sequences that shall form a complex.\n"); if(fold_constrained){ print_tty_constraint(VRNA_CONSTRAINT_DOT | VRNA_CONSTRAINT_X | VRNA_CONSTRAINT_ANG_BRACK | VRNA_CONSTRAINT_RND_BRACK); print_tty_input_seq_str("Input sequence (upper or lower case) followed by structure constraint\n"); } else print_tty_input_seq(); } } return EXIT_SUCCESS; }
PUBLIC pf_paramT *get_scaled_pf_parameters(void){ model_detailsT md; set_model_details(&md); return get_boltzmann_factors(temperature, 1.0, md, pf_scale); }
double score_seq( int s, char* seq, int ip ) { double score = 0.0; if( !is_legal( seq ) ) return score; int length = strlen( seq ); int* ix = get_iindx( length ); double betaScale = 1.0; double kT = ( betaScale*( ( temperature+K0 )*GASCONST ) )/1000.; /* in Kcal */ model_detailsT md; set_model_details( &md ); char* secstr = strdup( seq ); secstr[0] = 0; fold_constrained = 0; paramT* params = get_scaled_parameters( temperature, md ); double min_en = fold_par( seq, secstr, params, fold_constrained, 0 ); if( strncmp( secstr + ip, cnf->hairpin_ss, strlen( cnf->hairpin_ss ) ) != 0 || strcmp( secstr + length - strlen( cnf->tail3p_ss ), cnf->tail3p_ss ) != 0 ) { free( params ); free( secstr ); free( ix ); return score; } if( !is_legal_pair_content( seq, secstr, ip ) ) { free( params ); free( secstr ); free( ix ); return score; } #pragma omp atomic update num_scored++; double pf_scale = exp( -( 1.07*min_en )/kT/length ); pf_paramT* pf_params = get_boltzmann_factors( temperature, betaScale, md, pf_scale ); // Either patch fold_vars.h by inserting following at line 166 // // #ifdef _OPENMP // #pragma omp threadprivate(iindx) // #endif // // or uncomment this pragma below // // #pragma omp critical(pf_fold) double e = pf_fold_par( seq, NULL, pf_params, 1, fold_constrained, 0 ); FLT_OR_DBL* ppm = export_bppm(); #define pr_ij(i,j) (i == j? 0.0 : (i < j ? ppm[ix[i]-j] : ppm[ix[j]-i])) score = cnf->s_max; int i, o; for( i = 1; i <= length; i++ ) { for( o = 1; o <= strlen( cnf->hairpin_ss ); o++ ) { int j = ip + o; double v = pr_ij( i, j ); score -= v * ( 1.0 - v ); } } score *= cnf->s_scale; free( pf_params ); free( params ); free( secstr ); free( ix ); return score; }
/*--------------------------------------------------------------------------*/ int main(int argc, char *argv[]){ struct RNAplfold_args_info args_info; unsigned int error = 0; char fname[FILENAME_MAX_LENGTH], ffname[FILENAME_MAX_LENGTH], *c, *structure, *ParamFile, *ns_bases, *rec_sequence, *rec_id, **rec_rest, *orig_sequence; unsigned int input_type; int i, length, l, sym, r, istty, winsize, pairdist; float cutoff; int tempwin, temppair, tempunpaired; FILE *pUfp = NULL, *spup = NULL; double **pup = NULL; /*prob of being unpaired, lengthwise*/ int noconv, plexoutput, simply_putout, openenergies, binaries; plist *pl, *dpp = NULL; unsigned int rec_type, read_opt; double betaScale; pf_paramT *pf_parameters; model_detailsT md; dangles = 2; cutoff = 0.01; winsize = 70; pairdist = 0; unpaired = 0; betaScale = 1.; simply_putout = plexoutput = openenergies = noconv = 0;binaries=0; tempwin = temppair = tempunpaired = 0; structure = ParamFile = ns_bases = NULL; rec_type = read_opt = 0; rec_id = rec_sequence = orig_sequence = NULL; rec_rest = NULL; pf_parameters = NULL; set_model_details(&md); /* ############################################# # check the command line parameters ############################################# */ if(RNAplfold_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) 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; /* 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); /* 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 the maximum base pair span */ if(args_info.span_given) pairdist = args_info.span_arg; /* set the pair probability cutoff */ if(args_info.cutoff_given) cutoff = args_info.cutoff_arg; /* set the windowsize */ if(args_info.winsize_given) winsize = args_info.winsize_arg; /* set the length of unstructured region */ if(args_info.ulength_given) unpaired = args_info.ulength_arg; /* compute opening energies */ if(args_info.opening_energies_given) openenergies = 1; /* print output on the fly */ if(args_info.print_onthefly_given) simply_putout = 1; /* turn on RNAplex output */ if(args_info.plex_output_given) plexoutput = 1; /* turn on binary output*/ if(args_info.binaries_given) binaries = 1; if(args_info.betaScale_given) betaScale = args_info.betaScale_arg; /* check for errorneous parameter options */ if((pairdist < 0) || (cutoff < 0.) || (unpaired < 0) || (winsize < 0)){ RNAplfold_cmdline_parser_print_help(); exit(EXIT_FAILURE); } /* free allocated memory of command line data structure */ RNAplfold_cmdline_parser_free(&args_info); /* ############################################# # begin initializing ############################################# */ 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++; } } /* check parameter options again and reset to reasonable values if needed */ if(openenergies && !unpaired) unpaired = 31; if(pairdist == 0) pairdist = winsize; if(pairdist > winsize){ fprintf(stderr, "pairdist (-L %d) should be <= winsize (-W %d);" "Setting pairdist=winsize\n",pairdist, winsize); pairdist = winsize; } if(dangles % 2){ warn_user("using default dangles = 2"); dangles = 2; } istty = isatty(fileno(stdout))&&isatty(fileno(stdin)); read_opt |= VRNA_INPUT_NO_REST; if(istty){ print_tty_input_seq(); read_opt |= VRNA_INPUT_NOSKIP_BLANK_LINES; } /* ############################################# # 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))){ /* ######################################################## # init everything according to the data we've read ######################################################## */ if(rec_id){ if(!istty) printf("%s\n", rec_id); (void) sscanf(rec_id, ">%" XSTR(FILENAME_ID_LENGTH) "s", fname); } else fname[0] = '\0'; length = (int)strlen(rec_sequence); structure = (char *) space((unsigned) length+1); /* convert DNA alphabet to RNA if not explicitely switched off */ if(!noconv) str_DNA2RNA(rec_sequence); /* store case-unmodified sequence */ orig_sequence = strdup(rec_sequence); /* convert sequence to uppercase letters only */ str_uppercase(rec_sequence); if(istty) printf("length = %d\n", length); /* ######################################################## # done with 'stdin' handling ######################################################## */ if(length > 1000000){ if(!simply_putout && !unpaired){ printf("Switched to simple output mode!!!\n"); simply_putout = 1; } } if(unpaired && simply_putout){ printf("Output simplification not possible if unpaired is switched on\n"); simply_putout = 0; } /* restore winsize if altered before */ if(tempwin != 0){ winsize = tempwin; tempwin = 0; } /* restore pairdist if altered before */ if(temppair != 0){ pairdist = temppair; temppair = 0; } /* restore ulength if altered before */ if(tempunpaired != 0){ unpaired = tempunpaired; tempunpaired = 0; } /* adjust winsize, pairdist and ulength if necessary */ if(length < winsize){ fprintf(stderr, "WARN: window size %d larger than sequence length %d\n", winsize, length); tempwin = winsize; winsize = length; if (pairdist>winsize) { temppair=pairdist; pairdist=winsize; } if (unpaired>winsize) { tempunpaired=unpaired; unpaired=winsize; } } /* ######################################################## # begin actual computations ######################################################## */ if (length >= 5){ /* construct output file names */ char fname1[FILENAME_MAX_LENGTH], fname2[FILENAME_MAX_LENGTH], fname3[FILENAME_MAX_LENGTH], fname4[FILENAME_MAX_LENGTH], fname_t[FILENAME_MAX_LENGTH]; strcpy(fname_t, (fname[0] != '\0') ? fname : "plfold"); strcpy(fname1, fname_t); strcpy(fname2, fname_t); strcpy(fname3, fname_t); strcpy(fname4, fname_t); strcpy(ffname, fname_t); strcat(fname1, "_lunp"); strcat(fname2, "_basepairs"); strcat(fname3, "_uplex"); if(binaries){ strcat(fname4, "_openen_bin"); } else{ strcat(fname4, "_openen"); } strcat(ffname, "_dp.ps"); pf_parameters = get_boltzmann_factors(temperature, betaScale, md, -1); if(unpaired > 0){ pup =(double **) space((length+1)*sizeof(double *)); pup[0] =(double *) space(sizeof(double)); /*I only need entry 0*/ pup[0][0] = unpaired; } pUfp = spup = NULL; if(simply_putout){ spup = fopen(fname2, "w"); pUfp = (unpaired > 0) ? fopen(fname1, "w") : NULL; pl = pfl_fold_par(rec_sequence, winsize, pairdist, cutoff, pup, &dpp, pUfp, spup, pf_parameters); if(pUfp != NULL) fclose(pUfp); if(spup != NULL) fclose(spup); } else{ pl = pfl_fold_par(rec_sequence, winsize, pairdist, cutoff, pup, &dpp, pUfp, spup, pf_parameters); PS_dot_plot_turn(orig_sequence, pl, ffname, pairdist); if (unpaired > 0){ if(plexoutput){ pUfp = fopen(fname3, "w"); putoutphakim_u(pup,length, unpaired, pUfp); fclose(pUfp); } pUfp = fopen(openenergies ? fname4 : fname1, "w"); if(binaries){ putoutpU_prob_bin_par(pup, length, unpaired, pUfp, openenergies, pf_parameters); } else{ putoutpU_prob_par(pup, length, unpaired, pUfp, openenergies, pf_parameters); } fclose(pUfp); } } if(pl) free(pl); if(unpaired > 0){ free(pup[0]); free(pup); } free(pf_parameters); } (void) fflush(stdout); /* clean up */ if(rec_id) free(rec_id); free(rec_sequence); free(orig_sequence); free(structure); rec_id = rec_sequence = orig_sequence = NULL; rec_rest = NULL; /* print user help for the next round if we get input from tty */ if(istty) print_tty_input_seq(); } return EXIT_SUCCESS; }