PUBLIC float
vrna_pf_fold( const char *seq,
char *structure,
vrna_plist_t **pl){
float free_energy;
double mfe;
vrna_fold_compound_t *vc;
vrna_md_t md;
vrna_md_set_default(&md);
/* no need to backtrack MFE structure */
md.backtrack = 0;
if(!pl){ /* no need for pair probability computations if we do not store them somewhere */
md.compute_bpp = 0;
}
vc = vrna_fold_compound(seq, &md, 0);
mfe = (double)vrna_pf(vc, NULL);
vrna_exp_params_rescale(vc, &mfe);
free_energy = vrna_pf(vc, structure);
/* fill plist */
if(pl){
*pl = vrna_plist_from_probs(vc, /*cut_off:*/ 1e-6);
}
vrna_fold_compound_free(vc);
return free_energy;
}
PUBLIC vrna_fold_compound_t *
vrna_fold_compound_TwoD(const char *sequence,
const char *s1,
const char *s2,
vrna_md_t *md_p,
unsigned int options){
int length, l, turn;
vrna_fold_compound_t *vc;
vrna_md_t md;
if(sequence == NULL) return NULL;
/* sanity check */
length = strlen(sequence);
if(length == 0)
vrna_message_error("vrna_fold_compound_TwoD: sequence length must be greater 0");
l = strlen(s1);
if(l != length)
vrna_message_error("vrna_fold_compound_TwoD: sequence and s1 differ in length");
l = strlen(s2);
if(l != length)
vrna_message_error("vrna_fold_compound_TwoD: sequence and s2 differ in length");
vc = vrna_alloc(sizeof(vrna_fold_compound_t));
vc->type = VRNA_VC_TYPE_SINGLE;
vc->length = length;
vc->sequence = strdup(sequence);
/* get a copy of the model details */
if(md_p)
md = *md_p;
else /* this fallback relies on global parameters and thus is not threadsafe */
vrna_md_set_default(&md);
/* always make uniq ML decomposition ! */
md.uniq_ML = 1;
md.compute_bpp = 0;
set_fold_compound(vc, &md, options, WITH_PTYPE | WITH_PTYPE_COMPAT);
if(!(options & VRNA_OPTION_EVAL_ONLY)){
vrna_hc_init(vc); /* add default hard constraints */
/* add DP matrices */
vrna_mx_add(vc, VRNA_MX_2DFOLD, options);
}
/* set all fields that are unique to Distance class partitioning... */
turn = vc->params->model_details.min_loop_size;
vc->reference_pt1 = vrna_ptable(s1);
vc->reference_pt2 = vrna_ptable(s2);
vc->referenceBPs1 = vrna_refBPcnt_matrix(vc->reference_pt1, turn);
vc->referenceBPs2 = vrna_refBPcnt_matrix(vc->reference_pt2, turn);
vc->bpdist = vrna_refBPdist_matrix(vc->reference_pt1, vc->reference_pt2, turn);
/* compute maximum matching with reference structure 1 disallowed */
vc->mm1 = maximumMatchingConstraint(vc->sequence, vc->reference_pt1);
/* compute maximum matching with reference structure 2 disallowed */
vc->mm2 = maximumMatchingConstraint(vc->sequence, vc->reference_pt2);
vc->maxD1 = vc->mm1[vc->iindx[1]-length] + vc->referenceBPs1[vc->iindx[1]-length];
vc->maxD2 = vc->mm2[vc->iindx[1]-length] + vc->referenceBPs2[vc->iindx[1]-length];
return vc;
}
PUBLIC vrna_fold_compound_t *
vrna_fold_compound_comparative( const char **sequences,
vrna_md_t *md_p,
unsigned int options){
int s, n_seq, length;
vrna_fold_compound_t *vc;
vrna_md_t md;
unsigned int aux_options;
aux_options = 0L;
if(sequences == NULL) return NULL;
for(s=0;sequences[s];s++); /* count the sequences */
n_seq = s;
length = strlen(sequences[0]);
/* sanity check */
if(length == 0)
vrna_message_error("vrna_fold_compound_comparative: sequence length must be greater 0");
for(s = 0; s < n_seq; s++)
if(strlen(sequences[s]) != length)
vrna_message_error("vrna_fold_compound_comparative: uneqal sequence lengths in alignment");
vc = vrna_alloc(sizeof(vrna_fold_compound_t));
vc->type = VRNA_VC_TYPE_ALIGNMENT;
vc->n_seq = n_seq;
vc->length = length;
vc->sequences = vrna_alloc(sizeof(char *) * (vc->n_seq + 1));
for(s = 0; sequences[s]; s++)
vc->sequences[s] = strdup(sequences[s]);
/* get a copy of the model details */
if(md_p)
md = *md_p;
else /* this fallback relies on global parameters and thus is not threadsafe */
vrna_md_set_default(&md);
aux_options |= WITH_PTYPE;
if(options & VRNA_OPTION_PF)
aux_options |= WITH_PTYPE_COMPAT;
set_fold_compound(vc, &md, options, aux_options);
make_pscores(vc);
if(!(options & VRNA_OPTION_EVAL_ONLY)){
/* add default hard constraints */
vrna_hc_init(vc);
/* add DP matrices (if required) */
vrna_mx_add(vc, VRNA_MX_DEFAULT, options);
}
return vc;
}
PUBLIC vrna_fold_compound_t *
vrna_fold_compound( const char *sequence,
vrna_md_t *md_p,
unsigned int options){
unsigned int i, length, aux_options;
vrna_fold_compound_t *vc;
vrna_md_t md;
if(sequence == NULL) return NULL;
/* sanity check */
length = strlen(sequence);
if(length == 0)
vrna_message_error("vrna_fold_compound: sequence length must be greater 0");
vc = vrna_alloc(sizeof(vrna_fold_compound_t));
vc->type = VRNA_VC_TYPE_SINGLE;
vc->length = length;
vc->sequence = strdup(sequence);
aux_options = 0L;
/* get a copy of the model details */
if(md_p)
md = *md_p;
else
vrna_md_set_default(&md);
if(options & VRNA_OPTION_WINDOW){ /* sliding window structure prediction */
if(md.window_size <= 0)
md.window_size = (int)vc->length;
else if(md.window_size > (int)vc->length)
md.window_size = (int)vc->length;
vc->window_size = md.window_size;
if((md.max_bp_span <= 0) || (md.max_bp_span > md.window_size))
md.max_bp_span = md.window_size;
set_fold_compound(vc, &md, options, aux_options);
vc->ptype_local = vrna_alloc(sizeof(char *)*(vc->length+1));
for (i = vc->length; ( i > vc->length - vc->window_size - 5) && (i >= 0); i--){
vc->ptype_local[i] = vrna_alloc(sizeof(char)*(vc->window_size+5));
}
if(!(options & VRNA_OPTION_EVAL_ONLY)){
/* add default hard constraints */
/* vrna_hc_init(vc); */ /* no hard constraints in Lfold, yet! */
/* add DP matrices */
vrna_mx_add(vc, VRNA_MX_WINDOW, options);
}
} else { /* regular global structure prediction */
/* set window size to entire sequence */
md.window_size = (int)vc->length;
aux_options |= WITH_PTYPE;
if(options & VRNA_OPTION_PF)
aux_options |= WITH_PTYPE_COMPAT;
set_fold_compound(vc, &md, options, aux_options);
if(!(options & VRNA_OPTION_EVAL_ONLY)){
/* add default hard constraints */
vrna_hc_init(vc);
/* add DP matrices (if required) */
vrna_mx_add(vc, VRNA_MX_DEFAULT, options);
}
}
return vc;
}
int main(int argc, char *argv[]){
struct RNAplot_args_info args_info;
char *structure, *pre, *post;
char fname[FILENAME_MAX_LENGTH], ffname[FILENAME_MAX_LENGTH];
char *rec_sequence, *rec_id, **rec_rest;
int i, length;
int istty;
char format[5]="ps";
unsigned int rec_type, read_opt;
vrna_md_t md;
structure = pre = post = NULL;
length = 0;
vrna_md_set_default(&md);
/*
#############################################
# check the command line parameters
#############################################
*/
if(RNAplot_cmdline_parser (argc, argv, &args_info) != 0) exit(1);
if(args_info.layout_type_given) rna_plot_type = args_info.layout_type_arg;
if(args_info.pre_given) pre = strdup(args_info.pre_arg);
if(args_info.post_given) post = strdup(args_info.post_arg);
if(args_info.output_format_given){
strncpy(format, args_info.output_format_arg, 4); format[4] = '\0';
}
/* free allocated memory of command line data structure */
RNAplot_cmdline_parser_free (&args_info);
/*
#############################################
# begin initializing
#############################################
*/
rec_type = read_opt = 0;
rec_id = rec_sequence = NULL;
rec_rest = NULL;
istty = isatty(fileno(stdout)) && isatty(fileno(stdin));
/* set options we wanna pass to vrna_file_fasta_read_record() */
if(istty){
read_opt |= VRNA_INPUT_NOSKIP_BLANK_LINES;
vrna_message_input_seq("Input sequence (upper or lower case) followed by structure");
}
/*
#############################################
# main loop: continue until end of file
#############################################
*/
while(
!((rec_type = vrna_file_fasta_read_record(&rec_id, &rec_sequence, &rec_rest, NULL, read_opt))
& (VRNA_INPUT_ERROR | VRNA_INPUT_QUIT))){
if(rec_id){
(void) sscanf(rec_id, ">%" XSTR(FILENAME_ID_LENGTH) "s", fname);
}
else fname[0] = '\0';
length = (int)strlen(rec_sequence);
structure = vrna_extract_record_rest_structure((const char **)rec_rest, 0, (rec_id) ? VRNA_OPTION_MULTILINE : 0);
if(!structure) vrna_message_error("structure missing");
if((int)strlen(structure) != length) vrna_message_error("structure and sequence differ in length!");
if (fname[0]!='\0'){
strcpy(ffname, fname);
strcat(ffname, "_ss");
} else
strcpy(ffname, "rna");
structure = NULL;
unsigned int struct_options = (rec_id) ? VRNA_OPTION_MULTILINE : 0;
structure = vrna_extract_record_rest_structure((const char **)rec_rest, 0, struct_options);
if(strlen(rec_sequence) != strlen(structure))
vrna_message_error("sequence and structure have unequal length");
switch (format[0]) {
case 'p':
strcat(ffname, ".ps");
(void) vrna_file_PS_rnaplot_a(rec_sequence, structure, ffname, pre, post, &md);
break;
case 'g':
strcat(ffname, ".gml");
gmlRNA(rec_sequence, structure, ffname, 'x');
break;
case 'x':
strcat(ffname, ".ss");
xrna_plot(rec_sequence, structure, ffname);
break;
case 's':
strcat(ffname, ".svg");
svg_rna_plot(rec_sequence, structure, ffname);
break;
default:
RNAplot_cmdline_parser_print_help(); exit(EXIT_FAILURE);
}
fflush(stdout);
/* clean up */
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;
/* print user help for the next round if we get input from tty */
if(istty){
vrna_message_input_seq("Input sequence (upper or lower case) followed by structure");
}
}
return EXIT_SUCCESS;
}
