int main(int argc, char *argv[])
{
char *line;
char *sequence;
char *structure = NULL;
char fname[21];
char *ParamFile = NULL;
char *ns_bases = NULL, *c;
int i, length, l, sym, r;
int istty;
double deltaf, deltap=0;
int delta=100;
int n_back = 0;
int noconv = 0;
int circ=0;
int dos=0;
int zuker=0;
do_backtrack = 1;
dangles = 2;
for (i=1; i<argc; i++) {
if (argv[i][0]=='-')
switch ( argv[i][1] )
{
case 'T': if (argv[i][2]!='\0') usage();
if(i==argc-1) usage();
r=sscanf(argv[++i], "%lf", &temperature);
if (r!=1) usage();
break;
case 'p':
if (argv[i][2]!='\0') usage();
if(i==argc-1) usage();
(void) sscanf(argv[++i], "%d", &n_back);
init_rand();
break;
case 'n':
if ( strcmp(argv[i], "-noGU" )==0) noGU=1;
if ( strcmp(argv[i], "-noCloseGU" ) ==0) no_closingGU=1;
if ( strcmp(argv[i], "-noLP")==0) noLonelyPairs=1;
if ( strcmp(argv[i], "-nsp") ==0) {
if (i==argc-1) usage();
ns_bases = argv[++i];
}
if ( strcmp(argv[i], "-noconv")==0) noconv=1;
break;
case '4':
tetra_loop=0;
break;
case 'C':
fold_constrained=1;
break;
case 'D':
dos=1;
print_energy = -999999;
break;
case 'd': dangles=0;
if (argv[i][2]!='\0') {
r=sscanf(argv[i]+2, "%d", &dangles);
if (r!=1) usage();
}
break;
case 'P':
if (i==argc-1) usage();
ParamFile = argv[++i];
break;
case 's':
subopt_sorted=1;
break;
case 'l':
if (strcmp(argv[i],"-logML")==0) {
logML=1;
break;
}
else usage();
break;
case 'e':
if (i>=argc-1) usage();
if (strcmp(argv[i],"-ep")==0)
r=sscanf(argv[++i], "%lf", &deltap);
else {
r=sscanf(argv[++i], "%lf", &deltaf);
delta = (int) (0.1+deltaf*100);
}
if (r!=1) usage();
break;
case 'c':
if ( strcmp(argv[i], "-circ")==0) circ=1;
break;
case 'z':
zuker=1;
break;
default: usage();
}
}
if ((zuker)&&(circ)) {
printf("Sorry, zuker subopts not yet implemented for circfold\n");
usage();
}
if ((zuker)&&(n_back>0)) {
printf("Cna't do zuker subopts and stochastic subopts at the same time\n");
usage();
}
if (ParamFile != NULL)
read_parameter_file(ParamFile);
if (ns_bases != NULL) {
nonstandards = space(33);
c=ns_bases;
i=sym=0;
if (*c=='-') {
sym=1; c++;
}
while (*c) {
if (*c!=',') {
nonstandards[i++]=*c++;
nonstandards[i++]=*c;
if ((sym)&&(*c!=*(c-1))) {
nonstandards[i++]=*c;
nonstandards[i++]=*(c-1);
}
}
c++;
}
}
istty = isatty(fileno(stdout))&&isatty(fileno(stdin));
if ((fold_constrained)&&(istty)) {
printf("Input constraints using the following notation:\n");
/* printf("| : paired with another base\n"); */
printf(". : no constraint at all\n");
printf("x : base must not pair\n");
}
do { /* main loop: continue until end of file */
cut_point = -1;
if (istty) {
printf("\nInput string (upper or lower case); @ to quit\n");
if (!zuker)printf("Use '&' to connect 2 sequences that shall form a complex.\n");
printf("%s\n", scale);
}
fname[0]='\0';
if ((line = get_line(stdin))==NULL) break;
/* skip comment lines and get filenames */
while ((*line=='*')||(*line=='\0')||(*line=='>')) {
if (*line=='>')
(void) sscanf(line, ">%20s", fname);
free(line);
if ((line = get_line(stdin))==NULL) break;;
}
if ((line==NULL)||strcmp(line,"@")==0) break;
sequence = tokenize(line); /* frees line */
length = (int) strlen(sequence);
structure = (char *) space((unsigned) length+1);
if (fold_constrained) {
char *cstruc;
cstruc = tokenize(get_line(stdin));
if (cstruc!=NULL) {
strncpy(structure, cstruc, length);
for (i=0; i<length; i++)
if (structure[i]=='|')
nrerror("constraints of type '|' not allowed");
free(cstruc);
}
}
for (l = 0; l < length; l++) {
sequence[l] = toupper(sequence[l]);
if (!noconv && sequence[l] == 'T') sequence[l] = 'U';
}
if (istty) {
if (cut_point == -1)
printf("length = %d\n", length);
else
printf("length1 = %d\nlength2 = %d\n",
cut_point-1, length-cut_point+1);
}
if ((logML!=0 || dangles==1 || dangles==3) && dos==0)
if (deltap<=0) deltap=delta/100. +0.001;
if (deltap>0)
print_energy = deltap;
/* first lines of output (suitable for sort +1n) */
if (fname[0] != '\0')
printf("> %s [%d]\n", fname, delta);
if (n_back>0) { /* stochastic backtrack */
double mfe, kT;
char *ss;
st_back=1;
ss = (char *) space(strlen(sequence)+1);
strncpy(ss, structure, length);
mfe = fold(sequence, ss);
kT = (temperature+273.15)*1.98717/1000.; /* in Kcal */
pf_scale = exp(-(1.03*mfe)/kT/length);
strncpy(ss, structure, length);
/* ignore return value, we are not interested in the free energy */
(circ) ? (void) pf_circ_fold(sequence, ss) : (void) pf_fold(sequence, ss);
free(ss);
for (i=0; i<n_back; i++) {
char *s;
s =(circ) ? pbacktrack_circ(sequence) : pbacktrack(sequence);
printf("%s\n", s);
free(s);
}
free_pf_arrays();
} else if (!zuker) { /* normal subopt */
(circ) ? subopt_circ(sequence, structure, delta, stdout) : subopt(sequence, structure, delta, stdout);
if (dos) {
int i;
for (i=0; i<= MAXDOS && i<=delta/10; i++) {
printf("%4d %6d\n", i, density_of_states[i]);
}
}
} else { /* Zuker suboptimals */
SOLUTION *zr;
int i;
if (cut_point!=-1) {
printf("Sorry, zuker subopts not yet implemented for cofold\n");
usage();
}
zr = zukersubopt(sequence);
putoutzuker(zr);
(void)fflush(stdout);
for (i=0; zr[i].structure; i++) {
free(zr[i].structure);
}
free(zr);
}
(void)fflush(stdout);
free(sequence);
free(structure);
} while (1);
return 0;
}
bool plan_heuristic::getSuggestions() {
if (!m_suggestions.empty()) {
return true;
}
DREAL_LOG_INFO << "plan_heuristic::getSuggestions()";
displayTrail();
if (trail->size() > lastTrailEnd)
pushTrailOnStack();
bool suggestion_consistent = isStackConsistentWithSuggestion();
bool found_path = false;
bool path_possible = true;
// bool suggest_defaults = true;
if(!m_suggestions.empty() && suggestion_consistent) {
return true;
} else if(!suggestion_consistent || backtracked) {
path_possible = unwind_path();
}
while (!found_path && path_possible) {
if (path_possible) {
found_path = expand_path();
}
if (!found_path) {
path_possible = pbacktrack();
}
}
if (m_decision_stack.size() == 0)
return false;
completeSuggestionsForTrail();
// for (int time = m_depth; time >= 0; time--) {
// DREAL_LOG_DEBUG << "Depth = " << time;
// for (auto & p : *time_event_enodes[time]) {
// Enode* ev = p.second;
// // ev->setDecPolarity(l_True);
// m_suggestions.push_back(ev);
// }
// }
// for (int time = 0; time <= m_depth; time++) {
// for (auto & p : *time_process_enodes[time]) {
// Enode* proc = p.second;
// // proc->setDecPolarity(l_True);
// m_suggestions.push_back(proc);
// }
// }
// for (int time = 0; time <= m_depth; time++) {
// for (auto & p : *time_act_enodes[time]) {
// Enode* proc = p.second;
// // proc->setDecPolarity(l_True);
// m_suggestions.push_back(proc);
// }
// }
// for (int time = 0; time <= m_depth; time++) {
// for (auto & p : *time_duract_enodes[time]) {
// Enode* proc = p.second;
// // proc->setDecPolarity(l_True);
// m_suggestions.push_back(proc);
// }
// }
// for (auto e : m_suggestions) {
DREAL_LOG_INFO << "plan_heuristic::getSuggestions(): Suggesting ";
// << (e->getPolarity() == l_True ? " " : "(not ")
// << e
// << (e->getPolarity() == l_True ? "" : ")")
// << " = "
// << (e->getDecPolarity() == l_True ?
// " True" :
// (e->getDecPolarity() == l_False ? " False" : " Unknown"))
// << endl;
// }
return true;
}
int main(int argc, char *argv[])
{
char *sequence;
char *structure = NULL;
char *ns_bases = NULL, *c;
int i, length, l, sym;
int istty;
double deltap=0.;
int delta=100;
int n_back = 0;
int noconv=0;
int circ=0;
int dos=0;
AjPSeq seq = NULL;
AjPFile confile = NULL;
AjPFile paramfile = NULL;
AjPFile outf = NULL;
AjPStr constring = NULL;
float eT = 0.;
AjBool eGU;
AjBool eclose;
AjBool lonely;
AjBool convert;
AjPStr ensbases = NULL;
AjBool etloop;
AjPStr edangles = NULL;
char edangle = '\0';
ajint len;
float erange;
float prange;
embInitPV("vrnasubopt",argc,argv,"VIENNA",VERSION);
constring = ajStrNew();
seq = ajAcdGetSeq("sequence");
confile = ajAcdGetInfile("constraintfile");
paramfile = ajAcdGetInfile("paramfile");
eT = ajAcdGetFloat("temperature");
circ = !!ajAcdGetBoolean("circular");
dos = !!ajAcdGetBoolean("dos");
eGU = ajAcdGetBoolean("gu");
eclose = ajAcdGetBoolean("closegu");
lonely = ajAcdGetBoolean("lp");
convert = ajAcdGetBoolean("convert");
ensbases = ajAcdGetString("nsbases");
etloop = ajAcdGetBoolean("tetraloop");
erange = ajAcdGetFloat("erange");
prange = ajAcdGetFloat("prange");
subopt_sorted = !!ajAcdGetBoolean("sort");
logML = !!ajAcdGetBoolean("logml");
n_back = ajAcdGetInt("nrandom");
edangles = ajAcdGetListSingle("dangles");
outf = ajAcdGetOutfile("outfile");
if(dos)
print_energy = -999999;
do_backtrack = 1;
istty = 0;
temperature = (double) eT;
noGU = (eGU) ? 0 : 1;
no_closingGU = (eclose) ? 0 : 1;
noLonelyPairs = (lonely) ? 0 : 1;
noconv = (convert) ? 0 : 1;
ns_bases = (ajStrGetLen(ensbases)) ? MAJSTRGETPTR(ensbases) : NULL;
tetra_loop = !!etloop;
delta = (int) (0.1 + erange * 100);
deltap = prange;
edangle = *ajStrGetPtr(edangles);
if(edangle == '0')
dangles = 0;
else if(edangle == '1')
dangles = 1;
else if(edangle == '2')
dangles = 2;
else if(edangle == '3')
dangles = 3;
if(paramfile)
read_parameter_file(paramfile);
if (ns_bases != NULL)
{
nonstandards = space(33);
c=ns_bases;
i=sym=0;
if (*c=='-')
{
sym=1;
c++;
}
while (*c)
{
if (*c!=',')
{
nonstandards[i++]=*c++;
nonstandards[i++]=*c;
if ((sym)&&(*c!=*(c-1)))
{
nonstandards[i++]=*c;
nonstandards[i++]=*(c-1);
}
}
c++;
}
}
if(confile)
vienna_GetConstraints(confile,&constring);
if(n_back)
init_rand();
sequence = NULL;
structure = NULL;
length = ajSeqGetLen(seq);
sequence = (char *) space(length+1);
strcpy(sequence,ajSeqGetSeqC(seq));
len = ajStrGetLen(constring);
structure = (char *) space(length+1);
if(len)
{
fold_constrained = 1;
strcpy(structure,ajStrGetPtr(constring));
}
istty = 0;
if (fold_constrained)
{
for (i=0; i<length; i++)
if (structure[i]=='|')
ajFatal("Constraints of type '|' are not allowed\n");
}
for (l = 0; l < length; l++)
{
sequence[l] = toupper(sequence[l]);
if (!noconv && sequence[l] == 'T')
sequence[l] = 'U';
}
if ((logML!=0 || dangles==1 || dangles==3) && dos==0)
if (deltap<=0) deltap=delta/100. +0.001;
if (deltap>0)
print_energy = deltap;
/* first lines of output (suitable for sort +1n) */
ajFmtPrintF(outf,"> %s [%d]\n", ajSeqGetNameC(seq), delta);
if(n_back>0)
{
int i;
double mfe, kT;
char *ss;
st_back=1;
ss = (char *) space(strlen(sequence)+1);
strncpy(ss, structure, length);
mfe = (circ) ? circfold(sequence, ss) : fold(sequence, ss);
kT = (temperature+273.15)*1.98717/1000.; /* in Kcal */
pf_scale = exp(-(1.03*mfe)/kT/length);
strncpy(ss, structure, length);
/*
** we are not interested in the free energy but in the bppm, so we
** drop free energy into the void
*/
(circ) ? (void) pf_circ_fold(sequence, ss) :
(void) pf_fold(sequence, ss);
free(ss);
for (i=0; i<n_back; i++)
{
char *s;
s = (circ) ? pbacktrack_circ(sequence) : pbacktrack(sequence);
ajFmtPrintF(outf,"%s\n", s);
free(s);
}
free_pf_arrays();
}
else
{
(circ) ? subopt_circ(sequence, structure, delta, ajFileGetFileptr(outf)) :
subopt(sequence, structure, delta, ajFileGetFileptr(outf));
}
free(sequence);
free(structure);
ajSeqDel(&seq);
ajStrDel(&ensbases);
ajStrDel(&edangles);
ajFileClose(&confile);
ajFileClose(&outf);
ajFileClose(¶mfile);
embExit();
return 0;
}
// undo choices on m_decision_stack until earliest violated decision
bool plan_heuristic::unwind_path() {
// vector<int> path;
// path.assign(num_autom*(m_depth+1), -1);
// int actual_path_size = 0;
// for (auto e : m_stack) {
// DREAL_LOG_INFO << "Checking path " << e->first << " = " << e->second;
// auto i = (*tim_act_enodeserals[a]).find(e->first);
// if (i != (*mode_literals[a]).end()) {
// DREAL_LOG_DEBUG << "setting path[" << (((*i).second->second*num_autom)+(num_autom-a)-1) << "] = "
// << (*i).second->first;
// path[((*i).second->second*num_autom)+(num_autom-a-1)] = (*i).second->first;
// actual_path_size++;
// break;
// }
// }
// }
//int earliest_disagreement = m_decision_stack.size();
bool need_bt_to_decision = false;
for(int i = m_decision_stack.size()-1; i >= 0; i--) {
pair<Enode*, vector<bool>*> *decision = m_decision_stack[i];
// bool found_decision = false;
for(int j = m_stack.size()-1; j >= 0; j--) {
pair<Enode*, bool>* sdecision = m_stack[j];
if(decision->first == sdecision->first) {
// found_decision = true;
//decision disagrees w/ m_stack
if(sdecision->second != decision->second->back()) {
//found possibly earliest disagreement, clear decision stack to this point
for(int k = m_decision_stack.size()-1; k > i; k--) {
delete m_decision_stack[k]->second;
delete m_decision_stack[k];
m_decision_stack.pop_back();
}
need_bt_to_decision = false; //backtracked over any empty decisions
//clear conflicting decision
m_decision_stack[i]->second->pop_back();
if(m_decision_stack[i]->second->empty()) {
need_bt_to_decision = true;
}
}
}
}
}
if(need_bt_to_decision) {
//clean up decision stack so that there are no levels with no decisions
pbacktrack();
}
// bool paths_agree = true;
// int agree_depth = 0;
// for (int j = static_cast<int>(path.size() - 1); j > -1; j--) {
// DREAL_LOG_INFO << "Path (" << j << ") = " << path[j] << endl;
// int stack_index_for_path_index = static_cast<int>(path.size() - j - 1);
// if (stack_index_for_path_index < static_cast<int>(m_decision_stack.size()))
// DREAL_LOG_INFO << "Stack(" << stack_index_for_path_index << ") = a"
// << (m_decision_stack[stack_index_for_path_index]->first+1)
// << " m"
// << m_decision_stack[stack_index_for_path_index]->second->back();
// else
// DREAL_LOG_INFO << "Stack(" << stack_index_for_path_index << ") = *";
// if (stack_index_for_path_index < static_cast<int>(m_decision_stack.size())) {
// if (m_decision_stack[stack_index_for_path_index]->second->back() != path[j]) {
// if (paths_agree) {
// agree_depth = stack_index_for_path_index-1;
// DREAL_LOG_INFO << "Last Agreed at: " << agree_depth << endl;
// }
// paths_agree = false;
// }
// } else {
// if (paths_agree) {
// agree_depth = stack_index_for_path_index-1;
// DREAL_LOG_INFO << "Last Agreed at: " << agree_depth << endl;
// }
// paths_agree = false;
// }
// }
// // only unwind if decision stack needs to be
// int num_backtrack_steps = m_decision_stack.size() - agree_depth-1; // actual_path_size;
// DREAL_LOG_DEBUG << "Backtracking, # steps = " << num_backtrack_steps;
// if (// static_cast<int>(m_decision_stack.size()) > actual_path_size ||
// !paths_agree && num_backtrack_steps > 0) {
// for (int i = 0; i < num_backtrack_steps; i++) {
// DREAL_LOG_INFO << "Backtracking " << i << endl;
// if (i == num_backtrack_steps-1) {
// //choose sibling of at this level if it exists
// int path_index_for_stack_pos = i;//((m_depth+1)*num_autom) - m_decision_stack.size()+1;
// // if SAT solver already chose a sibling, then choose it, otherwise take the last
// if (path[path_index_for_stack_pos] != -1) {
// DREAL_LOG_DEBUG << "Moving to back " << path[path_index_for_stack_pos];
// m_decision_stack.back()->second->pop_back();
// for (vector<int>::iterator e = m_decision_stack.back()->second->begin();
// e != m_decision_stack.back()->second->end(); ) {
// if (*e == path[path_index_for_stack_pos]) {
// DREAL_LOG_DEBUG << "ReMoving " << *e;
// m_decision_stack.back()->second->erase(e);
// e = m_decision_stack.back()->second->begin();
// } else {
// e++;
// }
// }
// m_decision_stack.back()->second->push_back(path[path_index_for_stack_pos]);
// } else {
// m_decision_stack.back()->second->pop_back();
// if( m_decision_stack.back()->second->empty()) {
// delete m_decision_stack.back()->second;
// delete m_decision_stack.back();
// m_decision_stack.pop_back();
// }
// }
// } else {
// // the parent choice was unassigned too, so this decision no longer needed
// delete m_decision_stack.back()->second;
// delete m_decision_stack.back();
// m_decision_stack.pop_back();
// }
// // there is only a decision to backtrack if m_decision_stack.size() > m_depth - i
// //if (static_cast<int>(m_decision_stack.size()) > 0) { // ((m_depth+1)*num_autom)-1 - i) {
// // if (i == 0) {
// // // remove decision for time zero, which must be initial node
// // // this is never to blame for the backtrack, but must be backtracked over
// // delete m_decision_stack.back()->second;
// // delete m_decision_stack.back();
// // m_decision_stack.pop_back();
// // } else if (m_decision_stack.back() != NULL &&
// // m_decision_stack.back()->second->size() > 1) {
// // // there is an unexplored sibling at this level
// // // remove current choice at time and choose a sibling
// // int path_index_for_stack_pos = ((m_depth+1)*num_autom) - m_decision_stack.size()+1;
// // // if SAT solver already chose a sibling, then choose it, otherwise take the last
// // if (path[path_index_for_stack_pos] != -1) {
// // DREAL_LOG_DEBUG << "Moving to back " << path[path_index_for_stack_pos];
// // m_decision_stack.back()->second->pop_back();
// // for (vector<int>::iterator e = m_decision_stack.back()->second->begin();
// // e != m_decision_stack.back()->second->end(); ) {
// // if (*e == path[path_index_for_stack_pos]) {
// // DREAL_LOG_DEBUG << "ReMoving " << *e;
// // m_decision_stack.back()->second->erase(e);
// // e = m_decision_stack.back()->second->begin();
// // } else {
// // e++;
// // }
// // }
// // m_decision_stack.back()->second->push_back(path[path_index_for_stack_pos]);
// // } else {
// // m_decision_stack.back()->second->pop_back();
// // }
// // break;
// // } else {
// // // the parent choice was unassigned too, so this decision no longer needed
// // delete m_decision_stack.back()->second;
// // delete m_decision_stack.back();
// // m_decision_stack.pop_back();
// // }
// // }
// }
// }
// for (int j = static_cast<int>(path.size() - 1); j > -1; j--) {
// DREAL_LOG_INFO << "Path (" << j << ") = " << path[j] << endl;
// int stack_index_for_path_index = static_cast<int>(path.size() - j - 1);
// if (stack_index_for_path_index < static_cast<int>(m_decision_stack.size()))
// DREAL_LOG_INFO << "Stack(" << stack_index_for_path_index << ") = "
// << m_decision_stack[stack_index_for_path_index]->second->back();
// else {
// DREAL_LOG_INFO << "No choices left!";
// }
// }
return m_decision_stack.size() > 0;
}
int main(int argc, char *argv[]){
struct RNAsubopt_args_info args_info;
unsigned int input_type;
char fname[80], *cstruc, *sequence, *c, *input_string;
char *structure = NULL, *ParamFile = NULL, *ns_bases = NULL;
int i, length, l, sym, istty;
double deltaf, deltap;
int delta, n_back, noconv, circular, dos, zuker;
do_backtrack = 1;
dangles = 2;
delta = 100;
deltap = n_back = noconv = circular = dos = zuker = 0;
/*
#############################################
# check the command line parameters
#############################################
*/
if(RNAsubopt_cmdline_parser (argc, argv, &args_info) != 0) exit(1);
/* temperature */
if(args_info.temp_given) temperature = args_info.temp_arg;
/* structure constraint */
if(args_info.constraint_given) fold_constrained=1;
/* do not take special tetra loop energies into account */
if(args_info.noTetra_given) tetra_loop=0;
/* set dangle model */
if(args_info.dangles_given) dangles = args_info.dangles_arg;
/* do not allow weak pairs */
if(args_info.noLP_given) noLonelyPairs = 1;
/* do not allow wobble pairs (GU) */
if(args_info.noGU_given) noGU = 1;
/* do not allow weak closing pairs (AU,GU) */
if(args_info.noClosingGU_given) no_closingGU = 1;
/* do not convert DNA nucleotide "T" to appropriate RNA "U" */
if(args_info.noconv_given) noconv = 1;
/* take another energy parameter set */
if(args_info.paramFile_given) ParamFile = strdup(args_info.paramFile_arg);
/* Allow other pairs in addition to the usual AU,GC,and GU pairs */
if(args_info.nsp_given) ns_bases = strdup(args_info.nsp_arg);
/* energy range */
if(args_info.deltaEnergy_given) delta = (int) (0.1+args_info.deltaEnergy_arg*100);
/* energy range after post evaluation */
if(args_info.deltaEnergyPost_given) deltap = args_info.deltaEnergyPost_arg;
/* sorted output */
if(args_info.sorted_given) subopt_sorted = 1;
/* assume RNA sequence to be circular */
if(args_info.circ_given) circular=1;
/* stochastic backtracking */
if(args_info.stochBT_given){
n_back = args_info.stochBT_arg;
init_rand();
}
/* density of states */
if(args_info.dos_given){
dos = 1;
print_energy = -999999;
}
/* logarithmic multiloop energies */
if(args_info.logML_given) logML = 1;
/* zuker subopts */
if(args_info.zuker_given) zuker = 1;
if(zuker){
if(circular){
warn_user("Sorry, zuker subopts not yet implemented for circfold");
RNAsubopt_cmdline_parser_print_help();
exit(1);
}
else if(n_back>0){
warn_user("Can't do zuker subopts and stochastic subopts at the same time");
RNAsubopt_cmdline_parser_print_help();
exit(1);
}
}
/* free allocated memory of command line data structure */
RNAsubopt_cmdline_parser_free(&args_info);
/*
#############################################
# begin initializing
#############################################
*/
if (ParamFile != NULL) read_parameter_file(ParamFile);
if (ns_bases != NULL) {
nonstandards = space(33);
c=ns_bases;
i=sym=0;
if (*c=='-') {
sym=1; c++;
}
while (*c!='\0') {
if (*c!=',') {
nonstandards[i++]=*c++;
nonstandards[i++]=*c;
if ((sym)&&(*c!=*(c-1))) {
nonstandards[i++]=*c;
nonstandards[i++]=*(c-1);
}
}
c++;
}
}
istty = isatty(fileno(stdout))&&isatty(fileno(stdin));
if(fold_constrained && istty) print_tty_constraint(VRNA_CONSTRAINT_DOT | VRNA_CONSTRAINT_X);
/*
#############################################
# main loop: continue until end of file
#############################################
*/
do {
cut_point = -1;
/*
########################################################
# handle user input from 'stdin'
########################################################
*/
if(istty){
if (!zuker)
printf("Use '&' to connect 2 sequences that shall form a complex.\n");
print_tty_input_seq();
}
/* extract filename from fasta header if available */
fname[0] = '\0';
while((input_type = get_input_line(&input_string, 0)) == VRNA_INPUT_FASTA_HEADER){
printf(">%s\n", input_string);
(void) sscanf(input_string, "%42s", fname);
free(input_string);
}
/* break on any error, EOF or quit request */
if(input_type & (VRNA_INPUT_QUIT | VRNA_INPUT_ERROR)){ break;}
/* else assume a proper sequence of letters of a certain alphabet (RNA, DNA, etc.) */
else{
sequence = tokenize(input_string); /* frees input_string */
length = (int) strlen(sequence);
}
structure = (char *) space((unsigned) length+1);
if(noconv) str_RNA2RNA(sequence);
else str_DNA2RNA(sequence);
if(istty){
if (cut_point == -1)
printf("length = %d\n", length);
else
printf("length1 = %d\nlength2 = %d\n", cut_point-1, length-cut_point+1);
}
/* get structure constraint or break if necessary, entering an empty line results in a warning */
if (fold_constrained) {
input_type = get_input_line(&input_string, VRNA_INPUT_NOSKIP_COMMENTS);
if(input_type & VRNA_INPUT_QUIT){ break;}
else if((input_type & VRNA_INPUT_MISC) && (strlen(input_string) > 0)){
cstruc = tokenize(input_string);
strncpy(structure, cstruc, length);
for (i=0; i<length; i++)
if (structure[i]=='|')
nrerror("constraints of type '|' not allowed");
free(cstruc);
}
else warn_user("constraints missing");
}
/*
########################################################
# done with 'stdin' handling, now init everything properly
########################################################
*/
if((logML != 0 || dangles==1 || dangles==3) && dos == 0)
if(deltap<=0) deltap = delta/100. + 0.001;
if (deltap>0)
print_energy = deltap;
/* first lines of output (suitable for sort +1n) */
if (fname[0] != '\0')
printf("> %s [%d]\n", fname, delta);
/* stochastic backtracking */
if(n_back>0){
double mfe, kT;
char *ss;
st_back=1;
ss = (char *) space(strlen(sequence)+1);
strncpy(ss, structure, length);
mfe = fold(sequence, ss);
kT = (temperature+273.15)*1.98717/1000.; /* in Kcal */
pf_scale = exp(-(1.03*mfe)/kT/length);
strncpy(ss, structure, length);
/* ignore return value, we are not interested in the free energy */
(circular) ? (void) pf_circ_fold(sequence, ss) : (void) pf_fold(sequence, ss);
free(ss);
for (i=0; i<n_back; i++) {
char *s;
s =(circular) ? pbacktrack_circ(sequence) : pbacktrack(sequence);
printf("%s\n", s);
free(s);
}
free_pf_arrays();
}
/* normal subopt */
else if(!zuker){
(circular) ? subopt_circ(sequence, structure, delta, stdout) : subopt(sequence, structure, delta, stdout);
if (dos) {
int i;
for (i=0; i<= MAXDOS && i<=delta/10; i++) {
printf("%4d %6d\n", i, density_of_states[i]);
}
}
}
/* Zuker suboptimals */
else{
SOLUTION *zr;
int i;
if (cut_point!=-1) {
nrerror("Sorry, zuker subopts not yet implemented for cofold\n");
}
zr = zukersubopt(sequence);
putoutzuker(zr);
(void)fflush(stdout);
for (i=0; zr[i].structure; i++) {
free(zr[i].structure);
}
free(zr);
}
(void)fflush(stdout);
free(sequence);
free(structure);
} while (1);
return 0;
}
