1#ifndef VIENNA_RNA_PACKAGE_LOOPS_INTERNAL_H
2#define VIENNA_RNA_PACKAGE_LOOPS_INTERNAL_H
7#include <ViennaRNA/params/default.h>
15#ifdef VRNA_WARN_DEPRECATED
16# if defined(DEPRECATED)
19# if defined(__clang__)
20# define DEPRECATED(func, msg) func __attribute__ ((deprecated("", msg)))
21# elif defined(__GNUC__)
22# define DEPRECATED(func, msg) func __attribute__ ((deprecated(msg)))
24# define DEPRECATED(func, msg) func
27# define DEPRECATED(func, msg) func
158#ifndef VRNA_DISABLE_BACKWARD_COMPATIBILITY
169#define ON_SAME_STRAND(I, J, C) (((I) >= (C)) || ((J) < (C)))
256PRIVATE INLINE
int E_IntLoop_Co(
int type,
282ubf_eval_int_loop(
int i,
295 unsigned char type_2,
307 if ((cp < 0) || (ON_SAME_STRAND(i, p, cp) && ON_SAME_STRAND(q, j, cp))) {
309 energy =
E_IntLoop(u1, u2, type, type_2, si, sj, sp, sq, P);
313 Si = ON_SAME_STRAND(i, i1, cp) ? si : -1;
314 Sj = ON_SAME_STRAND(j1, j, cp) ? sj : -1;
315 energy = E_IntLoop_Co(rtype[type], rtype[type_2],
351ubf_eval_int_loop2(
int i,
364 unsigned char type_2,
377 if ((sn[i] == sn[p]) && (sn[q] == sn[j])) {
379 energy =
E_IntLoop(u1, u2, type, type_2, si, sj, sp, sq, P);
383 Si = (sn[i1] == sn[i]) ? si : -1;
384 Sj = (sn[j] == sn[j1]) ? sj : -1;
385 energy = E_IntLoop_Co(rtype[type], rtype[type_2],
431ubf_eval_ext_int_loop(
int i,
444 unsigned char type_2,
449 int energy, u1, u2, u3;
455 energy =
E_IntLoop(u2, u1 + u3, type, type_2, si, sj, sp, sq, P);
466 if (u1 + u2 + u3 == 0)
492 int nl, ns, u, energy, salt_stack_correction, salt_loop_correction, backbones;
494 salt_stack_correction = P->SaltStack;
495 salt_loop_correction = 0;
506 return P->stack[type][type_2] + salt_stack_correction;
514 salt_loop_correction = P->SaltLoop[backbones];
521 energy = (nl <=
MAXLOOP) ? P->bulge[nl] :
522 (P->bulge[30] + (
int)(P->lxc * log(nl / 30.)));
524 energy += P->stack[type][type_2];
527 energy += P->TerminalAU;
530 energy += P->TerminalAU;
533 return energy + salt_loop_correction;
538 return P->int11[type][type_2][si1][sj1] + salt_loop_correction;
543 energy = P->int21[type][type_2][si1][sq1][sj1];
545 energy = P->int21[type_2][type][sq1][si1][sp1];
547 return energy + salt_loop_correction;
552 MAXLOOP) ? (P->internal_loop[nl + 1]) : (P->internal_loop[30] +
553 (int)(P->lxc * log((nl + 1) / 30.)));
554 energy +=
MIN2(MAX_NINIO, (nl - ns) * P->ninio[2]);
555 energy += P->mismatch1nI[type][si1][sj1] + P->mismatch1nI[type_2][sq1][sp1];
556 return energy + salt_loop_correction;
558 }
else if (ns == 2) {
561 return P->int22[type][type_2][si1][sp1][sq1][sj1] + salt_loop_correction;
562 }
else if (nl == 3) {
564 energy = P->internal_loop[5] + P->ninio[2];
565 energy += P->mismatch23I[type][si1][sj1] + P->mismatch23I[type_2][sq1][sp1];
566 return energy + salt_loop_correction;
575 MAXLOOP) ? (P->internal_loop[u]) : (P->internal_loop[30] + (int)(P->lxc * log((u) / 30.)));
577 energy +=
MIN2(MAX_NINIO, (nl - ns) * P->ninio[2]);
579 energy += P->mismatchI[type][si1][sj1] + P->mismatchI[type_2][sq1][sp1];
583 return energy + salt_loop_correction;
598 int ul, us, no_close = 0;
602 double salt_stack_correction = P->expSaltStack;
603 double salt_loop_correction = 1.;
605 if ((noGUclosure) && ((type2 == 3) || (type2 == 4) || (type == 3) || (type == 4)))
621 salt_loop_correction = P->expSaltLoop[backbones];
628 z = P->expstack[type][type2] * salt_stack_correction;
629 }
else if (!no_close) {
634 z *= P->expstack[type][type2];
643 return (
FLT_OR_DBL)(z * salt_loop_correction);
644 }
else if (us == 1) {
646 return (
FLT_OR_DBL)(P->expint11[type][type2][si1][sj1] * salt_loop_correction);
651 return (
FLT_OR_DBL)(P->expint21[type][type2][si1][sq1][sj1] * salt_loop_correction);
653 return (
FLT_OR_DBL)(P->expint21[type2][type][sq1][si1][sp1] * salt_loop_correction);
656 z = P->expinternal[ul + us] * P->expmismatch1nI[type][si1][sj1] *
657 P->expmismatch1nI[type2][sq1][sp1];
658 return (
FLT_OR_DBL)(z * P->expninio[2][ul - us] * salt_loop_correction);
660 }
else if (us == 2) {
663 return (
FLT_OR_DBL)(P->expint22[type][type2][si1][sp1][sq1][sj1] * salt_loop_correction);
664 }
else if (ul == 3) {
666 z = P->expinternal[5] * P->expmismatch23I[type][si1][sj1] *
667 P->expmismatch23I[type2][sq1][sp1];
668 return (
FLT_OR_DBL)(z * P->expninio[2][1] * salt_loop_correction);
673 z = P->expinternal[ul + us] * P->expmismatchI[type][si1][sj1] *
674 P->expmismatchI[type2][sq1][sp1];
675 return (
FLT_OR_DBL)(z * P->expninio[2][ul - us] * salt_loop_correction);
683E_IntLoop_Co(
int type,
697 int e, energy, ci, cj, cp, cq, d3, d5, d5_2, d3_2, tmm, tmm_2;
698 int salt_loop_correction, backbones;
700 salt_loop_correction = 0;
702 backbones = p - i + j - q;
706 salt_loop_correction = P->SaltLoop[backbones];
713 energy += P->TerminalAU;
716 energy += P->TerminalAU;
719 return energy + salt_loop_correction;
721 ci = ON_SAME_STRAND(i, i + 1, cutpoint);
722 cj = ON_SAME_STRAND(j - 1, j, cutpoint);
723 cp = ON_SAME_STRAND(p - 1, p, cutpoint);
724 cq = ON_SAME_STRAND(q, q + 1, cutpoint);
726 d3 = ci ? P->dangle3[type][si1] : 0;
727 d5 = cj ? P->dangle5[type][sj1] : 0;
728 d5_2 = cp ? P->dangle5[type_2][sp1] : 0;
729 d3_2 = cq ? P->dangle3[type_2][sq1] : 0;
731 tmm = (cj && ci) ? P->mismatchExt[type][sj1][si1] : d5 + d3;
732 tmm_2 = (cp && cq) ? P->mismatchExt[type_2][sp1][sq1] : d5_2 + d3_2;
735 return energy + tmm + tmm_2 + salt_loop_correction;
744 e =
MIN2(tmm_2, d5_2);
747 }
else if (j - q == 2) {
749 e =
MIN2(tmm + d5_2, d3 + d5_2);
750 e =
MIN2(e, d5 + d5_2);
751 e =
MIN2(e, d3 + tmm_2);
752 e =
MIN2(e, d3 + d3_2);
761 }
else if (p - i == 2) {
764 e =
MIN2(tmm + d3_2, d5 + d3_2);
765 e =
MIN2(e, d5 + d3_2);
766 e =
MIN2(e, d3 + d3_2);
767 e =
MIN2(e, d5 + tmm_2);
772 }
else if (j - q == 2) {
774 e =
MIN2(tmm, tmm_2);
779 e =
MIN2(e, d3 + d3_2);
780 e =
MIN2(e, d5 + d5_2);
784 energy +=
MIN2(d3, d5_2);
791 }
else if (j - q == 2) {
793 energy +=
MIN2(d5, d3_2);
797 return energy + salt_loop_correction;
#define MAXLOOP
Definition: constants.h:29
Various data structures and pre-processor macros.
The Basic Fold Compound API.
#define VRNA_DECOMP_PAIR_IL
Indicator for interior loop decomposition step.
Definition: basic.h:144
double FLT_OR_DBL
Typename for floating point number in partition function computations.
Definition: basic.h:43
Base pair stack element.
Definition: basic.h:143
double temperature
Temperature used for loop contribution scaling.
Definition: basic.h:153
vrna_md_t model_details
Model details to be used in the recursions.
Definition: basic.h:96
vrna_md_t model_details
Model details to be used in the recursions.
Definition: basic.h:161
double temperature
Temperature used for loop contribution scaling.
Definition: basic.h:94
int vrna_salt_loop_int(int L, double salt, double T)
Get salt correction for a loop at a given salt concentration and temperature.
The data structure that contains temperature scaled Boltzmann weights of the energy parameters.
Definition: basic.h:110
The datastructure that contains temperature scaled energy parameters.
Definition: basic.h:57
PRIVATE FLT_OR_DBL exp_E_IntLoop(int u1, int u2, int type, int type2, short si1, short sj1, short sp1, short sq1, vrna_exp_param_t *P)
Definition: internal.h:588
PRIVATE int E_IntLoop(int n1, int n2, int type, int type_2, int si1, int sj1, int sp1, int sq1, vrna_param_t *P)
Definition: internal.h:481
int vrna_eval_int_loop(vrna_fold_compound_t *fc, int i, int j, int k, int l)
Evaluate the free energy contribution of an interior loop with delimiting base pairs and .
The most basic data structure required by many functions throughout the RNAlib.
Definition: fold_compound.h:156
int vrna_BT_stack(vrna_fold_compound_t *fc, int *i, int *j, int *en, vrna_bp_stack_t *bp_stack, int *stack_count)
Backtrack a stacked pair closed by .
int vrna_BT_int_loop(vrna_fold_compound_t *fc, int *i, int *j, int en, vrna_bp_stack_t *bp_stack, int *stack_count)
Backtrack an interior loop closed by .
double salt
Salt (monovalent) concentration (M) in buffer.
Definition: model.h:260
int noGUclosure
Do not allow loops to be closed by GU pair.
Definition: model.h:234
int dangles
Specifies the dangle model used in any energy evaluation (0,1,2 or 3)
Definition: model.h:207
int dangles
Switch the energy model for dangling end contributions (0, 1, 2, 3)
#define VRNA_MODEL_DEFAULT_SALT
Default model salt concentration (M)
Definition: model.h:162
vrna_sc_f f
A function pointer used for pseudo energy contribution in MFE calculations.
Definition: soft.h:247
int ** energy_up
Energy contribution for stretches of unpaired nucleotides.
Definition: soft.h:217
void * data
A pointer to the data object provided for for pseudo energy contribution functions of the generic sof...
Definition: soft.h:264
int * energy_stack
Pseudo Energy contribution per base pair involved in a stack.
Definition: soft.h:243
int * energy_bp
Energy contribution for base pairs.
Definition: soft.h:228
The soft constraints data structure.
Definition: soft.h:211
#define MIN2(A, B)
Get the minimum of two comparable values.
Definition: basic.h:106
Functions and data structures for handling of secondary structure hard constraints.
Functions to deal with sets of energy parameters.
Functions to compute salt correction.
Functions and data structures for secondary structure soft constraints.
General utility- and helper-functions used throughout the ViennaRNA Package.