Fine-tuning of the Implemented Models

Functions and data structures to fine-tune the implemented secondary structure evaluation model.

Defines

NBASES: #include <ViennaRNA/model.h>

VRNA_MODEL_DEFAULT_TEMPERATURE

#include <ViennaRNA/model.h>

VRNA_MODEL_DEFAULT_PF_SCALE

#include <ViennaRNA/model.h>

Default scaling factor for partition function computations.

VRNA_MODEL_DEFAULT_BETA_SCALE

#include <ViennaRNA/model.h>

Default scaling factor for absolute thermodynamic temperature in Boltzmann factors.

VRNA_MODEL_DEFAULT_DANGLES

#include <ViennaRNA/model.h>

Default dangling end model.

VRNA_MODEL_DEFAULT_SPECIAL_HP

#include <ViennaRNA/model.h>

Default model behavior for lookup of special tri-, tetra-, and hexa-loops.

VRNA_MODEL_DEFAULT_NO_LP

#include <ViennaRNA/model.h>

Default model behavior for so-called ‘lonely pairs’.

VRNA_MODEL_DEFAULT_NO_GU

#include <ViennaRNA/model.h>

Default model behavior for G-U base pairs.

VRNA_MODEL_DEFAULT_NO_GU_CLOSURE

#include <ViennaRNA/model.h>

Default model behavior for G-U base pairs closing a loop.

VRNA_MODEL_DEFAULT_CIRC

#include <ViennaRNA/model.h>

Default model behavior to treat a molecule as a circular RNA (DNA)

VRNA_MODEL_DEFAULT_GQUAD

#include <ViennaRNA/model.h>

Default model behavior regarding the treatment of G-Quadruplexes.

VRNA_MODEL_DEFAULT_UNIQ_ML

#include <ViennaRNA/model.h>

Default behavior of the model regarding unique multi-branch loop decomposition.

VRNA_MODEL_DEFAULT_ENERGY_SET

#include <ViennaRNA/model.h>

Default model behavior on which energy set to use.

VRNA_MODEL_DEFAULT_BACKTRACK

#include <ViennaRNA/model.h>

Default model behavior with regards to backtracking of structures.

VRNA_MODEL_DEFAULT_BACKTRACK_TYPE

#include <ViennaRNA/model.h>

Default model behavior on what type of backtracking to perform.

VRNA_MODEL_DEFAULT_COMPUTE_BPP

#include <ViennaRNA/model.h>

Default model behavior with regards to computing base pair probabilities.

VRNA_MODEL_DEFAULT_MAX_BP_SPAN

#include <ViennaRNA/model.h>

Default model behavior for the allowed maximum base pair span.

VRNA_MODEL_DEFAULT_WINDOW_SIZE

#include <ViennaRNA/model.h>

Default model behavior for the sliding window approach.

VRNA_MODEL_DEFAULT_LOG_ML

#include <ViennaRNA/model.h>

Default model behavior on how to evaluate the energy contribution of multi-branch loops.

VRNA_MODEL_DEFAULT_ALI_OLD_EN

#include <ViennaRNA/model.h>

Default model behavior for consensus structure energy evaluation.

VRNA_MODEL_DEFAULT_ALI_RIBO

#include <ViennaRNA/model.h>

Default model behavior for consensus structure co-variance contribution assessment.

VRNA_MODEL_DEFAULT_ALI_CV_FACT

#include <ViennaRNA/model.h>

Default model behavior for weighting the co-variance score in consensus structure prediction.

VRNA_MODEL_DEFAULT_ALI_NC_FACT

#include <ViennaRNA/model.h>

Default model behavior for weighting the nucleotide conservation? in consensus structure prediction.

VRNA_MODEL_DEFAULT_PF_SMOOTH: #include <ViennaRNA/model.h>

VRNA_MODEL_DEFAULT_SALT: #include <ViennaRNA/model.h>
Default model salt concentration (M)

VRNA_MODEL_DEFAULT_SALT_MLLOWER: #include <ViennaRNA/model.h>
Default model lower bound of multiloop size for salt correction fiting.

VRNA_MODEL_DEFAULT_SALT_MLUPPER: #include <ViennaRNA/model.h>
Default model upper bound of multiloop size for salt correction fiting.

VRNA_MODEL_DEFAULT_SALT_DPXINIT: #include <ViennaRNA/model.h>
Default model value to turn off user-provided salt correction for duplex initializtion.

VRNA_MODEL_SALT_DPXINIT_FACT_RNA: #include <ViennaRNA/model.h>

VRNA_MODEL_SALT_DPXINIT_FACT_DNA: #include <ViennaRNA/model.h>

VRNA_MODEL_DEFAULT_SALT_DPXINIT_FACT: #include <ViennaRNA/model.h>

VRNA_MODEL_HELICAL_RISE_RNA: #include <ViennaRNA/model.h>

VRNA_MODEL_HELICAL_RISE_DNA: #include <ViennaRNA/model.h>

VRNA_MODEL_DEFAULT_HELICAL_RISE: #include <ViennaRNA/model.h>
Default helical rise.

VRNA_MODEL_BACKBONE_LENGTH_RNA: #include <ViennaRNA/model.h>

VRNA_MODEL_BACKBONE_LENGTH_DNA: #include <ViennaRNA/model.h>

VRNA_MODEL_DEFAULT_BACKBONE_LENGTH: #include <ViennaRNA/model.h>
Default backbone length.

MAXALPHA: #include <ViennaRNA/model.h>
Maximal length of alphabet.

model_detailsT: #include <ViennaRNA/model.h>

Typedefs

typedef struct vrna_md_s vrna_md_t: #include <ViennaRNA/model.h>
Typename for the model details data structure vrna_md_s.

Functions

void vrna_md_set_default(vrna_md_t *md)

#include <ViennaRNA/model.h>

Apply default model details to a provided vrna_md_t data structure.

Use this function to initialize a vrna_md_t data structure with its default values

Parameters:

md – A pointer to the data structure that is about to be initialized

void vrna_md_update(vrna_md_t *md)

#include <ViennaRNA/model.h>

Update the model details data structure.

This function should be called after changing the vrna_md_t.energy_set attribute since it re-initializes base pairing related arrays within the vrna_md_t data structure. In particular, vrna_md_t.pair, vrna_md_t.alias, and vrna_md_t.rtype are set to the values that correspond to the specified vrna_md_t.energy_set option

vrna_md_t *vrna_md_copy(vrna_md_t *md_to, const vrna_md_t *md_from)

#include <ViennaRNA/model.h>

Copy/Clone a vrna_md_t model.

Use this function to clone a given model either inplace (target container md_to given) or create a copy by cloning the source model and returning it (md_to == NULL).

Parameters:

md_to – The model to be overwritten (if non-NULL and md_to != md_from)
md_from – The model to copy (if non-NULL)

Returns:

A pointer to the copy model (or NULL if md_from == NULL)

char *vrna_md_option_string(vrna_md_t *md): #include <ViennaRNA/model.h>
Get a corresponding commandline parameter string of the options in a vrna_md_t.

Note

This function is not threadsafe!

void vrna_md_set_nonstandards(vrna_md_t *md, const char *ns_bases): #include <ViennaRNA/model.h>

void vrna_md_defaults_reset(vrna_md_t *md_p)

#include <ViennaRNA/model.h>

Reset the global default model details to a specific set of parameters, or their initial values.

This function resets the global default model details to their initial values, i.e. as specified by the ViennaRNA Package release, upon passing NULL as argument. Alternatively it resets them according to a set of provided parameters.

See also

vrna_md_set_default(), vrna_md_t

Note

The global default parameters affect all function calls of RNAlib where model details are not explicitly provided. Hence, any change of them is not considered threadsafe

Warning

This function first resets the global default settings to factory defaults, and only then applies user provided settings (if any). User settings that do not meet specifications are skipped.

Parameters:

md_p – A set of model details to use as global default (if NULL is passed, factory defaults are restored)

void vrna_md_defaults_temperature(double T)

#include <ViennaRNA/model.h>

Set default temperature for energy evaluation of loops.

Parameters:

T – Temperature in centigrade

double vrna_md_defaults_temperature_get(void)

#include <ViennaRNA/model.h>

Get default temperature for energy evaluation of loops.

Returns:: The global default settings for temperature in centigrade

void vrna_md_defaults_betaScale(double b)

#include <ViennaRNA/model.h>

Set default scaling factor of thermodynamic temperature in Boltzmann factors.

Bolzmann factors are then computed as \( exp(-E / (b \cdot kT))\).

Parameters:

b – The scaling factor, default is 1.0

double vrna_md_defaults_betaScale_get(void)

#include <ViennaRNA/model.h>

Get default scaling factor of thermodynamic temperature in Boltzmann factors.

Returns:: The global default thermodynamic temperature scaling factor

void vrna_md_defaults_pf_smooth(int s): #include <ViennaRNA/model.h>

int vrna_md_defaults_pf_smooth_get(void): #include <ViennaRNA/model.h>

void vrna_md_defaults_dangles(int d)

#include <ViennaRNA/model.h>

Set default dangle model for structure prediction.

Parameters:

d – The dangle model

int vrna_md_defaults_dangles_get(void)

#include <ViennaRNA/model.h>

Get default dangle model for structure prediction.

Returns:: The global default settings for the dangle model

void vrna_md_defaults_special_hp(int flag)

#include <ViennaRNA/model.h>

Set default behavior for lookup of tabulated free energies for special hairpin loops, such as Tri-, Tetra-, or Hexa-loops.

Parameters:

flag – On/Off switch (0 = OFF, else = ON)

int vrna_md_defaults_special_hp_get(void)

#include <ViennaRNA/model.h>

Get default behavior for lookup of tabulated free energies for special hairpin loops, such as Tri-, Tetra-, or Hexa-loops.

Returns:: The global default settings for the treatment of special hairpin loops

void vrna_md_defaults_noLP(int flag)

#include <ViennaRNA/model.h>

Set default behavior for prediction of canonical secondary structures.

Parameters:

flag – On/Off switch (0 = OFF, else = ON)

int vrna_md_defaults_noLP_get(void)

#include <ViennaRNA/model.h>

Get default behavior for prediction of canonical secondary structures.

Returns:: The global default settings for predicting canonical secondary structures

void vrna_md_defaults_noGU(int flag)

#include <ViennaRNA/model.h>

Set default behavior for treatment of G-U wobble pairs.

Parameters:

flag – On/Off switch (0 = OFF, else = ON)

int vrna_md_defaults_noGU_get(void)

#include <ViennaRNA/model.h>

Get default behavior for treatment of G-U wobble pairs.

Returns:: The global default settings for treatment of G-U wobble pairs

void vrna_md_defaults_noGUclosure(int flag)

#include <ViennaRNA/model.h>

Set default behavior for G-U pairs as closing pair for loops.

Parameters:

flag – On/Off switch (0 = OFF, else = ON)

int vrna_md_defaults_noGUclosure_get(void)

#include <ViennaRNA/model.h>

Get default behavior for G-U pairs as closing pair for loops.

Returns:: The global default settings for treatment of G-U pairs closing a loop

void vrna_md_defaults_logML(int flag)

#include <ViennaRNA/model.h>

Set default behavior recomputing free energies of multi-branch loops using a logarithmic model.

Parameters:

flag – On/Off switch (0 = OFF, else = ON)

int vrna_md_defaults_logML_get(void)

#include <ViennaRNA/model.h>

Get default behavior recomputing free energies of multi-branch loops using a logarithmic model.

Returns:: The global default settings for logarithmic model in multi-branch loop free energy evaluation

void vrna_md_defaults_circ(int flag)

#include <ViennaRNA/model.h>

Set default behavior whether input sequences are circularized.

Parameters:

flag – On/Off switch (0 = OFF, else = ON)

int vrna_md_defaults_circ_get(void)

#include <ViennaRNA/model.h>

Get default behavior whether input sequences are circularized.

Returns:: The global default settings for treating input sequences as circular

void vrna_md_defaults_gquad(int flag)

#include <ViennaRNA/model.h>

Set default behavior for treatment of G-Quadruplexes.

Parameters:

flag – On/Off switch (0 = OFF, else = ON)

int vrna_md_defaults_gquad_get(void)

#include <ViennaRNA/model.h>

Get default behavior for treatment of G-Quadruplexes.

Returns:: The global default settings for treatment of G-Quadruplexes

void vrna_md_defaults_uniq_ML(int flag)

#include <ViennaRNA/model.h>

Set default behavior for creating additional matrix for unique multi-branch loop prediction.

Note

Activating this option usually results in higher memory consumption!

Parameters:

flag – On/Off switch (0 = OFF, else = ON)

int vrna_md_defaults_uniq_ML_get(void)

#include <ViennaRNA/model.h>

Get default behavior for creating additional matrix for unique multi-branch loop prediction.

Returns:: The global default settings for creating additional matrices for unique multi-branch loop prediction

void vrna_md_defaults_energy_set(int e)

#include <ViennaRNA/model.h>

Set default energy set.

Parameters:

e – Energy set (0, 1, 2, 3)

int vrna_md_defaults_energy_set_get(void)

#include <ViennaRNA/model.h>

Get default energy set.

Returns:: The global default settings for the energy set

void vrna_md_defaults_backtrack(int flag)

#include <ViennaRNA/model.h>

Set default behavior for whether to backtrack secondary structures.

Parameters:

flag – On/Off switch (0 = OFF, else = ON)

int vrna_md_defaults_backtrack_get(void)

#include <ViennaRNA/model.h>

Get default behavior for whether to backtrack secondary structures.

Returns:: The global default settings for backtracking structures

void vrna_md_defaults_backtrack_type(char t)

#include <ViennaRNA/model.h>

Set default backtrack type, i.e. which DP matrix is used.

Parameters:

t – The type (‘F’, ‘C’, or ‘M’)

char vrna_md_defaults_backtrack_type_get(void)

#include <ViennaRNA/model.h>

Get default backtrack type, i.e. which DP matrix is used.

Returns:: The global default settings that specify which DP matrix is used for backtracking

void vrna_md_defaults_compute_bpp(int flag)

#include <ViennaRNA/model.h>

Set the default behavior for whether to compute base pair probabilities after partition function computation.

Parameters:

flag – On/Off switch (0 = OFF, else = ON)

int vrna_md_defaults_compute_bpp_get(void)

#include <ViennaRNA/model.h>

Get the default behavior for whether to compute base pair probabilities after partition function computation.

Returns:: The global default settings that specify whether base pair probabilities are computed together with partition function

void vrna_md_defaults_max_bp_span(int span)

#include <ViennaRNA/model.h>

Set default maximal base pair span.

Parameters:

span – Maximal base pair span

int vrna_md_defaults_max_bp_span_get(void)

#include <ViennaRNA/model.h>

Get default maximal base pair span.

Returns:: The global default settings for maximum base pair span

void vrna_md_defaults_min_loop_size(int size)

#include <ViennaRNA/model.h>

Set default minimal loop size.

Parameters:

size – Minimal size, i.e. number of unpaired nucleotides for a hairpin loop

int vrna_md_defaults_min_loop_size_get(void)

#include <ViennaRNA/model.h>

Get default minimal loop size.

Returns:: The global default settings for minimal size of hairpin loops

void vrna_md_defaults_window_size(int size)

#include <ViennaRNA/model.h>

Set default window size for sliding window structure prediction approaches.

Parameters:

size – The size of the sliding window

int vrna_md_defaults_window_size_get(void)

#include <ViennaRNA/model.h>

Get default window size for sliding window structure prediction approaches.

Returns:: The global default settings for the size of the sliding window

void vrna_md_defaults_oldAliEn(int flag)

#include <ViennaRNA/model.h>

Set default behavior for whether to use old energy model for comparative structure prediction.

Note

This option is outdated. Activating the old energy model usually results in worse consensus structure predictions.

Parameters:

flag – On/Off switch (0 = OFF, else = ON)

int vrna_md_defaults_oldAliEn_get(void)

#include <ViennaRNA/model.h>

Get default behavior for whether to use old energy model for comparative structure prediction.

Returns:: The global default settings for using old energy model for comparative structure prediction

void vrna_md_defaults_ribo(int flag)

#include <ViennaRNA/model.h>

Set default behavior for whether to use Ribosum Scoring in comparative structure prediction.

Parameters:

flag – On/Off switch (0 = OFF, else = ON)

int vrna_md_defaults_ribo_get(void)

#include <ViennaRNA/model.h>

Get default behavior for whether to use Ribosum Scoring in comparative structure prediction.

Returns:: The global default settings for using Ribosum scoring in comparative structure prediction

void vrna_md_defaults_cv_fact(double factor)

#include <ViennaRNA/model.h>

Set the default co-variance scaling factor used in comparative structure prediction.

Parameters:

factor – The co-variance factor

double vrna_md_defaults_cv_fact_get(void)

#include <ViennaRNA/model.h>

Get the default co-variance scaling factor used in comparative structure prediction.

Returns:: The global default settings for the co-variance factor

void vrna_md_defaults_nc_fact(double factor)

#include <ViennaRNA/model.h>

Parameters:

factor –

double vrna_md_defaults_nc_fact_get(void)

#include <ViennaRNA/model.h>

Returns:

void vrna_md_defaults_sfact(double factor)

#include <ViennaRNA/model.h>

Set the default scaling factor used to avoid under-/overflows in partition function computation.

Parameters:

factor – The scaling factor (default: 1.07)

double vrna_md_defaults_sfact_get(void)

#include <ViennaRNA/model.h>

Get the default scaling factor used to avoid under-/overflows in partition function computation.

Returns:: The global default settings of the scaling factor

void vrna_md_defaults_salt(double salt)

#include <ViennaRNA/model.h>

Set the default salt concentration.

Parameters:

salt – The sodium concentration in M (default: 1.021)

double vrna_md_defaults_salt_get(void)

#include <ViennaRNA/model.h>

Get the default salt concentration.

Returns:: The default salt concentration

void vrna_md_defaults_saltMLLower(int lower)

#include <ViennaRNA/model.h>

Set the default multiloop size lower bound for loop salt correciton linear fitting.

Parameters:

lower – Size lower bound (number of backbone in loop)

int vrna_md_defaults_saltMLLower_get(void)

#include <ViennaRNA/model.h>

Get the default multiloop size lower bound for loop salt correciton linear fitting.

Returns:: The default lower bound

void vrna_md_defaults_saltMLUpper(int upper)

#include <ViennaRNA/model.h>

Set the default multiloop size upper bound for loop salt correciton linear fitting.

Parameters:

upper – Size Upper bound (number of backbone in loop)

int vrna_md_defaults_saltMLUpper_get(void)

#include <ViennaRNA/model.h>

Get the default multiloop size upper bound for loop salt correciton linear fitting.

Returns:: The default upper bound

void vrna_md_defaults_saltDPXInit(int value)

#include <ViennaRNA/model.h>

Set user-provided salt correciton for duplex initialization If value is 99999 the default value from fitting is used.

Parameters:

value – The value of salt correction for duplex initialization (in dcal/mol)

int vrna_md_defaults_saltDPXInit_get(void)

#include <ViennaRNA/model.h>

Get user-provided salt correciton for duplex initialization If value is 99999 the default value from fitting is used.

Returns:: The user-provided salt correction for duplex initialization

void vrna_md_defaults_saltDPXInitFact(float value): #include <ViennaRNA/model.h>

float vrna_md_defaults_saltDPXInitFact_get(void): #include <ViennaRNA/model.h>

void vrna_md_defaults_helical_rise(float value): #include <ViennaRNA/model.h>

float vrna_md_defaults_helical_rise_get(void): #include <ViennaRNA/model.h>

void vrna_md_defaults_backbone_length(float value): #include <ViennaRNA/model.h>

float vrna_md_defaults_backbone_length_get(void): #include <ViennaRNA/model.h>

void set_model_details(vrna_md_t *md)

#include <ViennaRNA/model.h>

Set default model details.

Use this function if you wish to initialize a vrna_md_t data structure with its default values, i.e. the global model settings as provided by the deprecated global variables.

Deprecated:: This function will vanish as soon as backward compatibility of RNAlib is dropped (expected in version 3). Use vrna_md_set_default() instead!

Parameters:

md – A pointer to the data structure that is about to be initialized

char *option_string(void): #include <ViennaRNA/model.h>

Variables

double temperature

Rescale energy parameters to a temperature in degC.

Default is 37C. You have to call the update_…_params() functions after changing this parameter.

Deprecated:: Use vrna_md_defaults_temperature(), and vrna_md_defaults_temperature_get() to change, and read the global default temperature settings

double pf_scale

A scaling factor used by pf_fold() to avoid overflows.

Should be set to approximately \(exp{((-F/kT)/length)}\), where \(F\) is an estimate for the ensemble free energy, for example the minimum free energy. You must call update_pf_params()

after changing this parameter.

If pf_scale is -1 (the default) , an estimate will be provided automatically when computing partition functions, e.g.

pf_fold() The automatic estimate is usually insufficient for sequences more than a few hundred bases long.

int dangles

Switch the energy model for dangling end contributions (0, 1, 2, 3)

If set to 0 no stabilizing energies are assigned to bases adjacent to helices in free ends and multiloops (so called dangling ends). Normally (dangles = 1) dangling end energies are assigned only to unpaired bases and a base cannot participate simultaneously in two dangling ends. In the partition function algorithm pf_fold() these checks are neglected. If dangles

is set to 2, all folding routines will follow this convention. This treatment of dangling ends gives more favorable energies to helices directly adjacent to one another, which can be beneficial since such helices often do engage in stabilizing interactions through co-axial stacking.

If dangles = 3 co-axial stacking is explicitly included for adjacent helices in multiloops. The option affects only mfe folding and energy evaluation (

fold() and energy_of_structure()), as well as suboptimal folding (subopt()) via re-evaluation of energies. Co-axial stacking with one intervening mismatch is not considered so far.

Default is 2 in most algorithms, partition function algorithms can only handle 0 and 2

int tetra_loop

Include special stabilizing energies for some tri-, tetra- and hexa-loops;.

default is 1.

int noLonelyPairs

Global switch to avoid/allow helices of length 1.

Disallow all pairs which can only occur as lonely pairs (i.e. as helix of length 1). This avoids lonely base pairs in the predicted structures in most cases.

int noGU: Global switch to forbid/allow GU base pairs at all.

int no_closingGU: GU allowed only inside stacks if set to 1.

int circ: backward compatibility variable.. this does not effect anything

int gquad: Allow G-quadruplex formation.

int uniq_ML: do ML decomposition uniquely (for subopt)

int energy_set

0 = BP; 1=any with GC; 2=any with AU-parameter

If set to 1 or 2: fold sequences from an artificial alphabet ABCD…, where A pairs B, C pairs D, etc. using either GC (1) or AU parameters (2); default is 0, you probably don’t want to change it.

int do_backtrack

do backtracking, i.e. compute secondary structures or base pair probabilities

If 0, do not calculate pair probabilities in pf_fold(); this is about twice as fast. Default is 1.

char backtrack_type

A backtrack array marker for inverse_fold()

If set to ‘C’: force (1,N) to be paired, ‘M’ fold as if the sequence were inside a multiloop. Otherwise (‘F’) the usual mfe structure is computed.

char *nonstandards

contains allowed non standard base pairs

Lists additional base pairs that will be allowed to form in addition to GC, CG, AU, UA, GU and UG. Nonstandard base pairs are given a stacking energy of 0.

int max_bp_span

Maximum allowed base pair span.

A value of -1 indicates no restriction for distant base pairs.

int oldAliEn: use old alifold energies (with gaps)

int ribo: use ribosum matrices

double cv_fact

double nc_fact

int logML: if nonzero use logarithmic ML energy in energy_of_struct

double salt: salt concentration

int saltDPXInit: Salt correction for duplex initialization.

float helical_rise

float backbone_length

struct vrna_md_s

#include <ViennaRNA/model.h>

The data structure that contains the complete model details used throughout the calculations.

For convenience reasons, we provide the type name vrna_md_t to address this data structure without the use of the struct keyword

SWIG Wrapper Notes:

This data structure is wrapped as an object md with multiple related functions attached as methods.

A new set of default parameters can be obtained by calling the constructure of md:

md() — Initialize with default settings

The resulting object has a list of attached methods which directly correspond to functions that mainly operate on the corresponding C data structure:

reset() - vrna_md_set_default()
set_from_globals() - set_model_details()
option_string() - vrna_md_option_string()

Note, that default parameters can be modified by directly setting any of the following global variables. Internally, getting/setting default parameters using their global variable representative translates into calls of the following functions, therefore these wrappers for these functions do not exist in the scripting language interface(s):

global variable	`C getter`	`C setter`
temperature	vrna_md_defaults_temperature_get()	vrna_md_defaults_temperature()
dangles	vrna_md_defaults_dangles_get()	vrna_md_defaults_dangles()
betaScale	vrna_md_defaults_betaScale_get()	vrna_md_defaults_betaScale()
tetra_loop	this is an alias of special_hp
special_hp	vrna_md_defaults_special_hp_get()	vrna_md_defaults_special_hp()
noLonelyPairs	this is an alias of noLP
noLP	vrna_md_defaults_noLP_get()	vrna_md_defaults_noLP()
noGU	vrna_md_defaults_noGU_get()	vrna_md_defaults_noGU()
no_closingGU	this is an alias of noGUclosure
noGUclosure	vrna_md_defaults_noGUclosure_get()	vrna_md_defaults_noGUclosure()
logML	vrna_md_defaults_logML_get()	vrna_md_defaults_logML()
circ	vrna_md_defaults_circ_get()	vrna_md_defaults_circ()
gquad	vrna_md_defaults_gquad_get()	vrna_md_defaults_gquad()
uniq_ML	vrna_md_defaults_uniq_ML_get()	vrna_md_defaults_uniq_ML()
energy_set	vrna_md_defaults_energy_set_get()	vrna_md_defaults_energy_set()
backtrack	vrna_md_defaults_backtrack_get()	vrna_md_defaults_backtrack()
backtrack_type	vrna_md_defaults_backtrack_type_get()	vrna_md_defaults_backtrack_type()
do_backtrack	this is an alias of compute_bpp
compute_bpp	vrna_md_defaults_compute_bpp_get()	vrna_md_defaults_compute_bpp()
max_bp_span	vrna_md_defaults_max_bp_span_get()	vrna_md_defaults_max_bp_span()
min_loop_size	vrna_md_defaults_min_loop_size_get()	vrna_md_defaults_min_loop_size()
window_size	vrna_md_defaults_window_size_get()	vrna_md_defaults_window_size()
oldAliEn	vrna_md_defaults_oldAliEn_get()	vrna_md_defaults_oldAliEn()
ribo	vrna_md_defaults_ribo_get()	vrna_md_defaults_ribo()
cv_fact	vrna_md_defaults_cv_fact_get()	vrna_md_defaults_cv_fact()
nc_fact	vrna_md_defaults_nc_fact_get()	vrna_md_defaults_nc_fact()
sfact	vrna_md_defaults_sfact_get()	vrna_md_defaults_sfact()

Public Members

double temperature: The temperature used to scale the thermodynamic parameters.

double betaScale: A scaling factor for the thermodynamic temperature of the Boltzmann factors.

int pf_smooth: A flat specifying whether energies in Boltzmann factors need to be smoothed.

int dangles

Specifies the dangle model used in any energy evaluation (0,1,2 or 3)

If set to 0 no stabilizing energies are assigned to bases adjacent to helices in free ends and multiloops (so called dangling ends). Normally (dangles = 1) dangling end energies are assigned only to unpaired bases and a base cannot participate simultaneously in two dangling ends. In the partition function algorithm vrna_pf()

these checks are neglected. To provide comparability between free energy minimization and partition function algorithms, the default setting is 2. This treatment of dangling ends gives more favorable energies to helices directly adjacent to one another, which can be beneficial since such helices often do engage in stabilizing interactions through co-axial stacking.

If set to 3 co-axial stacking is explicitly included for adjacent helices in multiloops. The option affects only mfe folding and energy evaluation (

vrna_mfe() and vrna_eval_structure()), as well as suboptimal folding (vrna_subopt()) via re-evaluation of energies. Co-axial stacking with one intervening mismatch is not considered so far. Note, that some function do not implement all dangle model but only a subset of (0,1,2,3). In particular, partition function algorithms can only handle 0 and 2. Read the documentation of the particular recurrences or energy evaluation function for information about the provided dangle model.

int special_hp: Include special hairpin contributions for tri, tetra and hexaloops.

int noLP: Only consider canonical structures, i.e. no ‘lonely’ base pairs.

int noGU: Do not allow GU pairs.

int noGUclosure: Do not allow loops to be closed by GU pair.

int logML: Use logarithmic scaling for multiloops.

int circ: Assume RNA to be circular instead of linear.

int gquad: Include G-quadruplexes in structure prediction.

int uniq_ML: Flag to ensure unique multi-branch loop decomposition during folding.

int energy_set: Specifies the energy set that defines set of compatible base pairs.

int backtrack: Specifies whether or not secondary structures should be backtraced.

char backtrack_type: Specifies in which matrix to backtrack.

int compute_bpp: Specifies whether or not backward recursions for base pair probability (bpp) computation will be performed.

char nonstandards[64]: contains allowed non standard bases

int max_bp_span: maximum allowed base pair span

int min_loop_size

Minimum size of hairpin loops.

The default value for this field is TURN, however, it may be 0 in cofolding context.

int window_size: Size of the sliding window for locally optimal structure prediction.

int oldAliEn: Use old alifold energy model.

int ribo: Use ribosum scoring table in alifold energy model.

double cv_fact: Co-variance scaling factor for consensus structure prediction.

double nc_fact: Scaling factor to weight co-variance contributions of non-canonical pairs.

double sfact: Scaling factor for partition function scaling.

int rtype[8]: Reverse base pair type array.

short alias[MAXALPHA + 1]: alias of an integer nucleotide representation

int pair[MAXALPHA + 1][MAXALPHA + 1]: Integer representation of a base pair.

float pair_dist[7][7]: Base pair dissimilarity, a.k.a. distance matrix.

double salt: Salt (monovalent) concentration (M) in buffer.

int saltMLLower: Lower bound of multiloop size to use in loop salt correction linear fitting.

int saltMLUpper: Upper bound of multiloop size to use in loop salt correction linear fitting.

int saltDPXInit: User-provided salt correction for duplex initialization (in dcal/mol). If set to 99999 the default salt correction is used. If set to 0 there is no salt correction for duplex initialization.

float saltDPXInitFact

float helical_rise

float backbone_length