1 /*
2 * Model Details structure creation/modification/destruction
3 *
4 * This file contains everything which is necessary to
5 * obtain, modify, and destroy the model_details datastructure
6 * used in the folding recurrences throughout the ViennaRNA
7 * Package
8 *
9 * c Ronny Lorenx
10 *
11 * Vienna RNA package
12 */
13
14 #ifdef HAVE_CONFIG_H
15 #include "config.h"
16 #endif
17
18 #include <stdio.h>
19 #include <stdlib.h>
20 #include <math.h>
21 #include <ctype.h>
22 #include <string.h>
23 #include <limits.h>
24
25 #include "ViennaRNA/params/constants.h"
26 #include "ViennaRNA/utils/basic.h"
27 #include "ViennaRNA/alphabet.h"
28 #include "ViennaRNA/model.h"
29
30 /*
31 #################################
32 # PRIVATE MACROS #
33 #################################
34 */
35
36 /*
37 #################################
38 # GLOBAL VARIABLES #
39 #################################
40 */
41
42 #ifndef VRNA_DISABLE_BACKWARD_COMPATIBILITY
43
44 /* below are the evil global variables that will vanish
45 * as soon as we drop backward compatibility in ViennaRNA
46 * Package v3
47 */
48
49 double temperature = VRNA_MODEL_DEFAULT_TEMPERATURE;
50 double pf_scale = VRNA_MODEL_DEFAULT_PF_SCALE;
51 int dangles = VRNA_MODEL_DEFAULT_DANGLES;
52 int tetra_loop = VRNA_MODEL_DEFAULT_SPECIAL_HP;
53 int noLonelyPairs = VRNA_MODEL_DEFAULT_NO_LP;
54 int noGU = VRNA_MODEL_DEFAULT_NO_GU;
55 int no_closingGU = VRNA_MODEL_DEFAULT_NO_GU_CLOSURE;
56 int circ = VRNA_MODEL_DEFAULT_CIRC;
57 int gquad = VRNA_MODEL_DEFAULT_GQUAD;
58 int uniq_ML = VRNA_MODEL_DEFAULT_UNIQ_ML;
59 int energy_set = VRNA_MODEL_DEFAULT_ENERGY_SET;
60 int do_backtrack = VRNA_MODEL_DEFAULT_COMPUTE_BPP;
61 char backtrack_type = VRNA_MODEL_DEFAULT_BACKTRACK_TYPE;
62 char *nonstandards = NULL;
63 int max_bp_span = VRNA_MODEL_DEFAULT_MAX_BP_SPAN;
64 int oldAliEn = VRNA_MODEL_DEFAULT_ALI_OLD_EN;
65 int ribo = VRNA_MODEL_DEFAULT_ALI_RIBO;
66 double cv_fact = VRNA_MODEL_DEFAULT_ALI_CV_FACT;
67 double nc_fact = VRNA_MODEL_DEFAULT_ALI_NC_FACT;
68 int logML = VRNA_MODEL_DEFAULT_LOG_ML;
69
70 /* below are some more deprecated global symbols we need to get rid off */
71
72 int james_rule = 1; /* interior loops of size 2 get energy 0.8Kcal and
73 * no mismatches (no longer used) */
74 char *RibosumFile = NULL; /* TODO: compile ribosums into program
75 * Warning: this variable will vanish */
76 int csv = 0; /*generate comma seperated output*/
77 vrna_bp_stack_t *base_pair = NULL;
78 FLT_OR_DBL *pr = NULL; /* base pairing prob. matrix */
79 int *iindx = NULL; /* pr[i,j] -> pr[iindx[i]-j] */
80 int fold_constrained = 0; /* fold with constraints */
81
82 #endif
83
84 /*
85 #################################
86 # PRIVATE VARIABLES #
87 #################################
88 */
89 PRIVATE int BP_pair[NBASES][NBASES] =
90 /* _ A C G U X K I */
91 { { 0, 0, 0, 0, 0, 0, 0, 0 },
92 { 0, 0, 0, 0, 5, 0, 0, 5 },
93 { 0, 0, 0, 1, 0, 0, 0, 0 },
94 { 0, 0, 2, 0, 3, 0, 0, 0 },
95 { 0, 6, 0, 4, 0, 0, 0, 6 },
96 { 0, 0, 0, 0, 0, 0, 2, 0 },
97 { 0, 0, 0, 0, 0, 1, 0, 0 },
98 { 0, 6, 0, 0, 5, 0, 0, 0 } };
99
100 PRIVATE vrna_md_t defaults = {
101 VRNA_MODEL_DEFAULT_TEMPERATURE,
102 1.,
103 VRNA_MODEL_DEFAULT_PF_SMOOTH,
104 VRNA_MODEL_DEFAULT_DANGLES,
105 VRNA_MODEL_DEFAULT_SPECIAL_HP,
106 VRNA_MODEL_DEFAULT_NO_LP,
107 VRNA_MODEL_DEFAULT_NO_GU,
108 VRNA_MODEL_DEFAULT_NO_GU_CLOSURE,
109 VRNA_MODEL_DEFAULT_LOG_ML,
110 VRNA_MODEL_DEFAULT_CIRC,
111 VRNA_MODEL_DEFAULT_GQUAD,
112 VRNA_MODEL_DEFAULT_UNIQ_ML,
113 VRNA_MODEL_DEFAULT_ENERGY_SET,
114 VRNA_MODEL_DEFAULT_BACKTRACK,
115 VRNA_MODEL_DEFAULT_BACKTRACK_TYPE,
116 VRNA_MODEL_DEFAULT_COMPUTE_BPP,
117 { 0 },
118 VRNA_MODEL_DEFAULT_MAX_BP_SPAN,
119 TURN,
120 VRNA_MODEL_DEFAULT_WINDOW_SIZE,
121 VRNA_MODEL_DEFAULT_ALI_OLD_EN,
122 VRNA_MODEL_DEFAULT_ALI_RIBO,
123 VRNA_MODEL_DEFAULT_ALI_CV_FACT,
124 VRNA_MODEL_DEFAULT_ALI_NC_FACT,
125 1.07,
126 { 0, 2, 1, 4, 3, 6, 5, 7 },
127 { 0, 1, 2, 3, 4, 3, 2, 0 },
128 {
129 { 0, 0, 0, 0, 0, 0, 0, 0 },
130 { 0, 0, 0, 0, 5, 0, 0, 5 },
131 { 0, 0, 0, 1, 0, 0, 0, 0 },
132 { 0, 0, 2, 0, 3, 0, 0, 0 },
133 { 0, 6, 0, 4, 0, 0, 0, 6 },
134 { 0, 0, 0, 0, 0, 0, 2, 0 },
135 { 0, 0, 0, 0, 0, 1, 0, 0 },
136 { 0, 6, 0, 0, 5, 0, 0, 0 }
137 }
138 };
139
140 /*
141 #################################
142 # PRIVATE FUNCTION DECLARATIONS #
143 #################################
144 */
145
146 /* Fill the base pair type encodings according to the model details */
147 PRIVATE void
148 fill_pair_matrices(vrna_md_t *md);
149
150
151 PRIVATE void
152 copy_nonstandards(vrna_md_t *md,
153 const char *ns);
154
155
156 PRIVATE void
157 prepare_default_pairs(vrna_md_t *md);
158
159
160 /*
161 #################################
162 # BEGIN OF FUNCTION DEFINITIONS #
163 #################################
164 */
165 PUBLIC vrna_md_t *
vrna_md_copy(vrna_md_t * md_to,const vrna_md_t * md_from)166 vrna_md_copy(vrna_md_t *md_to,
167 const vrna_md_t *md_from)
168 {
169 int i;
170 vrna_md_t *md;
171
172 md = NULL;
173
174 /* only process if md_from is non-NULL */
175 if (md_from) {
176 if (!md_to)
177 /* create container to be filled */
178 md = (vrna_md_t *)vrna_alloc(sizeof(vrna_md_t));
179 else
180 /* or directly write to target */
181 md = md_to;
182
183 /* check if not the same object */
184 if (md_to != md_from) {
185 /* copy simple members */
186 memcpy(md, md_from, sizeof(vrna_md_t));
187 /* copy arrays */
188 memcpy(md->rtype, &(md_from->rtype[0]), 8 * sizeof(int));
189 memcpy(md->alias, &(md_from->alias[0]), (MAXALPHA + 1) * sizeof(short));
190 memcpy(md->nonstandards, &(md_from->nonstandards[0]), 64 * sizeof(char));
191 /* copy matrices */
192 for (i = 0; i <= MAXALPHA; i++)
193 memcpy(md->pair[i], (md_from->pair[i]), (MAXALPHA + 1) * sizeof(int));
194 }
195 }
196
197 return md;
198 }
199
200
201 PUBLIC void
vrna_md_set_default(vrna_md_t * md)202 vrna_md_set_default(vrna_md_t *md)
203 {
204 if (md) /* copy defaults */
205 vrna_md_copy(md, &defaults);
206 }
207
208
209 PUBLIC char *
vrna_md_option_string(vrna_md_t * md)210 vrna_md_option_string(vrna_md_t *md)
211 {
212 static char options[255];
213
214 *options = '\0';
215
216 if (md) {
217 if (md->dangles != VRNA_MODEL_DEFAULT_DANGLES)
218 sprintf(options + strlen(options), "-d%d ", md->dangles);
219
220 if (!md->special_hp)
221 strcat(options, "-4 ");
222
223 if (md->noLP)
224 strcat(options, "--noLP ");
225
226 if (md->noGU)
227 strcat(options, "--noGU ");
228
229 if (md->noGUclosure)
230 strcat(options, "--noClosingGU ");
231
232 if (md->temperature != VRNA_MODEL_DEFAULT_TEMPERATURE)
233 sprintf(options + strlen(options), "-T %f ", md->temperature);
234 }
235
236 return options;
237 }
238
239
240 PRIVATE void
copy_nonstandards(vrna_md_t * md,const char * ns)241 copy_nonstandards(vrna_md_t *md,
242 const char *ns)
243 {
244 unsigned int n = strlen(ns);
245
246 if (n < 64) {
247 memcpy(md->nonstandards, ns, strlen(ns) * sizeof(char));
248 md->nonstandards[n] = '\0';
249 }
250 }
251
252
253 PUBLIC void
vrna_md_set_nonstandards(vrna_md_t * md,const char * ns_bases)254 vrna_md_set_nonstandards(vrna_md_t *md,
255 const char *ns_bases)
256 {
257 const char *c;
258 unsigned int n;
259 int i, sym;
260
261 if (md) {
262 if (ns_bases) {
263 n = strlen(ns_bases);
264 if (n < 33) {
265 /* parse the ns_bases list */
266 c = ns_bases;
267 i = sym = 0;
268 if (*c == '-') {
269 sym = 1;
270 c++;
271 }
272
273 while (*c != '\0') {
274 if (*c != ',') {
275 md->nonstandards[i++] = *c++;
276 md->nonstandards[i++] = *c;
277 if ((sym) && (*c != *(c - 1))) {
278 md->nonstandards[i++] = *c;
279 md->nonstandards[i++] = *(c - 1);
280 }
281 }
282
283 c++;
284 }
285 md->nonstandards[i] = '\0';
286
287 #ifndef VRNA_DISABLE_BACKWARD_COMPATIBILITY
288 free(nonstandards);
289 nonstandards = vrna_alloc(33);
290 memcpy(nonstandards, &(md->nonstandards[0]), 33 * sizeof(char));
291 #endif
292 } else {
293 vrna_message_warning("vrna_md_set_nonstandards: list too long, dropping nonstandards!");
294 }
295 } else {
296 /* remove nonstandards */
297 md->nonstandards[0] = '\0';
298 #ifndef VRNA_DISABLE_BACKWARD_COMPATIBILITY
299 free(nonstandards);
300 nonstandards = NULL;
301 #endif
302 }
303
304 /* update pair/rtype/alias arrays accordingly */
305 vrna_md_update(md);
306 }
307 }
308
309
310 PUBLIC void
vrna_md_defaults_reset(vrna_md_t * md_p)311 vrna_md_defaults_reset(vrna_md_t *md_p)
312 {
313 /* first, reset to factory defaults */
314 defaults.dangles = VRNA_MODEL_DEFAULT_DANGLES;
315 defaults.special_hp = VRNA_MODEL_DEFAULT_SPECIAL_HP;
316 defaults.noLP = VRNA_MODEL_DEFAULT_NO_LP;
317 defaults.noGU = VRNA_MODEL_DEFAULT_NO_GU;
318 defaults.noGUclosure = VRNA_MODEL_DEFAULT_NO_GU_CLOSURE;
319 defaults.logML = VRNA_MODEL_DEFAULT_LOG_ML;
320 defaults.gquad = VRNA_MODEL_DEFAULT_GQUAD;
321 defaults.circ = VRNA_MODEL_DEFAULT_CIRC;
322 defaults.uniq_ML = VRNA_MODEL_DEFAULT_UNIQ_ML;
323 defaults.compute_bpp = VRNA_MODEL_DEFAULT_COMPUTE_BPP;
324 defaults.backtrack = VRNA_MODEL_DEFAULT_BACKTRACK;
325 defaults.backtrack_type = VRNA_MODEL_DEFAULT_BACKTRACK_TYPE;
326 defaults.energy_set = VRNA_MODEL_DEFAULT_ENERGY_SET;
327 defaults.max_bp_span = VRNA_MODEL_DEFAULT_MAX_BP_SPAN;
328 defaults.min_loop_size = TURN;
329 defaults.window_size = VRNA_MODEL_DEFAULT_WINDOW_SIZE;
330 defaults.oldAliEn = VRNA_MODEL_DEFAULT_ALI_OLD_EN;
331 defaults.ribo = VRNA_MODEL_DEFAULT_ALI_RIBO;
332 defaults.cv_fact = VRNA_MODEL_DEFAULT_ALI_CV_FACT;
333 defaults.nc_fact = VRNA_MODEL_DEFAULT_ALI_NC_FACT;
334 defaults.temperature = VRNA_MODEL_DEFAULT_TEMPERATURE;
335 defaults.betaScale = VRNA_MODEL_DEFAULT_BETA_SCALE;
336 defaults.pf_smooth = VRNA_MODEL_DEFAULT_PF_SMOOTH;
337 defaults.sfact = 1.07;
338 defaults.nonstandards[0] = '\0';
339
340 if (md_p) {
341 /* now try to apply user settings */
342 /*
343 * Note that we use wrapper functions here instead of
344 * faster direct memory copy because we want to ensure
345 * that model settings always comply to the constraints
346 * we set in the wrappers
347 */
348 vrna_md_defaults_dangles(md_p->dangles);
349 vrna_md_defaults_special_hp(md_p->special_hp);
350 vrna_md_defaults_noLP(md_p->noLP);
351 vrna_md_defaults_noGU(md_p->noGU);
352 vrna_md_defaults_noGUclosure(md_p->noGUclosure);
353 vrna_md_defaults_logML(md_p->logML);
354 vrna_md_defaults_gquad(md_p->gquad);
355 vrna_md_defaults_circ(md_p->circ);
356 vrna_md_defaults_uniq_ML(md_p->uniq_ML);
357 vrna_md_defaults_compute_bpp(md_p->compute_bpp);
358 vrna_md_defaults_backtrack(md_p->backtrack);
359 vrna_md_defaults_backtrack_type(md_p->backtrack_type);
360 vrna_md_defaults_energy_set(md_p->energy_set);
361 vrna_md_defaults_max_bp_span(md_p->max_bp_span);
362 vrna_md_defaults_min_loop_size(md_p->min_loop_size);
363 vrna_md_defaults_window_size(md_p->window_size);
364 vrna_md_defaults_oldAliEn(md_p->oldAliEn);
365 vrna_md_defaults_ribo(md_p->ribo);
366 vrna_md_defaults_cv_fact(md_p->cv_fact);
367 vrna_md_defaults_nc_fact(md_p->nc_fact);
368 vrna_md_defaults_temperature(md_p->temperature);
369 vrna_md_defaults_betaScale(md_p->betaScale);
370 vrna_md_defaults_pf_smooth(md_p->pf_smooth);
371 vrna_md_defaults_sfact(md_p->sfact);
372 copy_nonstandards(&defaults, &(md_p->nonstandards[0]));
373 }
374
375 /* update pair/rtype/alias arrays accordingly */
376 vrna_md_update(&defaults);
377
378 #ifndef VRNA_DISABLE_BACKWARD_COMPATIBILITY
379 temperature = defaults.temperature;
380 pf_scale = VRNA_MODEL_DEFAULT_PF_SCALE;
381 dangles = defaults.dangles;
382 tetra_loop = defaults.special_hp;
383 noLonelyPairs = defaults.noLP;
384 noGU = defaults.noGU;
385 no_closingGU = defaults.noGUclosure;
386 circ = defaults.circ;
387 gquad = defaults.gquad;
388 uniq_ML = defaults.uniq_ML;
389 energy_set = defaults.energy_set;
390 do_backtrack = defaults.compute_bpp;
391 backtrack_type = defaults.backtrack_type;
392 nonstandards = defaults.nonstandards;
393 max_bp_span = defaults.max_bp_span;
394 oldAliEn = defaults.oldAliEn;
395 ribo = defaults.ribo;
396 cv_fact = defaults.cv_fact;
397 nc_fact = defaults.nc_fact;
398 logML = defaults.logML;
399 #endif
400 }
401
402
403 /* below are the setter functions for global default settings */
404
405 PUBLIC void
vrna_md_defaults_temperature(double T)406 vrna_md_defaults_temperature(double T)
407 {
408 if (T >= -K0) {
409 defaults.temperature = T;
410 #ifndef VRNA_DISABLE_BACKWARD_COMPATIBILITY
411 temperature = T;
412 #endif
413 } else {
414 vrna_message_warning(
415 "vrna_md_defaults_temperature@model.c: Temperature out of range, T must be above absolute zero. Not changing anything!");
416 }
417 }
418
419
420 PUBLIC double
vrna_md_defaults_temperature_get(void)421 vrna_md_defaults_temperature_get(void)
422 {
423 return defaults.temperature;
424 }
425
426
427 PUBLIC void
vrna_md_defaults_betaScale(double b)428 vrna_md_defaults_betaScale(double b)
429 {
430 defaults.betaScale = b;
431 }
432
433
434 PUBLIC double
vrna_md_defaults_betaScale_get(void)435 vrna_md_defaults_betaScale_get(void)
436 {
437 return defaults.betaScale;
438 }
439
440
441 PUBLIC void
vrna_md_defaults_pf_smooth(int s)442 vrna_md_defaults_pf_smooth(int s)
443 {
444 defaults.pf_smooth = s;
445 }
446
447
448 PUBLIC int
vrna_md_defaults_pf_smooth_get(void)449 vrna_md_defaults_pf_smooth_get(void)
450 {
451 return defaults.pf_smooth;
452 }
453
454
455 PUBLIC void
vrna_md_defaults_dangles(int d)456 vrna_md_defaults_dangles(int d)
457 {
458 if ((d >= 0) && (d <= 3)) {
459 defaults.dangles = d;
460 #ifndef VRNA_DISABLE_BACKWARD_COMPATIBILITY
461 dangles = d;
462 #endif
463 } else {
464 vrna_message_warning(
465 "vrna_md_defaults_dangles@model.c: Dangles out of range, must be (0 <= d <= 3). Not changing anything!");
466 }
467 }
468
469
470 PUBLIC int
vrna_md_defaults_dangles_get(void)471 vrna_md_defaults_dangles_get(void)
472 {
473 return defaults.dangles;
474 }
475
476
477 PUBLIC void
vrna_md_defaults_special_hp(int flag)478 vrna_md_defaults_special_hp(int flag)
479 {
480 defaults.special_hp = flag ? 1 : 0;
481 #ifndef VRNA_DISABLE_BACKWARD_COMPATIBILITY
482 tetra_loop = defaults.special_hp;
483 #endif
484 }
485
486
487 PUBLIC int
vrna_md_defaults_special_hp_get(void)488 vrna_md_defaults_special_hp_get(void)
489 {
490 return defaults.special_hp;
491 }
492
493
494 PUBLIC void
vrna_md_defaults_noLP(int flag)495 vrna_md_defaults_noLP(int flag)
496 {
497 defaults.noLP = flag ? 1 : 0;
498 #ifndef VRNA_DISABLE_BACKWARD_COMPATIBILITY
499 noLonelyPairs = defaults.noLP;
500 #endif
501 }
502
503
504 PUBLIC int
vrna_md_defaults_noLP_get(void)505 vrna_md_defaults_noLP_get(void)
506 {
507 return defaults.noLP;
508 }
509
510
511 PUBLIC void
vrna_md_defaults_noGU(int flag)512 vrna_md_defaults_noGU(int flag)
513 {
514 defaults.noGU = flag ? 1 : 0;
515 #ifndef VRNA_DISABLE_BACKWARD_COMPATIBILITY
516 noGU = defaults.noGU;
517 #endif
518 /* update pair/rtype/alias arrays accordingly */
519 vrna_md_update(&defaults);
520 }
521
522
523 PUBLIC int
vrna_md_defaults_noGU_get(void)524 vrna_md_defaults_noGU_get(void)
525 {
526 return defaults.noGU;
527 }
528
529
530 PUBLIC void
vrna_md_defaults_noGUclosure(int flag)531 vrna_md_defaults_noGUclosure(int flag)
532 {
533 defaults.noGUclosure = flag ? 1 : 0;
534 #ifndef VRNA_DISABLE_BACKWARD_COMPATIBILITY
535 no_closingGU = defaults.noGUclosure;
536 #endif
537 }
538
539
540 PUBLIC int
vrna_md_defaults_noGUclosure_get(void)541 vrna_md_defaults_noGUclosure_get(void)
542 {
543 return defaults.noGUclosure;
544 }
545
546
547 PUBLIC void
vrna_md_defaults_logML(int flag)548 vrna_md_defaults_logML(int flag)
549 {
550 defaults.logML = flag ? 1 : 0;
551 #ifndef VRNA_DISABLE_BACKWARD_COMPATIBILITY
552 logML = defaults.logML;
553 #endif
554 }
555
556
557 PUBLIC int
vrna_md_defaults_logML_get(void)558 vrna_md_defaults_logML_get(void)
559 {
560 return defaults.logML;
561 }
562
563
564 PUBLIC void
vrna_md_defaults_circ(int flag)565 vrna_md_defaults_circ(int flag)
566 {
567 defaults.circ = flag ? 1 : 0;
568 #ifndef VRNA_DISABLE_BACKWARD_COMPATIBILITY
569 circ = defaults.circ;
570 #endif
571 }
572
573
574 PUBLIC int
vrna_md_defaults_circ_get(void)575 vrna_md_defaults_circ_get(void)
576 {
577 return defaults.circ;
578 }
579
580
581 PUBLIC void
vrna_md_defaults_gquad(int flag)582 vrna_md_defaults_gquad(int flag)
583 {
584 defaults.gquad = flag ? 1 : 0;
585 #ifndef VRNA_DISABLE_BACKWARD_COMPATIBILITY
586 gquad = defaults.gquad;
587 #endif
588 }
589
590
591 PUBLIC int
vrna_md_defaults_gquad_get(void)592 vrna_md_defaults_gquad_get(void)
593 {
594 return defaults.gquad;
595 }
596
597
598 PUBLIC void
vrna_md_defaults_uniq_ML(int flag)599 vrna_md_defaults_uniq_ML(int flag)
600 {
601 defaults.uniq_ML = flag ? 1 : 0;
602 #ifndef VRNA_DISABLE_BACKWARD_COMPATIBILITY
603 uniq_ML = defaults.uniq_ML;
604 #endif
605 }
606
607
608 PUBLIC int
vrna_md_defaults_uniq_ML_get(void)609 vrna_md_defaults_uniq_ML_get(void)
610 {
611 return defaults.uniq_ML;
612 }
613
614
615 PUBLIC void
vrna_md_defaults_energy_set(int e)616 vrna_md_defaults_energy_set(int e)
617 {
618 if ((e >= 0) && (e <= 3)) {
619 defaults.energy_set = e;
620 #ifndef VRNA_DISABLE_BACKWARD_COMPATIBILITY
621 energy_set = e;
622 #endif
623 /* update pair/rtype/alias arrays accordingly */
624 vrna_md_update(&defaults);
625 } else {
626 vrna_message_warning(
627 "vrna_md_defaults_energy_set@model.c: Energy Set out of range, must be (0 <= e <= 3). Not changing anything!");
628 }
629 }
630
631
632 PUBLIC int
vrna_md_defaults_energy_set_get(void)633 vrna_md_defaults_energy_set_get(void)
634 {
635 return defaults.energy_set;
636 }
637
638
639 PUBLIC void
vrna_md_defaults_backtrack(int flag)640 vrna_md_defaults_backtrack(int flag)
641 {
642 defaults.backtrack = flag ? 1 : 0;
643 }
644
645
646 PUBLIC int
vrna_md_defaults_backtrack_get(void)647 vrna_md_defaults_backtrack_get(void)
648 {
649 return defaults.backtrack;
650 }
651
652
653 PUBLIC void
vrna_md_defaults_backtrack_type(char t)654 vrna_md_defaults_backtrack_type(char t)
655 {
656 switch (t) {
657 case 'M': /* fall through */
658 case 'C': /* fall through */
659 case 'F':
660 defaults.backtrack_type = t;
661 #ifndef VRNA_DISABLE_BACKWARD_COMPATIBILITY
662 backtrack_type = t;
663 #endif
664 break;
665 default:
666 vrna_message_warning(
667 "vrna_md_defaults_backtrack_type@model.c: Backtrack type must be any of 'F', 'C', or 'M'. Not changing anything!");
668 }
669 }
670
671
672 PUBLIC char
vrna_md_defaults_backtrack_type_get(void)673 vrna_md_defaults_backtrack_type_get(void)
674 {
675 return defaults.backtrack_type;
676 }
677
678
679 PUBLIC void
vrna_md_defaults_compute_bpp(int flag)680 vrna_md_defaults_compute_bpp(int flag)
681 {
682 if ((flag >= 0) && (flag <= 2)) {
683 defaults.compute_bpp = flag;
684 #ifndef VRNA_DISABLE_BACKWARD_COMPATIBILITY
685 do_backtrack = flag;
686 #endif
687 } else {
688 defaults.compute_bpp = 1;
689 }
690 }
691
692
693 PUBLIC int
vrna_md_defaults_compute_bpp_get(void)694 vrna_md_defaults_compute_bpp_get(void)
695 {
696 return defaults.compute_bpp;
697 }
698
699
700 PUBLIC void
vrna_md_defaults_max_bp_span(int span)701 vrna_md_defaults_max_bp_span(int span)
702 {
703 defaults.max_bp_span = (span <= 0) ? -1 : span;
704 #ifndef VRNA_DISABLE_BACKWARD_COMPATIBILITY
705 max_bp_span = defaults.max_bp_span;
706 #endif
707 }
708
709
710 PUBLIC int
vrna_md_defaults_max_bp_span_get(void)711 vrna_md_defaults_max_bp_span_get(void)
712 {
713 return defaults.max_bp_span;
714 }
715
716
717 PUBLIC void
vrna_md_defaults_min_loop_size(int size)718 vrna_md_defaults_min_loop_size(int size)
719 {
720 defaults.min_loop_size = (size < 0) ? 0 : size;
721 }
722
723
724 PUBLIC int
vrna_md_defaults_min_loop_size_get(void)725 vrna_md_defaults_min_loop_size_get(void)
726 {
727 return defaults.min_loop_size;
728 }
729
730
731 PUBLIC void
vrna_md_defaults_window_size(int size)732 vrna_md_defaults_window_size(int size)
733 {
734 defaults.window_size = (size <= 0) ? -1 : size;
735 }
736
737
738 PUBLIC int
vrna_md_defaults_window_size_get(void)739 vrna_md_defaults_window_size_get(void)
740 {
741 return defaults.window_size;
742 }
743
744
745 PUBLIC void
vrna_md_defaults_oldAliEn(int flag)746 vrna_md_defaults_oldAliEn(int flag)
747 {
748 defaults.oldAliEn = flag ? 1 : 0;
749 #ifndef VRNA_DISABLE_BACKWARD_COMPATIBILITY
750 oldAliEn = defaults.oldAliEn;
751 #endif
752 }
753
754
755 PUBLIC int
vrna_md_defaults_oldAliEn_get(void)756 vrna_md_defaults_oldAliEn_get(void)
757 {
758 return defaults.oldAliEn;
759 }
760
761
762 PUBLIC void
vrna_md_defaults_ribo(int flag)763 vrna_md_defaults_ribo(int flag)
764 {
765 defaults.ribo = flag ? 1 : 0;
766 #ifndef VRNA_DISABLE_BACKWARD_COMPATIBILITY
767 ribo = defaults.ribo;
768 #endif
769 }
770
771
772 PUBLIC int
vrna_md_defaults_ribo_get(void)773 vrna_md_defaults_ribo_get(void)
774 {
775 return defaults.ribo;
776 }
777
778
779 PUBLIC void
vrna_md_defaults_cv_fact(double factor)780 vrna_md_defaults_cv_fact(double factor)
781 {
782 defaults.cv_fact = factor;
783 #ifndef VRNA_DISABLE_BACKWARD_COMPATIBILITY
784 cv_fact = factor;
785 #endif
786 }
787
788
789 PUBLIC double
vrna_md_defaults_cv_fact_get(void)790 vrna_md_defaults_cv_fact_get(void)
791 {
792 return defaults.cv_fact;
793 }
794
795
796 PUBLIC void
vrna_md_defaults_nc_fact(double factor)797 vrna_md_defaults_nc_fact(double factor)
798 {
799 defaults.nc_fact = factor;
800 #ifndef VRNA_DISABLE_BACKWARD_COMPATIBILITY
801 nc_fact = factor;
802 #endif
803 }
804
805
806 PUBLIC double
vrna_md_defaults_nc_fact_get(void)807 vrna_md_defaults_nc_fact_get(void)
808 {
809 return defaults.nc_fact;
810 }
811
812
813 PUBLIC void
vrna_md_defaults_sfact(double factor)814 vrna_md_defaults_sfact(double factor)
815 {
816 defaults.sfact = factor;
817 }
818
819
820 PUBLIC double
vrna_md_defaults_sfact_get(void)821 vrna_md_defaults_sfact_get(void)
822 {
823 return defaults.sfact;
824 }
825
826
827 PUBLIC void
vrna_md_update(vrna_md_t * md)828 vrna_md_update(vrna_md_t *md)
829 {
830 if (md)
831 fill_pair_matrices(md);
832 }
833
834
835 /*
836 * This function updates the pair/alias/rtype arrays according to model settings.
837 * It should be called whenever there is a change in the following model settings:
838 * - energy_set
839 * - noGU
840 * - nonstandards
841 */
842 PRIVATE void
fill_pair_matrices(vrna_md_t * md)843 fill_pair_matrices(vrna_md_t *md)
844 {
845 int i, j;
846
847 /* nullify everything */
848 for (i = 0; i <= MAXALPHA; i++)
849 memset(md->pair[i], 0, (MAXALPHA + 1) * sizeof(int));
850
851 memset(md->alias, 0, (MAXALPHA + 1) * sizeof(short));
852
853 /* start setting actual base pair type encodings */
854 switch (md->energy_set) {
855 case 0:
856 prepare_default_pairs(md);
857 break;
858
859 case 1:
860 for (i = 1; i < MAXALPHA;) {
861 md->alias[i++] = 3; /* A <-> G */
862 md->alias[i++] = 2; /* B <-> C */
863 }
864 for (i = 1; i < MAXALPHA; i++) {
865 md->pair[i][i + 1] = 2; /* AB <-> GC */
866 i++;
867 md->pair[i][i - 1] = 1; /* BA <-> CG */
868 }
869
870 break;
871
872 case 2:
873 for (i = 1; i < MAXALPHA;) {
874 md->alias[i++] = 1; /* A <-> A*/
875 md->alias[i++] = 4; /* B <-> U */
876 }
877 for (i = 1; i < MAXALPHA; i++) {
878 md->pair[i][i + 1] = 5; /* AB <-> AU */
879 i++;
880 md->pair[i][i - 1] = 6; /* BA <-> UA */
881 }
882
883 break;
884
885 case 3:
886 for (i = 1; i < MAXALPHA - 2;) {
887 md->alias[i++] = 3; /* A <-> G */
888 md->alias[i++] = 2; /* B <-> C */
889 md->alias[i++] = 1; /* C <-> A */
890 md->alias[i++] = 4; /* D <-> U */
891 }
892 for (i = 1; i < MAXALPHA - 2; i++) {
893 md->pair[i][i + 1] = 2; /* AB <-> GC */
894 i++;
895 md->pair[i][i - 1] = 1; /* BA <-> CG */
896 i++;
897 md->pair[i][i + 1] = 5; /* CD <-> AU */
898 i++;
899 md->pair[i][i - 1] = 6; /* DC <-> UA */
900 }
901
902 break;
903
904 default:
905 vrna_message_warning("vrna_md_update: "
906 "Unknown energy_set = %d. "
907 "Using defaults!",
908 md->energy_set);
909 md->energy_set = 0;
910 prepare_default_pairs(md);
911 break;
912 }
913
914 /* set the reverse base pair types */
915 for (i = 0; i <= MAXALPHA; i++)
916 for (j = 0; j <= MAXALPHA; j++)
917 md->rtype[md->pair[i][j]] = md->pair[j][i];
918
919 /* handle special cases separately */
920 md->rtype[0] = 0;
921 md->rtype[7] = 7;
922
923 /* was used for energy_set == 0
924 * for(i = 0; i < NBASES; i++)
925 * for(j = 0; j < NBASES; j++)
926 * md->rtype[md->pair[i][j]] = md->pair[j][i];
927 */
928 }
929
930
931 PRIVATE void
prepare_default_pairs(vrna_md_t * md)932 prepare_default_pairs(vrna_md_t *md)
933 {
934 unsigned int i, j;
935
936 for (i = 0; i < 5; i++)
937 md->alias[i] = (short)i;
938
939 md->alias[5] = 3; /* X <-> G */
940 md->alias[6] = 2; /* K <-> C */
941 md->alias[7] = 0; /* I <-> default base '@' */
942
943 for (i = 0; i < NBASES; i++)
944 for (j = 0; j < NBASES; j++)
945 md->pair[i][j] = BP_pair[i][j];
946
947 if (md->noGU)
948 md->pair[3][4] = md->pair[4][3] = 0;
949
950 if (md->nonstandards[0] != '\0') {
951 /* allow nonstandard bp's (encoded by type=7) */
952 for (i = 0; i < strlen(md->nonstandards); i += 2)
953 md->pair[vrna_nucleotide_encode(md->nonstandards[i], md)]
954 [vrna_nucleotide_encode(md->nonstandards[i + 1], md)] = 7;
955 }
956 }
957
958
959 #ifndef VRNA_DISABLE_BACKWARD_COMPATIBILITY
960
961 /*###########################################*/
962 /*# deprecated functions below #*/
963 /*###########################################*/
964
965 PUBLIC void
set_model_details(vrna_md_t * md)966 set_model_details(vrna_md_t *md)
967 {
968 if (md) {
969 /* make sure there are no uninitialized data fields */
970 memset(md, 0, sizeof(vrna_md_t));
971
972 md->dangles = dangles;
973 md->special_hp = tetra_loop;
974 md->noLP = noLonelyPairs;
975 md->noGU = noGU;
976 md->noGUclosure = no_closingGU;
977 md->logML = logML;
978 md->gquad = gquad;
979 md->circ = circ;
980 md->uniq_ML = uniq_ML;
981 md->compute_bpp = do_backtrack;
982 md->backtrack = VRNA_MODEL_DEFAULT_BACKTRACK;
983 md->backtrack_type = backtrack_type;
984 md->energy_set = energy_set;
985 md->max_bp_span = max_bp_span;
986 md->min_loop_size = TURN;
987 md->window_size = VRNA_MODEL_DEFAULT_WINDOW_SIZE;
988 md->oldAliEn = oldAliEn;
989 md->ribo = ribo;
990 md->cv_fact = cv_fact;
991 md->nc_fact = nc_fact;
992 md->temperature = temperature;
993 md->betaScale = VRNA_MODEL_DEFAULT_BETA_SCALE;
994 md->pf_smooth = VRNA_MODEL_DEFAULT_PF_SMOOTH;
995 md->sfact = 1.07;
996
997 if (nonstandards)
998 copy_nonstandards(md, nonstandards);
999
1000 /* set default values for the pair/rtype[pair] stuff */
1001 vrna_md_update(md);
1002 }
1003 }
1004
1005
1006 PUBLIC char *
option_string(void)1007 option_string(void)
1008 {
1009 vrna_md_t md;
1010
1011 set_model_details(&md);
1012
1013 return vrna_md_option_string(&md);
1014 }
1015
1016
1017 #endif
1018