/*
                  Model Details structure creation/modification/destruction

                  This file contains everything which is necessary to
                  obtain, modify, and destroy the model_details datastructure
                  used in the folding recurrences throughout the ViennaRNA
                  Package

                  c Ronny Lorenx

                  Vienna RNA package
*/

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <ctype.h>
#include <string.h>
#include <limits.h>

#include "ViennaRNA/energy_const.h"
#include "ViennaRNA/utils.h"
#include "ViennaRNA/model.h"

/*
#################################
# PRIVATE MACROS                #
#################################
*/

/*
#################################
# GLOBAL VARIABLES              #
#################################
*/

#ifdef  VRNA_BACKWARD_COMPAT

/*  below are the evil global variables that will vanish
    as soon as we drop backward compatibility in ViennaRNA
    Package v3
*/

double  temperature     = VRNA_MODEL_DEFAULT_TEMPERATURE;
double  pf_scale        = VRNA_MODEL_DEFAULT_PF_SCALE;
int     dangles         = VRNA_MODEL_DEFAULT_DANGLES;
int     tetra_loop      = VRNA_MODEL_DEFAULT_SPECIAL_HP;
int     noLonelyPairs   = VRNA_MODEL_DEFAULT_NO_LP;
int     noGU            = VRNA_MODEL_DEFAULT_NO_GU;
int     no_closingGU    = VRNA_MODEL_DEFAULT_NO_GU_CLOSURE;
int     circ            = VRNA_MODEL_DEFAULT_CIRC;
int     gquad           = VRNA_MODEL_DEFAULT_GQUAD;
int     canonicalBPonly = VRNA_MODEL_DEFAULT_CANONICAL_BP;
int     uniq_ML         = VRNA_MODEL_DEFAULT_UNIQ_ML;
int     energy_set      = VRNA_MODEL_DEFAULT_ENERGY_SET;
int     do_backtrack    = VRNA_MODEL_DEFAULT_COMPUTE_BPP;
char    backtrack_type  = VRNA_MODEL_DEFAULT_BACKTRACK_TYPE;
char    *nonstandards   = NULL;
int     max_bp_span     = VRNA_MODEL_DEFAULT_MAX_BP_SPAN;
int     oldAliEn        = VRNA_MODEL_DEFAULT_ALI_OLD_EN;
int     ribo            = VRNA_MODEL_DEFAULT_ALI_RIBO;
double  cv_fact         = VRNA_MODEL_DEFAULT_ALI_CV_FACT;
double  nc_fact         = VRNA_MODEL_DEFAULT_ALI_NC_FACT;
int     logML           = VRNA_MODEL_DEFAULT_LOG_ML;

/* below are some more deprecated global symbols we need to get rid off */

int         james_rule = 1;       /* interior loops of size 2 get energy 0.8Kcal and
                                    no mismatches (no longer used) */
char        *RibosumFile = NULL;  /* TODO: compile ribosums into program
                                    Warning: this variable will vanish */
int         csv = 0;              /*generate comma seperated output*/
vrna_bp_stack_t       *base_pair = NULL;
FLT_OR_DBL  *pr = NULL;           /* base pairing prob. matrix */
int         *iindx = NULL;        /* pr[i,j] -> pr[iindx[i]-j] */
int         fold_constrained = 0; /* fold with constraints */

#endif

/*
#################################
# PRIVATE VARIABLES             #
#################################
*/
PRIVATE int rtype[8] = {0, 2, 1, 4, 3, 6, 5, 7};
PRIVATE int BP_pair[NBASES][NBASES]=
/* _  A  C  G  U  X  K  I */
{{ 0, 0, 0, 0, 0, 0, 0, 0},
 { 0, 0, 0, 0, 5, 0, 0, 5},
 { 0, 0, 0, 1, 0, 0, 0, 0},
 { 0, 0, 2, 0, 3, 0, 0, 0},
 { 0, 6, 0, 4, 0, 0, 0, 6},
 { 0, 0, 0, 0, 0, 0, 2, 0},
 { 0, 0, 0, 0, 0, 1, 0, 0},
 { 0, 6, 0, 0, 5, 0, 0, 0}};

PRIVATE vrna_md_t defaults = {
  VRNA_MODEL_DEFAULT_TEMPERATURE,
  1.,
  VRNA_MODEL_DEFAULT_DANGLES,
  VRNA_MODEL_DEFAULT_SPECIAL_HP,
  VRNA_MODEL_DEFAULT_NO_LP,
  VRNA_MODEL_DEFAULT_NO_GU,
  VRNA_MODEL_DEFAULT_NO_GU_CLOSURE,
  VRNA_MODEL_DEFAULT_LOG_ML,
  VRNA_MODEL_DEFAULT_CIRC,
  VRNA_MODEL_DEFAULT_GQUAD,
  VRNA_MODEL_DEFAULT_CANONICAL_BP,
  VRNA_MODEL_DEFAULT_UNIQ_ML,
  VRNA_MODEL_DEFAULT_ENERGY_SET,
  VRNA_MODEL_DEFAULT_BACKTRACK,
  VRNA_MODEL_DEFAULT_BACKTRACK_TYPE,
  VRNA_MODEL_DEFAULT_COMPUTE_BPP,
  {0},
  VRNA_MODEL_DEFAULT_MAX_BP_SPAN,
  TURN,
  VRNA_MODEL_DEFAULT_WINDOW_SIZE,
  VRNA_MODEL_DEFAULT_ALI_OLD_EN,
  VRNA_MODEL_DEFAULT_ALI_RIBO,
  VRNA_MODEL_DEFAULT_ALI_CV_FACT,
  VRNA_MODEL_DEFAULT_ALI_NC_FACT,
  1.07,
  {0, 2, 1, 4, 3, 6, 5, 7},
  {0, 1, 2, 3, 4, 3, 2, 0},
  {
    { 0, 0, 0, 0, 0, 0, 0, 0},
    { 0, 0, 0, 0, 5, 0, 0, 5},
    { 0, 0, 0, 1, 0, 0, 0, 0},
    { 0, 0, 2, 0, 3, 0, 0, 0},
    { 0, 6, 0, 4, 0, 0, 0, 6},
    { 0, 0, 0, 0, 0, 0, 2, 0},
    { 0, 0, 0, 0, 0, 1, 0, 0},
    { 0, 6, 0, 0, 5, 0, 0, 0}
  }
};

/*
#################################
# PRIVATE FUNCTION DECLARATIONS #
#################################
*/

/* Fill the base pair type encodings according to the model details */
PRIVATE void fill_pair_matrices(vrna_md_t *md);
PRIVATE void copy_nonstandards(vrna_md_t *md, const char *ns);

/*
#################################
# BEGIN OF FUNCTION DEFINITIONS #
#################################
*/

PUBLIC vrna_md_t *
vrna_md_copy( vrna_md_t       *md_to,
              const vrna_md_t *md_from){

  int i;
  vrna_md_t *md;

  md = NULL;

  /* only process if md_from is non-NULL */
  if(md_from){
    if(!md_to){
      /* create container to be filled */
      md = (vrna_md_t *)vrna_alloc(sizeof(vrna_md_t));
    } else {
      /* or directly write to target */
      md = md_to;
    }

    /* check if not the same object */
    if(md_to != md_from){
      /* copy simple members */
      memcpy(md, md_from, sizeof(vrna_md_t));
      /* copy arrays */
      memcpy(md->rtype, &(md_from->rtype[0]), 8 * sizeof(int));
      memcpy(md->alias, &(md_from->alias[0]), (MAXALPHA + 1) * sizeof(short));
      memcpy(md->nonstandards, &(md_from->nonstandards[0]), 64 * sizeof(char));
      /* copy matrices */
      for(i = 0; i <= MAXALPHA; i++){
        memcpy(md->pair[i], (md_from->pair[i]), (MAXALPHA + 1) * sizeof(int));
      }
    }
  }

  return md;
}

PUBLIC void
vrna_md_set_default(vrna_md_t *md){

  if(md) /* copy defaults */
    vrna_md_copy(md, &defaults);
}

PUBLIC char *
vrna_md_option_string(vrna_md_t  *md){
  static char options[255];
  *options = '\0';

  if(md){
    if(md->dangles != VRNA_MODEL_DEFAULT_DANGLES)
      sprintf(options + strlen(options), "-d%d ", md->dangles);
    if(!md->special_hp)
      strcat(options, "-4 ");
    if(md->noLP)
      strcat(options, "--noLP ");
    if(md->noGU)
      strcat(options, "--noGU ");
    if(md->noGUclosure)
      strcat(options, "--noClosingGU ");
    if(md->temperature != VRNA_MODEL_DEFAULT_TEMPERATURE)
      sprintf(options + strlen(options), "-T %f ", md->temperature);
  }

  return options;
}

PRIVATE void
copy_nonstandards(vrna_md_t *md, const char *ns){

  unsigned int n = strlen(ns);
  if(n < 64){
    memcpy(md->nonstandards, ns, strlen(ns)*sizeof(char));
    md->nonstandards[n] = '\0';
  }
}

PUBLIC void
vrna_md_set_nonstandards(vrna_md_t *md, const char *ns_bases){

  const char    *c;
  unsigned int  n;
  int           i, sym;

  if(md){
    if(ns_bases){
      n = strlen(ns_bases);
      if(n < 33){ /* parse the ns_bases list */
        c = ns_bases;
        i = sym = 0;
        if(*c == '-'){
          sym=1;
          c++;
        }

        while(*c != '\0'){
          if(*c != ','){
            md->nonstandards[i++] = *c++;
            md->nonstandards[i++] = *c;
            if((sym) && (*c != *(c-1))){
              md->nonstandards[i++] = *c;
              md->nonstandards[i++] = *(c-1);
            }
          }
          c++;
        }
        md->nonstandards[i] = '\0';

#ifdef  VRNA_BACKWARD_COMPAT
        free(nonstandards);
        nonstandards = vrna_alloc(33);
        memcpy(nonstandards, &(md->nonstandards[0]), 33*sizeof(char));
#endif
      } else {
        vrna_message_warning("vrna_md_set_nonstandards: list too long, dropping nonstandards!");
      }
    } else { /* remove nonstandards */
      md->nonstandards[0] = '\0';
#ifdef  VRNA_BACKWARD_COMPAT
      free(nonstandards);
      nonstandards = NULL;
#endif
    }

    /* update pair/rtype/alias arrays accordingly */
    vrna_md_update(md);
  }
}

PUBLIC void
vrna_md_defaults_reset(vrna_md_t *md_p){

  int i = 0;

  /* first, reset to factory defaults */
  defaults.dangles           = VRNA_MODEL_DEFAULT_DANGLES;
  defaults.special_hp        = VRNA_MODEL_DEFAULT_SPECIAL_HP;
  defaults.noLP              = VRNA_MODEL_DEFAULT_NO_LP;
  defaults.noGU              = VRNA_MODEL_DEFAULT_NO_GU;
  defaults.noGUclosure       = VRNA_MODEL_DEFAULT_NO_GU_CLOSURE;
  defaults.logML             = VRNA_MODEL_DEFAULT_LOG_ML;
  defaults.gquad             = VRNA_MODEL_DEFAULT_GQUAD;
  defaults.canonicalBPonly   = VRNA_MODEL_DEFAULT_CANONICAL_BP;
  defaults.circ              = VRNA_MODEL_DEFAULT_CIRC;
  defaults.uniq_ML           = VRNA_MODEL_DEFAULT_UNIQ_ML;
  defaults.compute_bpp       = VRNA_MODEL_DEFAULT_COMPUTE_BPP;
  defaults.backtrack         = VRNA_MODEL_DEFAULT_BACKTRACK;
  defaults.backtrack_type    = VRNA_MODEL_DEFAULT_BACKTRACK_TYPE;
  defaults.energy_set        = VRNA_MODEL_DEFAULT_ENERGY_SET;
  defaults.max_bp_span       = VRNA_MODEL_DEFAULT_MAX_BP_SPAN;
  defaults.min_loop_size     = TURN;
  defaults.window_size       = VRNA_MODEL_DEFAULT_WINDOW_SIZE;
  defaults.oldAliEn          = VRNA_MODEL_DEFAULT_ALI_OLD_EN;
  defaults.ribo              = VRNA_MODEL_DEFAULT_ALI_RIBO;
  defaults.cv_fact           = VRNA_MODEL_DEFAULT_ALI_CV_FACT;
  defaults.nc_fact           = VRNA_MODEL_DEFAULT_ALI_NC_FACT;
  defaults.temperature       = VRNA_MODEL_DEFAULT_TEMPERATURE;
  defaults.betaScale         = VRNA_MODEL_DEFAULT_BETA_SCALE;
  defaults.sfact             = 1.07;
  defaults.nonstandards[0]   = '\0';

  if(md_p){ /* now try to apply user settings */
    /*
        Note that we use wrapper functions here instead of
        faster direct memory copy because we want to ensure
        that model settings always comply to the constraints
        we set in the wrappers
    */
    vrna_md_defaults_dangles(md_p->dangles);
    vrna_md_defaults_special_hp(md_p->special_hp);
    vrna_md_defaults_noLP(md_p->noLP);
    vrna_md_defaults_noGU(md_p->noGU);
    vrna_md_defaults_noGUclosure(md_p->noGUclosure);
    vrna_md_defaults_logML(md_p->logML);
    vrna_md_defaults_gquad(md_p->gquad);
    defaults.canonicalBPonly = md_p->canonicalBPonly;
    vrna_md_defaults_circ(md_p->circ);
    vrna_md_defaults_uniq_ML(md_p->uniq_ML);
    vrna_md_defaults_compute_bpp(md_p->compute_bpp);
    vrna_md_defaults_backtrack(md_p->backtrack);
    vrna_md_defaults_backtrack_type(md_p->backtrack_type);
    vrna_md_defaults_energy_set(md_p->energy_set);
    vrna_md_defaults_max_bp_span(md_p->max_bp_span);
    vrna_md_defaults_min_loop_size(md_p->min_loop_size);
    vrna_md_defaults_window_size(md_p->window_size);
    vrna_md_defaults_oldAliEn(md_p->oldAliEn);
    vrna_md_defaults_ribo(md_p->ribo);
    vrna_md_defaults_cv_fact(md_p->cv_fact);
    vrna_md_defaults_nc_fact(md_p->nc_fact);
    vrna_md_defaults_temperature(md_p->temperature);
    vrna_md_defaults_betaScale(md_p->betaScale);
    vrna_md_defaults_sfact(md_p->sfact);
    copy_nonstandards(&defaults, &(md_p->nonstandards[0]));
  }

  /* update pair/rtype/alias arrays accordingly */
  vrna_md_update(&defaults);

#ifdef  VRNA_BACKWARD_COMPAT
  temperature     = defaults.temperature;
  pf_scale        = VRNA_MODEL_DEFAULT_PF_SCALE;
  dangles         = defaults.dangles;
  tetra_loop      = defaults.special_hp;
  noLonelyPairs   = defaults.noLP;
  noGU            = defaults.noGU;
  no_closingGU    = defaults.noGUclosure;
  circ            = defaults.circ;
  gquad           = defaults.gquad;
  canonicalBPonly = defaults.canonicalBPonly;
  uniq_ML         = defaults.uniq_ML;
  energy_set      = defaults.energy_set;
  do_backtrack    = defaults.compute_bpp;
  backtrack_type  = defaults.backtrack_type;
  nonstandards    = defaults.nonstandards;
  max_bp_span     = defaults.max_bp_span;
  oldAliEn        = defaults.oldAliEn;
  ribo            = defaults.ribo;
  cv_fact         = defaults.cv_fact;
  nc_fact         = defaults.nc_fact;
  logML           = defaults.logML;
#endif
}

/* below are the setter functions for global default settings */

PUBLIC void
vrna_md_defaults_temperature(double T){

  if(T >= -K0){
    defaults.temperature = T;
#ifdef VRNA_BACKWARD_COMPAT
    temperature = T;
#endif
  } else
    vrna_message_warning("vrna_md_defaults_temperature@model.c: Temperature out of range, T must be above absolute zero. Not changing anything!");
}

PUBLIC double
vrna_md_defaults_temperature_get(void){

  return defaults.temperature;
}

PUBLIC void
vrna_md_defaults_betaScale(double b){

  defaults.betaScale = b;
}

PUBLIC double
vrna_md_defaults_betaScale_get(void){

  return defaults.betaScale;
}

PUBLIC void
vrna_md_defaults_dangles(int d){
  if((d >= 0) && (d <= 3)){
    defaults.dangles = d;
#ifdef VRNA_BACKWARD_COMPAT
    dangles = d;
#endif
  } else
    vrna_message_warning("vrna_md_defaults_dangles@model.c: Dangles out of range, must be (0 <= d <= 3). Not changing anything!");
}

PUBLIC int
vrna_md_defaults_dangles_get(void){

  return defaults.dangles;
}

PUBLIC void
vrna_md_defaults_special_hp(int flag){

  defaults.special_hp = flag ? 1 : 0;
#ifdef VRNA_BACKWARD_COMPAT
  tetra_loop = defaults.special_hp;
#endif
}

PUBLIC int
vrna_md_defaults_special_hp_get(void){

  return defaults.special_hp;
}

PUBLIC void
vrna_md_defaults_noLP(int flag){

  defaults.noLP = flag ? 1 : 0;
#ifdef VRNA_BACKWARD_COMPAT
  noLonelyPairs = defaults.noLP;
#endif
}

PUBLIC int
vrna_md_defaults_noLP_get(void){

  return defaults.noLP;
}

PUBLIC void
vrna_md_defaults_noGU(int flag){

  defaults.noGU = flag ? 1 : 0;
#ifdef VRNA_BACKWARD_COMPAT
  noGU = defaults.noGU;
#endif
  /* update pair/rtype/alias arrays accordingly */
  vrna_md_update(&defaults);
}

PUBLIC int
vrna_md_defaults_noGU_get(void){

  return defaults.noGU;
}

PUBLIC void
vrna_md_defaults_noGUclosure(int flag){

  defaults.noGUclosure = flag ? 1 : 0;
#ifdef VRNA_BACKWARD_COMPAT
  no_closingGU = defaults.noGUclosure;
#endif
}

PUBLIC int
vrna_md_defaults_noGUclosure_get(void){

  return defaults.noGUclosure;
}

PUBLIC void
vrna_md_defaults_logML(int flag){

  defaults.logML = flag ? 1 : 0;
#ifdef VRNA_BACKWARD_COMPAT
  logML = defaults.logML;
#endif
}

PUBLIC int
vrna_md_defaults_logML_get(void){

  return defaults.logML;
}

PUBLIC void
vrna_md_defaults_circ(int flag){

  defaults.circ = flag ? 1 : 0;
#ifdef VRNA_BACKWARD_COMPAT
  circ = defaults.circ;
#endif
}

PUBLIC int
vrna_md_defaults_circ_get(void){

  return defaults.circ;
}

PUBLIC void
vrna_md_defaults_gquad(int flag){

  defaults.gquad = flag ? 1 : 0;
#ifdef VRNA_BACKWARD_COMPAT
  gquad = defaults.gquad;
#endif
}

PUBLIC int
vrna_md_defaults_gquad_get(void){

  return defaults.gquad;
}

PUBLIC void
vrna_md_defaults_uniq_ML(int flag){

  defaults.uniq_ML = flag ? 1 : 0;
#ifdef VRNA_BACKWARD_COMPAT
  uniq_ML = defaults.uniq_ML;
#endif
}

PUBLIC int
vrna_md_defaults_uniq_ML_get(void){

  return defaults.uniq_ML;
}

PUBLIC void
vrna_md_defaults_energy_set(int e){

  if((e >= 0) && (e <= 3)){
    defaults.energy_set = e;
#ifdef VRNA_BACKWARD_COMPAT
    energy_set = e;
#endif
    /* update pair/rtype/alias arrays accordingly */
    vrna_md_update(&defaults);
  } else
    vrna_message_warning("vrna_md_defaults_energy_set@model.c: Energy Set out of range, must be (0 <= e <= 3). Not changing anything!");
}

PUBLIC int
vrna_md_defaults_energy_set_get(void){

  return defaults.energy_set;
}

PUBLIC void
vrna_md_defaults_backtrack(int flag){

  defaults.backtrack = flag ? 1 : 0;
}

PUBLIC int
vrna_md_defaults_backtrack_get(void){

  return defaults.backtrack;
}

PUBLIC void
vrna_md_defaults_backtrack_type(char t){

  switch(t){
    case 'M': /* fall through */
    case 'C': /* fall through */
    case 'F': defaults.backtrack_type = t;
#ifdef VRNA_BACKWARD_COMPAT
              backtrack_type = t;
#endif
              break;
    default:  vrna_message_warning("vrna_md_defaults_backtrack_type@model.c: Backtrack type must be any of 'F', 'C', or 'M'. Not changing anything!");
  }
}

PUBLIC char
vrna_md_defaults_backtrack_type_get(void){

  return defaults.backtrack_type;
}

PUBLIC void
vrna_md_defaults_compute_bpp(int flag){

  if((flag >= 0) && (flag <= 2)){
    defaults.compute_bpp = flag;
#ifdef VRNA_BACKWARD_COMPAT
    do_backtrack = flag;
#endif
  } else
    defaults.compute_bpp = 1;
}

PUBLIC int
vrna_md_defaults_compute_bpp_get(void){

  return defaults.compute_bpp;
}

PUBLIC void
vrna_md_defaults_max_bp_span(int span){

  defaults.max_bp_span = (span <= 0) ? -1 : span;
#ifdef VRNA_BACKWARD_COMPAT
  max_bp_span = defaults.max_bp_span;
#endif
}

PUBLIC int
vrna_md_defaults_max_bp_span_get(void){

  return defaults.max_bp_span;
}

PUBLIC void
vrna_md_defaults_min_loop_size(int size){

  defaults.min_loop_size = (size < 0) ? 0 : size;
}

PUBLIC int
vrna_md_defaults_min_loop_size_get(void){

  return defaults.min_loop_size;
}

PUBLIC void
vrna_md_defaults_window_size(int size){

  defaults.window_size = (size <= 0) ? -1 : size;
}

PUBLIC int
vrna_md_defaults_window_size_get(void){

  return defaults.window_size;
}

PUBLIC void
vrna_md_defaults_oldAliEn(int flag){

  defaults.oldAliEn = flag ? 1 : 0;
#ifdef VRNA_BACKWARD_COMPAT
  oldAliEn = defaults.oldAliEn;
#endif
}

PUBLIC int
vrna_md_defaults_oldAliEn_get(void){

  return defaults.oldAliEn;
}

PUBLIC void
vrna_md_defaults_ribo(int flag){

  defaults.ribo = flag ? 1 : 0;
#ifdef VRNA_BACKWARD_COMPAT
  ribo = defaults.ribo;
#endif
}

PUBLIC int
vrna_md_defaults_ribo_get(void){

  return defaults.ribo;
}

PUBLIC void
vrna_md_defaults_cv_fact(double factor){

  defaults.cv_fact = factor;
#ifdef VRNA_BACKWARD_COMPAT
  cv_fact = factor;
#endif
}

PUBLIC double
vrna_md_defaults_cv_fact_get(void){

  return defaults.cv_fact;
}

PUBLIC void
vrna_md_defaults_nc_fact(double factor){

  defaults.nc_fact = factor;
#ifdef VRNA_BACKWARD_COMPAT
  nc_fact = factor;
#endif
}

PUBLIC double
vrna_md_defaults_nc_fact_get(void){

  return defaults.nc_fact;
}

PUBLIC void
vrna_md_defaults_sfact(double factor){

  defaults.sfact = factor;
}

PUBLIC double
vrna_md_defaults_sfact_get(void){

  return defaults.sfact;
}


PUBLIC void
vrna_md_update(vrna_md_t *md){

  if(md)
    fill_pair_matrices(md);
}


/*
    This function updates the pair/alias/rtype arrays according to model settings.
    It should be called whenever there is a change in the following model settings:
    - energy_set
    - noGU
    - nonstandards
*/
PRIVATE void
fill_pair_matrices(vrna_md_t *md){

  int i,j;

  /* nullify everything */
  for(i = 0;i <= MAXALPHA; i++)
    memset(md->pair[i], 0, (MAXALPHA + 1) * sizeof(int));

  memset(md->alias, 0, (MAXALPHA + 1) * sizeof(short));

  /* start setting actual base pair type encodings */
  switch(md->energy_set){
    case  0:    for(i = 0; i < 5; i++)
                  md->alias[i] = (short) i;

                md->alias[5] = 3; /* X <-> G */
                md->alias[6] = 2; /* K <-> C */
                md->alias[7] = 0; /* I <-> default base '@' */

                for(i = 0; i < NBASES; i++)
                    for(j = 0; j < NBASES; j++)
                      md->pair[i][j] = BP_pair[i][j];

                if(md->noGU)
                  md->pair[3][4] = md->pair[4][3] = 0;

                if(md->nonstandards[0] != '\0') {  /* allow nonstandard bp's (encoded by type=7) */
                   for(i = 0; i < (int)strlen(md->nonstandards); i += 2)
                      md->pair[vrna_nucleotide_encode(md->nonstandards[i], md)]
                        [vrna_nucleotide_encode(md->nonstandards[i+1], md)] = 7;
                }

                break;

    case 1:     for(i = 1; i < MAXALPHA;){
                  md->alias[i++] = 3;  /* A <-> G */
                  md->alias[i++] = 2;  /* B <-> C */
                }
                for(i = 1; i < MAXALPHA; i++){
                  md->pair[i][i+1] = 2;    /* AB <-> GC */
                  i++;
                  md->pair[i][i-1] = 1;    /* BA <-> CG */
                }

                break;

    case 2:     for(i = 1; i < MAXALPHA;){
                  md->alias[i++] = 1;  /* A <-> A*/
                  md->alias[i++] = 4;  /* B <-> U */
                }
                for(i = 1; i < MAXALPHA; i++){
                  md->pair[i][i+1] = 5;    /* AB <-> AU */
                  i++;
                  md->pair[i][i-1] = 6;    /* BA <-> UA */
                }

                break;

    case 3:     for(i = 1; i < MAXALPHA - 2; ){
                  md->alias[i++] = 3;  /* A <-> G */
                  md->alias[i++] = 2;  /* B <-> C */
                  md->alias[i++] = 1;  /* C <-> A */
                  md->alias[i++] = 4;  /* D <-> U */
                }
                for(i = 1; i < MAXALPHA - 2; i++){
                  md->pair[i][i+1] = 2;    /* AB <-> GC */
                  i++;
                  md->pair[i][i-1] = 1;    /* BA <-> CG */
                  i++;
                  md->pair[i][i+1] = 5;    /* CD <-> AU */
                  i++;
                  md->pair[i][i-1] = 6;    /* DC <-> UA */
                }

                break;

    default:    vrna_message_error("Which energy_set are YOU using??");
                break;
  }

  /* set the reverse base pair types */
  for(i = 0; i <= MAXALPHA; i++){
    for(j = 0; j <= MAXALPHA; j++){
      md->rtype[md->pair[i][j]] = md->pair[j][i];
    }
  }

  /* handle special cases separately */
  md->rtype[0] = 0;
  md->rtype[7] = 7;

  /* was used for energy_set == 0
  for(i = 0; i < NBASES; i++)
      for(j = 0; j < NBASES; j++)
       md->rtype[md->pair[i][j]] = md->pair[j][i];
  */
}

#ifdef  VRNA_BACKWARD_COMPAT

/*###########################################*/
/*# deprecated functions below              #*/
/*###########################################*/

PUBLIC void
set_model_details(vrna_md_t *md){

  if(md){
    /* make sure there are no uninitialized data fields */
    memset(md, 0, sizeof(vrna_md_t));

    md->dangles           = dangles;
    md->special_hp        = tetra_loop;
    md->noLP              = noLonelyPairs;
    md->noGU              = noGU;
    md->noGUclosure       = no_closingGU;
    md->logML             = logML;
    md->gquad             = gquad;
    md->canonicalBPonly   = canonicalBPonly;
    md->circ              = circ;
    md->uniq_ML           = uniq_ML;
    md->compute_bpp       = do_backtrack;
    md->backtrack         = VRNA_MODEL_DEFAULT_BACKTRACK;
    md->backtrack_type    = backtrack_type;
    md->energy_set        = energy_set;
    md->max_bp_span       = max_bp_span;
    md->min_loop_size     = TURN;
    md->window_size       = VRNA_MODEL_DEFAULT_WINDOW_SIZE;
    md->oldAliEn          = oldAliEn;
    md->ribo              = ribo;
    md->cv_fact           = cv_fact;
    md->nc_fact           = nc_fact;
    md->temperature       = temperature;
    md->betaScale         = VRNA_MODEL_DEFAULT_BETA_SCALE;
    md->sfact             = 1.07;

    if (nonstandards)
      copy_nonstandards(md, nonstandards);

    /* set default values for the pair/rtype[pair] stuff */
    vrna_md_update(md);

  }
}


PUBLIC char *
option_string(void){

  vrna_md_t md;
  set_model_details(&md);

  return vrna_md_option_string(&md);
}


#endif