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;
}