PRIVATE double *read_concentrations(AjPFile concfile) {
/* reads concentrations, returns list of double, -1. marks end */
char *line;
double *startc;
int i=0, n=2;
FILE *fp = NULL;
fp = ajFileGetFileptr(concfile);
startc = (double *) space((2*n+1)*sizeof(double));
while ((line=get_line(fp))!=NULL) {
int c;
if (i+4>=2*n) {
n*=2;
startc=(double *)xrealloc(startc,(2*n+1)*sizeof(double));
}
c = sscanf(line,"%lf %lf", &startc[i], &startc[i+1]);
free(line);
if (c<2) break;
i+=2;
}
startc[i]=startc[i+1]=0;
return startc;
}
FILE* ajMessGetDebugfile(void)
{
if(!messDebugFile)
return NULL;
return ajFileGetFileptr(messDebugFile);
}
int main(int argc, char **argv)
{
const char *hmmfile; /* file to read HMMs from */
FILE *fp; /* output file handle */
HMMFILE *hmmfp; /* opened hmmfile for reading */
struct plan7_s *hmm; /* HMM to generate from */
int L; /* length of a sequence */
int i; /* counter over sequences */
char *ofile; /* output sequence file */
int nseq; /* number of seqs to sample */
int seed; /* random number generator seed */
int be_quiet; /* TRUE to silence header/footer */
int do_alignment; /* TRUE to output in aligned format */
int do_consensus; /* TRUE to do a single consensus seq */
AjBool ajselex;
AjBool ajcons;
AjPFile inf=NULL;
AjPFile outf=NULL;
AjPStr instr=NULL;
AjPStr outstr=NULL;
#ifdef MEMDEBUG
unsigned long histid1, histid2, orig_size, current_size;
orig_size = malloc_inuse(&histid1);
fprintf(stderr, "[... memory debugging is ON ...]\n");
#endif
/***********************************************
* Parse command line
***********************************************/
nseq = 10;
be_quiet = FALSE;
do_alignment = FALSE;
do_consensus = FALSE;
ofile = NULL;
embInitPV("ohmmemit",argc,argv,"HMMER",VERSION);
ajselex = ajAcdGetBoolean("selex");
ajcons = ajAcdGetBoolean("consensus");
nseq = ajAcdGetInt("number");
seed = ajAcdGetInt("seed");
inf = ajAcdGetInfile("infile");
outf = ajAcdGetOutfile("outfile");
if(!seed)
seed = time ((time_t *) NULL);
if(ajselex)
do_alignment=TRUE;
else
do_alignment=FALSE;
if(ajcons)
do_consensus=TRUE;
else
do_consensus=FALSE;
instr = ajStrNewC((char *)ajFileGetNameC(inf));
outstr = ajStrNewC((char *)ajFileGetNameC(outf));
hmmfile = ajStrGetPtr(instr);
sre_srandom(seed);
if (do_alignment && do_consensus)
ajFatal("Sorry, -selex and -consensus are incompatible.\n");
if (nseq != 10 && do_consensus)
ajWarn("-consensus overrides -number (# of sampled seqs)");
/***********************************************
* Open HMM file (might be in HMMERDB or current directory).
* Read a single HMM from it.
***********************************************/
if ((hmmfp = HMMFileOpen(hmmfile, "HMMERDB")) == NULL)
ajFatal("Failed to open HMM file %s\n", hmmfile);
if (!HMMFileRead(hmmfp, &hmm))
ajFatal("Failed to read any HMMs from %s\n", hmmfile);
HMMFileClose(hmmfp);
if (hmm == NULL)
ajFatal("HMM file %s corrupt or in incorrect format? Parse failed",
hmmfile);
/* Configure the HMM to shut off N,J,C emission: so we
* do a simple single pass through the model.
*/
Plan7NakedConfig(hmm);
Plan7Renormalize(hmm);
/***********************************************
* Open the output file, or stdout
***********************************************/
fp = ajFileGetFileptr(outf);
/***********************************************
* Show the options banner
***********************************************/
be_quiet=TRUE;
if (! be_quiet)
{
printf("HMM file: %s\n", hmmfile);
if (! do_consensus)
{
printf("Number of seqs: %d\n", nseq);
printf("Random seed: %d\n", seed);
}
printf("- - - - - - - - - - - - - - - - - - - - - - - - - "
"- - - - - - -\n\n");
}
/***********************************************
* Do the work.
* If we're generating an alignment, we have to collect
* all our traces, then output. If we're generating unaligned
* sequences, we can emit one at a time.
***********************************************/
if (do_consensus)
{
char *seq;
SQINFO sqinfo; /* info about sequence (name/desc) */
EmitConsensusSequence(hmm, &seq, NULL, &L, NULL);
strcpy(sqinfo.name, "consensus");
sqinfo.len = L;
sqinfo.flags = SQINFO_NAME | SQINFO_LEN;
WriteSeq(fp, kPearson, seq, &sqinfo);
free(seq);
}
else if (do_alignment)
{
struct p7trace_s **tr;
char **dsq;
SQINFO *sqinfo;
char **aseq;
AINFO ainfo;
float *wgt;
dsq = MallocOrDie(sizeof(char *) * nseq);
tr = MallocOrDie(sizeof(struct p7trace_s *) * nseq);
sqinfo = MallocOrDie(sizeof(SQINFO) * nseq);
wgt = MallocOrDie(sizeof(float) * nseq);
FSet(wgt, nseq, 1.0);
for (i = 0; i < nseq; i++)
{
EmitSequence(hmm, &(dsq[i]), &L, &(tr[i]));
sprintf(sqinfo[i].name, "seq%d", i+1);
sqinfo[i].len = L;
sqinfo[i].flags = SQINFO_NAME | SQINFO_LEN;
}
P7Traces2Alignment(dsq, sqinfo, wgt, nseq, hmm->M, tr, FALSE,
&aseq, &ainfo);
/* Output the alignment */
WriteSELEX(fp, aseq, &ainfo, 50);
if (ofile != NULL && !be_quiet)
printf("Alignment saved in file %s\n", ofile);
/* Free memory
*/
for (i = 0; i < nseq; i++)
{
P7FreeTrace(tr[i]);
free(dsq[i]);
}
FreeAlignment(aseq, &ainfo);
free(sqinfo);
free(dsq);
free(wgt);
free(tr);
}
else /* unaligned sequence output */
{
struct p7trace_s *tr;
char *dsq;
char *seq;
SQINFO sqinfo;
for (i = 0; i < nseq; i++)
{
EmitSequence(hmm, &dsq, &L, &tr);
sprintf(sqinfo.name, "seq%d", i+1);
sqinfo.len = L;
sqinfo.flags = SQINFO_NAME | SQINFO_LEN;
seq = DedigitizeSequence(dsq, L);
WriteSeq(fp, kPearson, seq, &sqinfo);
P7FreeTrace(tr);
free(dsq);
free(seq);
}
}
ajFileClose(&outf);
FreePlan7(hmm);
SqdClean();
#ifdef MEMDEBUG
current_size = malloc_inuse(&histid2);
if (current_size != orig_size)
malloc_list(2, histid1, histid2);
else
fprintf(stderr, "[No memory leaks.]\n");
#endif
ajStrDel(&instr);
ajStrDel(&outstr);
ajFileClose(&inf);
ajFileClose(&outf);
embExit();
return 0;
}
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;
}
static AjBool assemoutWriteNextBam(AjPOutfile outfile, const AjPAssem assem)
{
AjPFile outf = ajOutfileGetFile(outfile);
AjPSeqBamHeader header = NULL;
AjPAssemContig c = NULL;
AjPSeqBam bam;
AjPAssemRead r = NULL;
AjPAssemContig* contigs = NULL;
AjPAssemTag t = NULL;
AjIList j = NULL;
AjPSeqBamBgzf gzfile = NULL;
AjPStr headertext=NULL;
const AjPStr rgheadertext=NULL;
AjBool ret = ajTrue;
ajint i=0;
ajulong ncontigs=0UL;
if(!outf) return ajFalse;
if(!assem) return ajFalse;
if(!assem->Hasdata)
{
if(ajListGetLength(assem->ContigsOrder))
ncontigs = ajListToarray(assem->ContigsOrder, (void***)&contigs);
else
ncontigs = ajTableToarrayValues(assem->Contigs, (void***)&contigs);
ajFmtPrintS(&headertext, "@HD\tVN:1.3\tSO:%s\n",
ajAssemGetSortorderC(assem));
header = ajSeqBamHeaderNewN((ajuint) ncontigs);
gzfile = ajSeqBamBgzfNew(ajFileGetFileptr(outf), "w");
outfile->OutData = gzfile;
while (contigs[i]) /* contigs */
{
c = contigs[i];
if(ajStrMatchC(c->Name, "*"))
{
i++;
continue;
}
header->target_name[i] = strdup(ajStrGetPtr(c->Name));
header->target_len[i++] = c->Length;
ajFmtPrintAppS(&headertext, "@SQ\tSN:%S\tLN:%d",
c->Name, c->Length);
if(c->URI)
ajFmtPrintAppS(&headertext, "\tUR:%S", c->URI);
if(c->MD5)
ajFmtPrintAppS(&headertext, "\tM5:%S", c->MD5);
if(c->Species)
ajFmtPrintAppS(&headertext, "\tSP:%S", c->Species);
ajFmtPrintAppS(&headertext, "\n");
j = ajListIterNewread(c->Tags);
while (!ajListIterDone(j))
{
t = ajListIterGet(j);
ajFmtPrintAppS(&headertext,
"@CO\t%S %u %u %S\n", t->Name, t->x1, t->y1,
t->Comment);
}
ajListIterDel(&j);
}
rgheadertext = assemSAMGetReadgroupHeaderlines(assem);
if(rgheadertext)
ajStrAppendS(&headertext, rgheadertext);
ajSeqBamHeaderSetTextC(header, ajStrGetPtr(headertext));
ajSeqBamHeaderWrite(gzfile, header);
ajSeqBamHeaderDel(&header);
ajStrDel(&headertext);
AJFREE(contigs);
if(!assem->BamHeader)
return ajTrue;
}
/* data */
gzfile = outfile->OutData;
AJNEW0(bam);
bam->m_data=10;
AJCNEW0(bam->data, bam->m_data);
j = ajListIterNewread(assem->Reads);
while (!ajListIterDone(j)) /* reads */
{
r = ajListIterGet(j);
assemoutWriteBamAlignment(gzfile, r, bam);
}
ajListIterDel(&j);
AJFREE(bam->data);
AJFREE(bam);
/* ajSeqBamBgzfClose(gzfile);*/
return ret;
}
int main(int argc, char *argv[])
{
char *string;
char *structure=NULL;
char *cstruc=NULL;
char *ns_bases=NULL;
char *c;
int n_seq;
int i;
int length;
int sym;
int endgaps = 0;
int mis = 0;
double min_en;
double real_en;
double sfact = 1.07;
int pf = 0;
int istty;
char *AS[MAX_NUM_NAMES]; /* aligned sequences */
char *names[MAX_NUM_NAMES]; /* sequence names */
AjPSeqset seq = NULL;
AjPFile confile = NULL;
AjPFile alifile = NULL;
AjPFile paramfile = NULL;
AjPFile outf = NULL;
AjPFile essfile = NULL;
AjPFile dotfile = NULL;
AjPStr constring = NULL;
float eT = 0.;
AjBool eGU;
AjBool eclose;
AjBool lonely;
AjPStr ensbases = NULL;
AjBool etloop;
AjPStr eenergy = NULL;
char ewt = '\0';
float escale = 0.;
AjPStr edangles = NULL;
char edangle = '\0';
ajint len;
AjPSeq tseq = NULL;
AjPStr tname = NULL;
int circ = 0;
int doAlnPS = 0;
int doColor = 0;
embInitPV("vrnaalifoldpf",argc,argv,"VIENNA",VERSION);
constring = ajStrNew();
seq = ajAcdGetSeqset("sequence");
confile = ajAcdGetInfile("constraintfile");
paramfile = ajAcdGetInfile("paramfile");
eT = ajAcdGetFloat("temperature");
eGU = ajAcdGetBoolean("gu");
eclose = ajAcdGetBoolean("closegu");
lonely = ajAcdGetBoolean("lp");
ensbases = ajAcdGetString("nsbases");
etloop = ajAcdGetBoolean("tetraloop");
eenergy = ajAcdGetListSingle("energy");
escale = ajAcdGetFloat("scale");
edangles = ajAcdGetListSingle("dangles");
mis = !!ajAcdGetBoolean("most");
endgaps = !!ajAcdGetBoolean("endgaps");
nc_fact = (double) ajAcdGetFloat("nspenalty");
cv_fact = (double) ajAcdGetFloat("covariance");
outf = ajAcdGetOutfile("outfile");
essfile = ajAcdGetOutfile("ssoutfile");
alifile = ajAcdGetOutfile("alignoutfile");
circ = !!ajAcdGetBoolean("circular");
doColor = !!ajAcdGetBoolean("colour");
dotfile = ajAcdGetOutfile("dotoutfile");
do_backtrack = 1;
pf = 1;
string = NULL;
istty = 0;
dangles = 2;
temperature = (double) eT;
noGU = (eGU) ? 0 : 1;
no_closingGU = (eclose) ? 0 : 1;
noLonelyPairs = (lonely) ? 0 : 1;
ns_bases = (ajStrGetLen(ensbases)) ? MAJSTRGETPTR(ensbases) : NULL;
tetra_loop = !!etloop;
ewt = *ajStrGetPtr(eenergy);
if(ewt == '0')
energy_set = 0;
else if(ewt == '1')
energy_set = 1;
else if(ewt == '2')
energy_set = 2;
sfact = (double) escale;
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!='\0')
{
if (*c!=',')
{
nonstandards[i++]=*c++;
nonstandards[i++]=*c;
if ((sym)&&(*c!=*(c-1)))
{
nonstandards[i++]=*c;
nonstandards[i++]=*(c-1);
}
}
c++;
}
}
if(alifile)
doAlnPS = 1;
if(confile)
vienna_GetConstraints(confile,&constring);
n_seq = ajSeqsetGetSize(seq);
if(n_seq > MAX_NUM_NAMES - 1)
ajFatal("[e]RNAalifold is restricted to %d sequences\n",
MAX_NUM_NAMES - 1);
if (n_seq==0)
ajFatal("No sequences found");
for(i=0;i<n_seq;++i)
{
tseq = (AjPSeq) ajSeqsetGetseqSeq(seq,i);
ajSeqGapStandard(tseq, '-');
tname = (AjPStr) ajSeqsetGetseqNameS(seq,i);
len = ajSeqGetLen(tseq);
AS[i] = (char *) space(len+1);
names[i] = (char *) space(ajStrGetLen(tname)+1);
strcpy(AS[i],ajSeqGetSeqC(tseq));
strcpy(names[i],ajStrGetPtr(tname));
}
AS[n_seq] = NULL;
names[n_seq] = NULL;
if (endgaps)
for (i=0; i<n_seq; i++)
mark_endgaps(AS[i], '~');
length = (int) strlen(AS[0]);
structure = (char *) space((unsigned) length+1);
if(confile)
{
fold_constrained = 1;
strcpy(structure,ajStrGetPtr(constring));
}
if (circ && noLonelyPairs)
ajWarn(
"warning, depending on the origin of the circular sequence, "
"some structures may be missed when using -noLP\n"
"Try rotating your sequence a few times\n");
if (circ)
min_en = circalifold((const char **)AS, structure);
else
min_en = alifold(AS, structure);
{
int i;
double s=0;
extern int eos_debug;
eos_debug=-1; /* shut off warnings about nonstandard pairs */
for (i=0; AS[i]!=NULL; i++)
if (circ)
s += energy_of_circ_struct(AS[i], structure);
else
s += energy_of_struct(AS[i], structure);
real_en = s/i;
}
string = (mis) ?
consens_mis((const char **) AS) : consensus((const char **) AS);
ajFmtPrintF(outf,"%s\n%s", string, structure);
ajFmtPrintF(outf," (%6.2f = %6.2f + %6.2f) \n", min_en, real_en,
min_en-real_en );
if (length<=2500) {
char **A;
A = annote(structure, (const char**) AS);
if (doColor)
(void) PS_rna_plot_a(string, structure, essfile, A[0], A[1]);
else
(void) PS_rna_plot_a(string, structure, essfile, NULL, A[1]);
free(A[0]); free(A[1]);free(A);
} else
ajWarn("INFO: structure too long, not doing xy_plot\n");
if (doAlnPS)
PS_color_aln(structure, alifile, AS, names);
{ /* free mfe arrays but preserve base_pair for PS_dot_plot */
struct bond *bp;
bp = base_pair; base_pair = space(16);
free_alifold_arrays(); /* free's base_pair */
free_alipf_arrays();
base_pair = bp;
}
if (pf) {
double energy, kT;
pair_info *pi;
char * mfe_struc;
mfe_struc = strdup(structure);
kT = (temperature+273.15)*1.98717/1000.; /* in Kcal */
pf_scale = exp(-(sfact*min_en)/kT/length);
if (length>2000)
ajWarn("scaling factor %f\n", pf_scale);
/* init_alipf_fold(length); */
if (confile)
strncpy(structure, ajStrGetPtr(constring), length+1);
energy = (circ) ? alipf_circ_fold(AS, structure, &pi) : alipf_fold(AS, structure, &pi);
if (do_backtrack) {
ajFmtPrintF(outf,"%s", structure);
ajFmtPrintF(outf," [%6.2f]\n", energy);
}
if ((istty)||(!do_backtrack))
ajFmtPrintF(outf," free energy of ensemble = %6.2f kcal/mol\n", energy);
ajFmtPrintF(outf," frequency of mfe structure in ensemble %g\n",
exp((energy-min_en)/kT));
if (do_backtrack) {
FILE *aliout;
cpair *cp;
short *ptable; int k;
ptable = make_pair_table(mfe_struc);
ajFmtPrintF(outf,"\n# Alignment section\n\n");
aliout = ajFileGetFileptr(outf);
fprintf(aliout, "%d sequences; length of alignment %d\n",
n_seq, length);
fprintf(aliout, "alifold output\n");
for (k=0; pi[k].i>0; k++) {
pi[k].comp = (ptable[pi[k].i] == pi[k].j) ? 1:0;
print_pi(pi[k], aliout);
}
fprintf(aliout, "%s\n", structure);
free(ptable);
cp = make_color_pinfo(pi);
(void) PS_color_dot_plot(string, cp, dotfile);
free(cp);
free(mfe_struc);
free(pi);
}
}
if (cstruc!=NULL) free(cstruc);
free(base_pair);
(void) fflush(stdout);
free(string);
free(structure);
for (i=0; AS[i]; i++) {
free(AS[i]); free(names[i]);
}
ajSeqsetDel(&seq);
ajStrDel(&constring);
ajStrDel(&eenergy);
ajStrDel(&edangles);
ajStrDel(&ensbases);
ajFileClose(&confile);
ajFileClose(¶mfile);
ajFileClose(&outf);
ajFileClose(&essfile);
ajFileClose(&alifile);
ajFileClose(&dotfile);
embExit();
return 0;
}
int main(int argc, char *argv[])
{
char *start;
char *structure;
char *rstart;
char *str2;
char *line;
int i;
int length;
int l;
int hd;
double energy = 0.;
double kT;
int pf = 0;
int mfe = 0;
int istty;
int repeat;
int found;
AjPFile inf = NULL;
AjPSeq seq = NULL;
AjPFile paramfile = NULL;
AjPFile outf = NULL;
float eT = 0.;
AjBool eGU;
AjBool eclose;
AjBool lonely;
AjBool etloop;
AjPStr eenergy = NULL;
char ewt = '\0';
AjPStr edangles = NULL;
AjPStr method = NULL;
AjPStr ealpha = NULL;
AjBool showfails = ajFalse;
AjBool succeed = ajFalse;
char edangle = '\0';
ajint len;
FILE *fp;
embInitPV("vrnainverse",argc,argv,"VIENNA",VERSION);
inf = ajAcdGetInfile("structuresfile");
seq = ajAcdGetSeq("sequence");
paramfile = ajAcdGetInfile("paramfile");
eT = ajAcdGetFloat("temperature");
eGU = ajAcdGetBoolean("gu");
eclose = ajAcdGetBoolean("closegu");
lonely = ajAcdGetBoolean("lp");
etloop = ajAcdGetBoolean("tetraloop");
eenergy = ajAcdGetListSingle("energy");
edangles = ajAcdGetListSingle("dangles");
method = ajAcdGetListSingle("folding");
ealpha = ajAcdGetString("alphabet");
final_cost = ajAcdGetFloat("final");
repeat = ajAcdGetInt("repeats");
showfails = ajAcdGetBoolean("showfails");
succeed = ajAcdGetBoolean("succeed");
outf = ajAcdGetOutfile("outfile");
do_backtrack = 0;
structure = NULL;
istty = 0;
temperature = (double) eT;
noGU = (eGU) ? 0 : 1;
no_closingGU = (eclose) ? 0 : 1;
noLonelyPairs = (lonely) ? 0 : 1;
tetra_loop = !!etloop;
ewt = *ajStrGetPtr(eenergy);
if(ewt == '0')
energy_set = 0;
else if(ewt == '1')
energy_set = 1;
else if(ewt == '2')
energy_set = 2;
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(ajStrMatchC(method,"mp"))
{
mfe = 1;
pf = 1;
}
else if(ajStrMatchC(method,"m"))
{
mfe = 1;
pf = 0;
}
else if(ajStrMatchC(method,"p"))
{
mfe = 0;
pf = 1;
}
len = ajStrGetLen(ealpha);
symbolset = (char *) space(len + 1);
strcpy(symbolset, ajStrGetPtr(ealpha));
for (l = 0; l < len; l++)
symbolset[l] = toupper(symbolset[l]);
inv_verbose = !!showfails;
fp = ajFileGetFileptr(inf);
init_rand();
kT = (temperature+273.15)*1.98717/1000.0;
istty = (isatty(fileno(stdout))&&isatty(fileno(stdin)));
if (paramfile)
read_parameter_file(paramfile);
give_up = succeed;
do {
if ((line = get_line(fp))==NULL) break;
/* read structure, skipping over comment lines */
while ((*line=='*')||(*line=='\0')||(*line=='>'))
{
free(line);
if ((line = get_line(fp))==NULL)
break;
}
/* stop at eof or '@' */
if (line==NULL) break;
if (strcmp(line, "@") == 0)
{
free(line);
break;
}
structure = (char *) space(strlen(line)+1);
/* scanf gets rid of trailing junk */
(void) sscanf(line,"%s",structure);
free(line);
length = (int) strlen(structure);
str2 = (char *) space((unsigned)length+1);
/* now look for a sequence to match the structure */
/*
if ((line = get_line(fp))!=NULL)
if (strcmp(line, "@") == 0)
{
free(line);
break;
}
*/
start = (char *) space((unsigned) length+1);
if(seq)
(void) strncpy(start, ajSeqGetSeqC(seq), length);
if (repeat!=0)
found = repeat;
else
found = 1;
initialize_fold(length);
rstart = (char *) space((unsigned)length+1);
while(found>0)
{
char *string;
string = (char *) space((unsigned)length+1);
strcpy(string, start);
for (i=0; i<length; i++)
{
/* lower case characters are kept fixed, any other character
not in symbolset is replaced by a random character */
if (islower(string[i]))
continue;
if (string[i]=='\0' || (strchr(symbolset,string[i])==NULL))
string[i]=symbolset[int_urn(0,strlen(symbolset)-1)];
}
strcpy(rstart, string); /* remember start string */
if (mfe)
{
energy = inverse_fold(string, structure);
if( (!succeed) || (energy<=0.0) ) {
found--;
hd = hamming(rstart, string);
ajFmtPrintF(outf,"%s %3d", string, hd);
if (energy>0)
{ /* no solution found */
ajFmtPrintF(outf," d = %f\n", energy);
}
else
ajFmtPrintF(outf,"\n");
}
}
if (pf)
{
if (!(mfe && give_up && (energy>0)))
{
/* unless we gave up in the mfe part */
double prob, min_en, sfact=1.07;
/* get a reasonable pf_scale */
min_en = fold(string,str2);
pf_scale = exp(-(sfact*min_en)/kT/length);
init_pf_fold(length);
energy = inverse_pf_fold(string, structure);
prob = exp(-energy/kT);
hd = hamming(rstart, string);
ajFmtPrintF(outf,"%s %3d (%f)\n", string, hd, prob);
free_pf_arrays();
}
if (!mfe)
found--;
}
free(string);
}
free(rstart);
free_arrays();
free(structure);
free(str2);
free(start);
} while (1);
ajSeqDel(&seq);
ajStrDel(&eenergy);
ajStrDel(&edangles);
ajStrDel(&method);
ajStrDel(&ealpha);
ajFileClose(&inf);
ajFileClose(¶mfile);
ajFileClose(&outf);
AJFREE(symbolset);
embExit();
return 0;
}
