AjBool ajReadlinePos(AjPFile file, AjPStr* Pdest, ajlong* Ppos)
{
const char *cp;
char *buff;
ajint isize;
ajint ilen;
ajint jlen;
ajint ipos;
ajuint buffsize;
size_t iread;
const char* pnewline = NULL;
MAJSTRDEL(Pdest);
if(file->Buffsize)
buffsize = file->Buffsize;
else
buffsize = ajFileValueBuffsize();
if(!file->Buff)
ajStrAssignResC(&file->Buff, buffsize, "");
else if(buffsize > MAJSTRGETRES(file->Buff))
ajStrSetRes(&file->Buff, buffsize);
if(MAJSTRGETUSE(file->Buff) == 1)
buff = MAJSTRGETPTR(file->Buff);
else
buff = ajStrGetuniquePtr(&file->Buff);
isize = MAJSTRGETRES(file->Buff);
ilen = 0;
ipos = 0;
if(!file->fp)
ajWarn("ajFileGets file not found");
*Ppos = file->Filepos;
while(buff)
{
if(file->End)
{
ajStrAssignClear(Pdest);
ajDebug("at EOF: File already read to end %F\n", file);
return ajFalse;
}
#ifndef __ppc__
if(file->Readblock)
{
if(file->Blockpos >= file->Blocklen)
{
iread = fread(file->Readblock,
1, file->Blocksize,
file->fp);
if(!iread && ferror(file->fp))
ajFatal("fread failed with error:%d '%s'",
ferror(file->fp), strerror(ferror(file->fp)));
file->Blockpos = 0;
file->Blocklen = iread;
file->Readblock[iread] = '\0';
/*ajDebug("++ fread %u Ppos:%Ld\n", iread, *Ppos);*/
}
if(file->Blockpos < file->Blocklen)
{
/* we know we have something in Readblock to process */
pnewline = strchr(&file->Readblock[file->Blockpos], '\n');
if(pnewline)
jlen = pnewline - &file->Readblock[file->Blockpos] + 1;
else
jlen = file->Blocklen - file->Blockpos;
/*ajDebug("ipos:%d jlen:%d pnewline:%p "
"Readblock:%p blockpos:%d blocklen:%d\n",
ipos, jlen, pnewline, file->Readblock,
file->Blockpos, file->Blocklen);*/
memmove(&buff[ipos], &file->Readblock[file->Blockpos], jlen);
buff[ipos+jlen]='\0';
cp = &buff[ipos];
file->Blockpos += jlen;
}
else
{
jlen = 0;
cp = NULL;
}
}
else
{
cp = fgets(&buff[ipos], isize, file->fp);
jlen = strlen(&buff[ipos]);
}
#else
cp = ajSysFuncFgets(&buff[ipos], isize, file->fp);
jlen = strlen(&buff[ipos]);
#endif
if(!cp && !ipos)
{
if(feof(file->fp))
{
file->End = ajTrue;
ajStrAssignClear(Pdest);
ajDebug("EOF ajFileGetsL file %F\n", file);
return ajFalse;
}
else
ajFatal("Error reading from file '%S'\n", ajFileGetNameS(file));
}
ilen += jlen;
file->Filepos += jlen;
/*
** We need to read again if:
** We have read the entire buffer
** and we don't have a newline at the end
** (must be careful about that - we may just have read enough)
*/
if(((file->Readblock && !pnewline) ||(jlen == (isize-1))) &&
(buff[ilen-1] != '\n'))
{
MAJSTRSETVALIDLEN(&file->Buff, ilen); /* fix before resizing! */
ajStrSetResRound(&file->Buff, ilen+buffsize+1);
/*ajDebug("more to do: jlen: %d ipos: %d isize: %d ilen: %d "
"Size: %d\n",
jlen, ipos, isize, ilen, ajStrGetRes(file->Buff));*/
ipos += jlen;
buff = ajStrGetuniquePtr(&file->Buff);
isize = ajStrGetRes(file->Buff) - ipos;
/*ajDebug("expand to: ipos: %d isize: %d Size: %d\n",
ipos, isize, ajStrGetRes(file>Buff));*/
}
else
buff = NULL;
}
MAJSTRSETVALIDLEN(&file->Buff, ilen);
if (ajStrGetCharLast(file->Buff) != '\n')
{
/*ajDebug("Appending missing newline to '%S'\n", file->Buff);*/
ajStrAppendK(&file->Buff, '\n');
}
ajStrAssignRef(Pdest, file->Buff);
/*
if(file->Readblock)
ajDebug("ajFileGetsL done blocklen:%d blockpos:%d readlen:%u\n",
file->Blocklen, file->Blockpos, ajStrGetLen(file->Buff));
*/
return ajTrue;
}
AjBool ajBuffreadLinePos(AjPFilebuff buff, AjPStr* Pdest, ajlong* Ppos)
{
AjBool ok;
/* read from the buffer if it is not empty */
*Ppos = 0;
if(buff->Pos < buff->Size)
{
ajStrAssignS(Pdest, buff->Curr->Line);
*Ppos = buff->Curr->Fpos;
buff->Prev = buff->Curr;
buff->Curr = buff->Curr->Next;
buff->Pos++;
return ajTrue;
}
/* file has been closed */
if(!buff->File->Handle)
return ajFalse;
/* buffer used up - try reading from the file */
ok = ajReadlinePos(buff->File, Pdest, &buff->Fpos);
if(!ok)
{
if(buff->File->End)
{
if(buff->Size)
{
/* we have data in the buffer - fail */
ajDebug("End of file - data in buffer - return ajFalse\n");
return ajFalse;
}
else
{
/* buffer clear - try another file */
if(ajFileReopenNext(buff->File))
{
/* OK - read the new file */
ok = ajBuffreadLinePos(buff, Pdest, Ppos);
ajDebug("End of file - trying next file ok: %B "
"fpos: %Ld %Ld\n",
ok, *Ppos, buff->Fpos);
return ok;
}
else
{
/* no new file, fail again */
ajDebug("End of file - no new file to read - "
"return ajFalse\n");
return ajFalse;
}
}
}
else
ajFatal("Error reading from file '%S'\n",
ajFileGetNameS(buff->File));
}
if(buff->Nobuff)
{
*Ppos = buff->Fpos;
/*ajDebug("ajBuffreadLinePos unbuffered fpos: %Ld\n", *Ppos);*/
return ajTrue;
}
filebuffLineAdd(buff, *Pdest);
*Ppos = buff->Fpos;
return ajTrue;
}
int main(int argc, char **argv)
{
AjPSeqset seqset = NULL;
AjPStr cl = NULL;
AjPSeqout seqout = NULL;
float cutoff = 0.;
AjBool best = ajFalse;
AjBool gff = ajFalse;
AjBool two = ajFalse;
AjBool kinase = ajFalse;
AjPStr rsd = NULL;
AjBool addseq = ajFalse;
AjBool plot = ajFalse;
const AjPStr ofn = NULL;
AjPStr fn = NULL;
AjPStr stmp = NULL;
AjPFile outf = NULL;
embInitPV("enetphos", argc, argv, "CBSTOOLS", VERSION);
seqset = ajAcdGetSeqset("sequence");
outf = ajAcdGetOutfile("outfile");
plot = ajAcdGetBoolean("plot");
best = ajAcdGetBoolean("best");
gff = ajAcdGetBoolean("gff");
two = ajAcdGetBoolean("two");
kinase = ajAcdGetBoolean("kinase");
addseq = ajAcdGetBoolean("addseq");
cutoff = ajAcdGetFloat("cutoff");
rsd = ajAcdGetListSingle("residue");
cl = ajStrNewC("netphos ");
fn = ajStrNew();
stmp = ajStrNew();
ajFilenameSetTempname(&fn);
seqout = ajSeqoutNew();
if(!ajSeqoutOpenFilename(seqout, fn))
ajFatal("Cannot open temporary file %S",fn);
ajSeqoutSetFormatC(seqout, "fasta");
ajSeqoutWriteSet(seqout,seqset);
ajSeqoutClose(seqout);
if(ajStrMatchC(rsd,"serine"))
ajStrAppendC(&cl," -s");
else if(ajStrMatchC(rsd,"threonine"))
ajStrAppendC(&cl," -t");
else if(ajStrMatchC(rsd,"tyrosine"))
ajStrAppendC(&cl," -y");
if(plot)
ajStrAppendC(&cl," -g");
if(two)
ajStrAppendC(&cl," -2");
if(best)
ajStrAppendC(&cl," -b");
if(gff)
ajStrAppendC(&cl," -f gff");
if(kinase)
ajStrAppendC(&cl," -k");
if(addseq)
ajStrAppendC(&cl," -S");
ajFmtPrintS(&stmp," -c %f",cutoff);
ajStrAppendS(&cl,stmp);
ajFmtPrintS(&stmp," %S",fn);
ajStrAppendS(&cl,stmp);
ofn = ajFileGetNameS(outf);
ajFmtPrintS(&stmp," > %S",ofn);
ajStrAppendS(&cl,stmp);
ajFileClose(&outf);
#if 0
ajFmtPrint("%S\n",cl);
#endif
#if 1
if(system(ajStrGetPtr(cl)) == -1)
ajFatal("Command %S failed",cl);
#endif
ajSysFileUnlink(fn);
ajStrDel(&cl);
ajStrDel(&fn);
ajStrDel(&stmp);
ajStrDel(&rsd);
ajSeqoutDel(&seqout);
ajSeqsetDel(&seqset);
embExit();
return 0;
}
int main(int argc, char **argv)
{
/* ACD data item variables */
AjPFile oldhmmfile = NULL;
AjPStr format = NULL;
AjPFile newhmmfile = NULL;
/* Housekeeping variables */
AjPStr cmd = NULL;
char option;
/* ACD file processing */
embInitPV("ehmmconvert",argc,argv,"HMMERNEW",VERSION);
oldhmmfile = ajAcdGetInfile("oldhmmfile");
format = ajAcdGetListSingle("format");
newhmmfile = ajAcdGetOutfile("newhmmfile");
/* MAIN APPLICATION CODE */
cmd = ajStrNew();
/* 1. Build hmmconvert command line */
/* Command line is built in this order:
i. Application name.
ii. HMMER 'options' (in order they appear in ACD file)
iii.HMMER 'options' (that don't appear in ACD file)
iv. HMMER & new parameters.
*/
ajStrAssignS(&cmd, ajAcdGetpathC("hmmconvert"));
/* ACD option only allows one selection */
option = ajStrGetCharFirst(format);
if(option == 'A')
ajStrAppendC(&cmd, " -a ");
else if(option == 'B')
ajStrAppendC(&cmd, " -b ");
else if(option == 'G')
ajStrAppendC(&cmd, " -p ");
else if(option == 'X')
ajStrAppendC(&cmd, " -P ");
/* -A (append) always set but file will be wiped by EMBOSS first unless
append: "Y" is set for "newhmmfile" in the ACD file. */
/* hmmer cannot append to empty file, so only set the -A (append) option
if file was opened for appending to (and therefore was not wiped by
EMBOSS) and is not zero size. */
if(ajFileIsAppend(newhmmfile) && (ajFilenameGetSize(ajFileGetNameS(newhmmfile))!=-1))
ajStrAppendC(&cmd, " -A ");
ajStrAppendC(&cmd, " -F ");
ajFmtPrintAppS(&cmd, " %s %s", ajFileGetNameC(oldhmmfile), ajFileGetNameC(newhmmfile));
/* 2. Close ACD files. */
ajFileClose(&oldhmmfile);
ajFileClose(&newhmmfile);
/* 3. Call hmmconvert */
ajFmtPrint("\n%S\n\n", cmd);
ajSysExecS(cmd);
/* 4. Exit cleanly */
ajStrDel(&cmd);
ajStrDel(&format);
embExit();
return 0;
}
int main(int argc, char **argv)
{
/* ACD data item variables */
AjPSeqset dataset = NULL;
AjPFile bfile = NULL;
AjPFile plib = NULL;
AjPStr mod = NULL;
ajint nmotifs = 0;
AjBool text = ajFalse;
AjPStr prior = NULL;
float evt = 0.0;
ajint nsites = 0;
ajint minsites = 0;
ajint maxsites = 0;
float wnsites = 0.0;
ajint w = 0;
ajint minw = 0;
ajint maxw = 0;
AjBool nomatrim = ajFalse;
ajint wg = 0;
ajint ws = 0;
AjBool noendgaps = ajFalse;
AjBool revcomp = ajFalse;
AjBool pal = ajFalse;
AjBool nostatus = ajFalse;
ajint maxiter = 0;
float distance = 0.0;
float b = 0.0;
float spfuzz = 0.0;
AjPStr spmap = NULL;
AjPStr cons = NULL;
ajint maxsize = 0;
ajint p = 0;
ajint time = 0;
AjPStr sf = NULL;
ajint heapsize = 64;
AjBool xbranch = ajFalse;
AjBool wbranch = ajFalse;
ajint bfactor = 0;
AjPFile outtext = NULL;
/* Housekeeping variables */
AjPStr cmd = NULL;
AjPStr ssname = NULL;
AjPSeqout outseq = NULL;
AjPStr tmp = NULL;
char option;
/* ACD file processing */
embInitPV("ememetext",argc,argv,"MEME",VERSION);
dataset = ajAcdGetSeqset("dataset");
bfile = ajAcdGetInfile("bfile");
plib = ajAcdGetInfile("plibfile");
mod = ajAcdGetSelectSingle("mod");
nmotifs = ajAcdGetInt("nmotifs");
text = ajAcdGetBoolean("text");
prior = ajAcdGetSelectSingle("prior");
evt = ajAcdGetFloat("evt");
nsites = ajAcdGetInt("nsites");
minsites = ajAcdGetInt("minsites");
maxsites = ajAcdGetInt("maxsites");
wnsites = ajAcdGetFloat("wnsites");
w = ajAcdGetInt("w");
minw = ajAcdGetInt("minw");
maxw = ajAcdGetInt("maxw");
nomatrim = ajAcdGetBoolean("nomatrim");
wg = ajAcdGetInt("wg");
ws = ajAcdGetInt("ws");
noendgaps = ajAcdGetBoolean("noendgaps");
revcomp = ajAcdGetBoolean("revcomp");
pal = ajAcdGetBoolean("pal");
nostatus = ajAcdGetBoolean("nostatus");
maxiter = ajAcdGetInt("maxiter");
distance = ajAcdGetFloat("distance");
b = ajAcdGetFloat("b");
spfuzz = ajAcdGetFloat("spfuzz");
spmap = ajAcdGetSelectSingle("spmap");
cons = ajAcdGetString("cons");
maxsize = ajAcdGetInt("maxsize");
p = ajAcdGetInt("p");
time = ajAcdGetInt("time");
sf = ajAcdGetString("sf");
heapsize = ajAcdGetInt("heapsize");
xbranch = ajAcdGetBoolean("xbranch");
wbranch = ajAcdGetBoolean("wbranch");
bfactor = ajAcdGetInt("bfactor");
outtext = ajAcdGetOutfile("outtext");
outseq = ajAcdGetSeqoutset("outseq");
/* MAIN APPLICATION CODE */
/* 1. Housekeeping */
cmd = ajStrNew();
tmp = ajStrNew();
/* 2. Re-write dataset to a temporary file in a format (fasta) MEME
** can understand.
** Can't just pass the name of dataset to MEME as the name provided
** might be a USA which MEME would not understand.
*/
ssname = ajStrNewS(ajFileGetNameS(outseq->File));
ajSeqoutSetFormatC(outseq, "fasta");
ajSeqoutWriteSet(outseq, dataset);
ajSeqoutClose(outseq);
ajSeqoutDel(&outseq);
/* 3. Build ememe command line */
/* Command line is built in this order:
i. Application name.
ii. Original MEME options (in order they appear in ACD file)
iii.Original MEME options (that don't appear in ACD file)
iv. EMBASSY MEME new qualifiers and parameters.
*/
ajStrAssignS(&cmd, ajAcdGetpathC("meme"));
ajFmtPrintAppS(&cmd, " %S", ssname);
if(bfile)
ajFmtPrintAppS(&cmd, " -bfile %s ", ajFileGetNameC(bfile));
if(plib)
ajFmtPrintAppS(&cmd, " -plib %s ", ajFileGetNameC(plib));
option = ajStrGetCharFirst(mod);
if(option == 'o')
ajStrAppendC(&cmd, " -mod oops ");
else if(option == 'z')
ajStrAppendC(&cmd, " -mod zoops ");
else if(option == 'a')
ajStrAppendC(&cmd, " -mod anr ");
if(nmotifs != 1)
ajFmtPrintAppS(&cmd, " -nmotifs %d ", nmotifs);
if(text)
ajFmtPrintAppS(&cmd, " -text ");
ajFmtPrintAppS(&cmd, " -prior %S ", prior);
if(evt != -1)
ajFmtPrintAppS(&cmd, " -evt %f ", evt);
if(nsites != -1)
ajFmtPrintAppS(&cmd, " -nsites %d ", nsites);
else
{
if(minsites != -1)
ajFmtPrintAppS(&cmd, " -minsites %d ", minsites);
if(maxsites != -1)
ajFmtPrintAppS(&cmd, " -maxsites %d ", maxsites);
}
if(wnsites < 0.7999 || wnsites > .8001)
ajFmtPrintAppS(&cmd, " -wnsites %f ", wnsites);
if(w != -1)
ajFmtPrintAppS(&cmd, " -w %d ", w);
if(minw != 8)
ajFmtPrintAppS(&cmd, " -minw %d ", minw);
if(maxw != 50)
ajFmtPrintAppS(&cmd, " -maxw %d ", maxw);
if(nomatrim)
ajFmtPrintAppS(&cmd, " -nomatrim ");
if(wg != 11)
ajFmtPrintAppS(&cmd, " -wg %d ", wg);
if(ws != 1)
ajFmtPrintAppS(&cmd, " -ws %d ", ws);
if(noendgaps)
ajFmtPrintAppS(&cmd, " -noendgaps ");
if(revcomp)
ajFmtPrintAppS(&cmd, " -revcomp ");
if(pal && ajSeqsetIsNuc(dataset))
ajFmtPrintAppS(&cmd, " -pal ");
if(nostatus)
ajFmtPrintAppS(&cmd, " -nostatus ");
if(maxiter != 50)
ajFmtPrintAppS(&cmd, " -maxiter %d ", maxiter);
if(distance < 0.00099 || distance > 0.00101)
ajFmtPrintAppS(&cmd, " -distance %f ", distance);
if(b != -1)
ajFmtPrintAppS(&cmd, " -b %f ", b);
if(spfuzz != -1)
ajFmtPrintAppS(&cmd, " -spfuzz %f ", spfuzz);
if(!ajStrMatchC(spmap,"default"))
ajFmtPrintAppS(&cmd, " -spmap %S ", spmap);
if(MAJSTRGETLEN(cons))
ajFmtPrintAppS(&cmd, "-cons %S", cons);
if(maxsize != -1)
ajFmtPrintAppS(&cmd, " -maxsize %d ", maxsize);
if(p > 0)
ajFmtPrintAppS(&cmd, " -p %d ", p);
if(time > 0)
ajFmtPrintAppS(&cmd, " -time %d ", time);
if(MAJSTRGETLEN(sf))
ajFmtPrintAppS(&cmd, " -sf %S", sf);
if(heapsize != 64)
ajFmtPrintAppS(&cmd, " -heapsize %d ", heapsize);
if(xbranch)
ajFmtPrintAppS(&cmd, " -x_branch");
if(wbranch)
ajFmtPrintAppS(&cmd, " -w_branch");
if(bfactor != 3)
ajFmtPrintAppS(&cmd, " -bfactor %d ", bfactor);
if(ajSeqsetIsProt(dataset))
ajFmtPrintAppS(&cmd, "-protein ");
else
ajFmtPrintAppS(&cmd, "-dna ");
ajFmtPrintAppS(&cmd, " -text");
ajFmtPrintAppS(&cmd, " > %S ", ajFileGetNameS(outtext));
/* 4. Close files from ACD before calling meme */
ajFileClose(&bfile);
ajFileClose(&plib);
/* 5. Call meme */
/* ajFmtPrint("\n%S\n", cmd); */
system(ajStrGetPtr(cmd));
/* 6. Exit cleanly */
ajSeqsetDel(&dataset);
ajStrDel(&cons);
ajStrDel(&sf);
ajStrDel(&mod);
ajStrDel(&prior);
ajStrDel(&spmap);
ajStrDel(&cmd);
ajStrDel(&ssname);
ajStrDel(&tmp);
ajFileClose(&bfile);
ajFileClose(&plib);
ajFileClose(&outtext);
ajSeqoutDel(&outseq);
embExit();
return 0;
}
int main(int argc, char** argv)
{
AjPFile outf = NULL;
AjPFile cachef = NULL;
AjIList iterator = NULL;
AjPList aliases = NULL;
AjPList dbas = NULL;
AjPList species = NULL;
AjPStr alias = NULL;
AjPStr dbname = NULL;
AjPStr spname = NULL;
AjPStr svrname = NULL;
AjPStr svrurl = NULL;
AjPStr dbcurl = NULL;
AjPTime svrtime = NULL;
EnsEDatabaseadaptorGroup dbag = ensEDatabaseadaptorGroupNULL;
EnsPDatabaseadaptor dba = NULL;
EnsPDatabaseconnection dbc = NULL;
embInit("cacheensembl", argc, argv);
ensInit();
svrname = ajAcdGetString("servername");
outf = ajAcdGetOutfile("outfile");
cachef = ajAcdGetOutfile("cachefile");
dbcurl = ajStrNew();
svrurl = ajStrNew();
dbname = ajStrNew();
ajNamSvrGetUrl(svrname, &svrurl);
if(!svrurl)
ajFatal("Could not resolve server name '%S'.", svrname);
dbc = ensDatabaseconnectionNewUrl(svrurl);
ensRegistryLoadDatabaseconnection(dbc);
ensDatabaseconnectionDel(&dbc);
/* Write the server file header. */
svrtime = ajTimeNewTodayFmt("cachefile");
ajFmtPrintF(cachef, "# %S %D\n", ajFileGetNameS(cachef), svrtime);
ajTimeDel(&svrtime);
ajFmtPrintF(cachef,
"# Automatically generated by cacheensembl "
"for server '%S'.\n\n",
svrname);
/*
** Get all Ensembl Database Adaptor objects and write them as
** EMBOSS Database definitions.
*/
aliases = ajListstrNew();
dbas = ajListNew();
species = ajListstrNew();
ensRegistryRetrieveAllSpecies(species);
while(ajListstrPop(species, &spname))
{
ensRegistryGetAllDatabaseadaptors(ensEDatabaseadaptorGroupNULL,
spname,
dbas);
while(ajListPop(dbas, (void**) &dba))
{
dbag = ensDatabaseadaptorGetGroup(dba);
if(dbag == ensEDatabaseadaptorGroupNULL)
{
ajDebug("cacheensembl main got unexpected "
"Ensembl Database Adaptor Group %d.\n",
dbag);
continue;
}
ajStrAssignS(&dbname, ensDatabaseadaptorGetSpecies(dba));
if(dbag != ensEDatabaseadaptorGroupCore)
{
ajStrAppendC(&dbname, "_");
ajStrAppendC(&dbname, ensDatabaseadaptorGroupToChar(dbag));
}
dbc = ensDatabaseadaptorGetDatabaseconnection(dba);
ensDatabaseconnectionFetchUrl(dbc, &dbcurl);
if(outf)
ajFmtPrintF(outf, "%S\n", dbname);
ajFmtPrintF(cachef, "DBNAME %S [\n", dbname);
ajFmtPrintF(cachef, " release: \"%s\"\n", ensSoftwareGetVersion());
ajFmtPrintF(cachef, " server: \"%S\"\n", svrname);
ajFmtPrintF(cachef, " url: \"%S\"\n", dbcurl);
ajFmtPrintF(cachef, "]\n");
ajFmtPrintF(cachef, "\n");
if(dbag != ensEDatabaseadaptorGroupCore)
continue;
ensRegistryAliasFetchAllbySpecies(
ensDatabaseadaptorGetSpecies(dba),
aliases);
/*
** Format all aliases to lower case,
** sort them alphabetically and remove duplicates.
*/
iterator = ajListIterNew(aliases);
while(!ajListIterDone(iterator))
{
alias = ajListstrIterGet(iterator);
ajStrFmtLower(&alias);
}
ajListIterDel(&iterator);
ajListSortUnique(aliases,
cacheensembl_stringcompare,
cacheensembl_stringdelete);
alias = NULL;
if(ajListGetLength(aliases) > 0)
{
while(ajListstrPop(aliases, &alias))
{
/*
** Reject any aliases with other than alpha-numeric
** characters like white space.
*/
if(ajStrIsAlnum(alias))
ajFmtPrintF(cachef,
"ALIAS %S %S\n",
alias,
ensDatabaseadaptorGetSpecies(dba));
ajStrDel(&alias);
}
ajFmtPrintF(cachef, "\n");
}
/* Ensembl Database Adaptor objects *must not* be deleted. */
}
ajStrDel(&spname);
}
ajListstrFree(&aliases);
ajListFree(&dbas);
ajStrDel(&dbcurl);
ajStrDel(&svrurl);
ajStrDel(&dbname);
ajStrDel(&svrname);
ajFileClose(&outf);
ajFileClose(&cachef);
embExit();
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
AjPSeqset seqset = NULL;
AjPStr cl = NULL;
AjPSeqout seqout = NULL;
AjBool pc = ajFalse;
AjBool sigp = ajFalse;
AjBool plot = ajFalse;
const AjPStr ofn = NULL;
AjPStr fn = NULL;
AjPStr stmp = NULL;
AjPFile outf = NULL;
embInitPV("eprop", argc, argv, "CBSTOOLS", VERSION);
seqset = ajAcdGetSeqset("sequence");
outf = ajAcdGetOutfile("outfile");
plot = ajAcdGetBoolean("plot");
pc = ajAcdGetBoolean("pcprediction");
sigp = ajAcdGetBoolean("signalp");
cl = ajStrNewC("prop ");
fn = ajStrNew();
stmp = ajStrNew();
ajFilenameSetTempname(&fn);
seqout = ajSeqoutNew();
if(!ajSeqoutOpenFilename(seqout, fn))
ajFatal("Cannot open temporary file %S",fn);
ajSeqoutSetFormatC(seqout, "fasta");
ajSeqoutWriteSet(seqout,seqset);
ajSeqoutClose(seqout);
if(plot)
ajStrAppendC(&cl," -g");
if(pc)
ajStrAppendC(&cl," -p");
if(sigp)
ajStrAppendC(&cl," -s");
ajFmtPrintS(&stmp," %S",fn);
ajStrAppendS(&cl,stmp);
ofn = ajFileGetNameS(outf);
ajFmtPrintS(&stmp," > %S",ofn);
ajStrAppendS(&cl,stmp);
ajFileClose(&outf);
#if 0
ajFmtPrint("%S\n",cl);
#endif
#if 1
if(system(ajStrGetPtr(cl)) == -1)
ajFatal("Command %S failed",cl);
#endif
ajSysFileUnlink(fn);
ajStrDel(&cl);
ajStrDel(&fn);
ajStrDel(&stmp);
ajSeqoutDel(&seqout);
ajSeqsetDel(&seqset);
embExit();
return 0;
}
int main(int argc, char **argv)
{
const char *hmmfile; /* file to read HMMs from */
HMMFILE *hmmfp; /* opened hmmfile for reading */
const char *seqfile; /* file to read target sequence from */
char **rseq; /* raw, unaligned sequences */
SQINFO *sqinfo; /* info associated with sequences */
char **dsq; /* digitized raw sequences */
int nseq; /* number of sequences */
char **aseq; /* aligned sequences */
AINFO ainfo; /* alignment information */
float *wgt; /* per-sequence weights */
int i;
struct plan7_s *hmm; /* HMM to align to */
struct p7trace_s **tr; /* traces for aligned sequences */
int be_quiet; /* TRUE to suppress verbose banner */
int matchonly; /* TRUE to show only match state syms */
const char *outfile; /* optional alignment output file */
FILE *ofp; /* handle on alignment output file */
AjPFile ajwithali; /* name of additional alignment file to align */
AjPFile ajmapali; /* name of additional alignment file to map */
AjBool ajmatch=ajFalse;
AjPFile outf=NULL;
AjPStr outfname=NULL;
AjPFile inf=NULL;
AjPStr infname=NULL;
AjPSeqset seqset=NULL;
AjPStr ajseqfile=NULL;
char* mapali=NULL;
char* withali=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
***********************************************/
matchonly = FALSE;
outfile = NULL;
be_quiet = FALSE;
withali = NULL;
mapali = NULL;
embInitPV("ohmmalign",argc,argv,"HMMER",VERSION);
ajmatch = ajAcdGetBoolean("matchonly");
if(ajmatch)
matchonly=TRUE;
else
matchonly=FALSE;
ajmapali = ajAcdGetInfile("mapalifile");
if (ajmapali)
mapali = ajCharNewS(ajFileGetNameS(ajmapali));
ajFileClose(&ajmapali);
ajwithali = ajAcdGetInfile("withalifile");
if (ajwithali)
withali = ajCharNewS(ajFileGetNameS(ajwithali));
ajFileClose(&ajwithali);
be_quiet=TRUE;
outf = ajAcdGetOutfile("outfile");
outfname = ajStrNewC((char *)ajFileGetNameC(outf));
if(*ajStrGetPtr(outfname)>31)
ajFileClose(&outf);
outfile = ajStrGetPtr(outfname);
inf = ajAcdGetInfile("hmmfile");
infname = ajStrNewC((char *)ajFileGetNameC(inf));
ajFileClose(&inf);
hmmfile = ajStrGetPtr(infname);
seqset = ajAcdGetSeqset("sequences");
ajseqfile = ajStrNewC(ajStrGetPtr(seqset->Filename));
seqfile = ajStrGetPtr(ajseqfile);
/***********************************************
* Open HMM file (might be in HMMERDB or current directory).
* Read a single HMM from it.
*
* Currently hmmalign disallows the J state and
* only allows one domain per sequence. To preserve
* the S/W entry information, the J state is explicitly
* disallowed, rather than calling a Plan7*Config() function.
* this is a workaround in 2.1 for the 2.0.x "yo!" bug.
***********************************************/
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);
hmm->xt[XTE][MOVE] = 1.; /* only 1 domain/sequence ("global" alignment) */
hmm->xt[XTE][LOOP] = 0.;
P7Logoddsify(hmm, TRUE);
/* do we have the map we might need? */
if (mapali != NULL && ! (hmm->flags & PLAN7_MAP))
ajFatal("HMMER: HMM file %s has no map; you can't use --mapali.", hmmfile);
/***********************************************
* Open sequence file in current directory.
* Read all seqs from it.
***********************************************/
/*
if (! SeqfileFormat(seqfile, &format, NULL))
switch (squid_errno) {
case SQERR_NOFILE:
ajFatal("Sequence file %s could not be opened for reading", seqfile);
case SQERR_FORMAT:
default:
ajFatal("Failed to determine format of sequence file %s", seqfile);
}
if (! ReadMultipleRseqs(seqfile, format, &rseq, &sqinfo, &nseq))
ajFatal("Failed to read any sequences from file %s", seqfile);
*/
emboss_rseqs(seqset,&rseq,&sqinfo,&nseq);
/***********************************************
* Show the banner
***********************************************/
be_quiet=TRUE;
if (! be_quiet)
{
/* Banner(stdout, banner); */
printf( "HMM file: %s\n", hmmfile);
printf( "Sequence file: %s\n", seqfile);
printf("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n\n");
}
/***********************************************
* Do the work
***********************************************/
/* Allocations and initializations.
*/
dsq = MallocOrDie(sizeof(char *) * nseq);
tr = MallocOrDie(sizeof(struct p7trace_s *) * nseq);
/* Align each sequence to the model, collect traces
*/
for (i = 0; i < nseq; i++)
{
dsq[i] = DigitizeSequence(rseq[i], sqinfo[i].len);
if (P7ViterbiSize(sqinfo[i].len, hmm->M) <= RAMLIMIT)
(void) P7Viterbi(dsq[i], sqinfo[i].len, hmm, &(tr[i]));
else
(void) P7SmallViterbi(dsq[i], sqinfo[i].len, hmm, &(tr[i]));
}
/* Include an aligned alignment, if desired.
*/
if (mapali != NULL)
include_alignment(mapali, hmm, TRUE, &rseq, &dsq, &sqinfo, &tr, &nseq);
if (withali != NULL)
include_alignment(withali, hmm, FALSE, &rseq, &dsq, &sqinfo, &tr, &nseq);
/* Turn traces into a multiple alignment
*/
wgt = MallocOrDie(sizeof(float) * nseq);
FSet(wgt, nseq, 1.0);
P7Traces2Alignment(dsq, sqinfo, wgt, nseq, hmm->M, tr, matchonly,
&aseq, &ainfo);
/***********************************************
* Output the alignment
***********************************************/
if (outfile != NULL && (ofp = fopen(outfile, "w")) != NULL)
{
WriteSELEX(ofp, aseq, &ainfo, 50);
printf("Alignment saved in file %s\n", outfile);
fclose(ofp);
}
else
WriteSELEX(stdout, aseq, &ainfo, 50);
/***********************************************
* Cleanup and exit
***********************************************/
for (i = 0; i < nseq; i++)
{
P7FreeTrace(tr[i]);
FreeSequence(rseq[i], &(sqinfo[i]));
free(dsq[i]);
}
FreeAlignment(aseq, &ainfo);
FreePlan7(hmm);
free(sqinfo);
free(rseq);
free(dsq);
free(wgt);
free(tr);
SqdClean();
ajStrDel(&outfname);
ajStrDel(&infname);
ajStrDel(&ajseqfile);
#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
ajSeqsetDel(&seqset);
ajFileClose(&ajwithali);
ajFileClose(&ajmapali);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPStr cl = NULL;
AjPSeqset seqset = NULL;
AjPSeqout seqout = NULL;
AjPStr stmp = NULL;
AjPStr email = NULL;
AjPStr fmt = NULL;
AjPStr trtab = NULL;
const AjPStr ofn = NULL;
AjPStr *applist = NULL;
AjBool crc = ajFalse;
AjBool alt = ajFalse;
AjBool iprlook = ajFalse;
AjBool goterms = ajFalse;
ajint trlen = 0;
ajuint i = 0;
ajuint lcnt = 0;
AjPStr fn = NULL;
AjPFile outf = NULL;
embInitPV("eiprscan", argc, argv, "IPRSCAN", VERSION);
seqset = ajAcdGetSeqset("sequence");
email = ajAcdGetString("email");
crc = ajAcdGetBoolean("crc");
applist = ajAcdGetList("appl");
fmt = ajAcdGetListSingle("format");
trtab = ajAcdGetListSingle("trtable");
trlen = ajAcdGetInt("trlen");
alt = ajAcdGetBoolean("altjobs");
iprlook = ajAcdGetBoolean("iprlookup");
goterms = ajAcdGetBoolean("goterms");
outf = ajAcdGetOutfile("outfile");
stmp = ajStrNew();
cl = ajStrNewC("iprscan -cli");
fn = ajStrNew();
ajFilenameSetTempname(&fn);
seqout = ajSeqoutNew();
if(!ajSeqoutOpenFilename(seqout, fn))
ajFatal("Cannot open temporary file %S",fn);
ajSeqoutSetFormatC(seqout, "fasta");
ajSeqoutWriteSet(seqout,seqset);
ajSeqoutClose(seqout);
ajFmtPrintS(&stmp," -i %S",fn);
ajStrAppendS(&cl,stmp);
if(!ajSeqsetIsProt(seqset))
ajStrAppendC(&cl," -seqtype n");
if(!crc)
ajStrAppendC(&cl," -nocrc");
if(ajStrGetLen(email))
{
ajFmtPrintS(&stmp," -email %S",email);
ajStrAppendS(&cl,stmp);
}
i = 0;
lcnt = 0;
while(applist[i])
{
++lcnt;
++i;
}
i = 0;
while(applist[i])
{
if(ajStrMatchC(applist[i],"all"))
{
if(lcnt != 1)
ajFatal("Cannot specify 'all' with multiple "
"applications");
++i;
continue;
}
ajFmtPrintS(&stmp," -appl %S",applist[i]);
ajStrAppendS(&cl,stmp);
++i;
}
ajFmtPrintS(&stmp," -format %S",fmt);
ajStrAppendS(&cl,stmp);
ajFmtPrintS(&stmp," -trtable %S",trtab);
ajStrAppendS(&cl,stmp);
ajFmtPrintS(&stmp," -trlen %d",trlen);
ajStrAppendS(&cl,stmp);
if(alt)
ajStrAppendC(&cl," -altjobs");
if(iprlook)
ajStrAppendC(&cl," -iprlookup");
if(goterms)
ajStrAppendC(&cl," -goterms");
ofn = ajFileGetNameS(outf);
ajFmtPrintS(&stmp," -o %S",ofn);
ajFileClose(&outf);
ajStrAppendS(&cl,stmp);
#if 0
ajFmtPrint("%S\n",cl);
#endif
#if 1
system(ajStrGetPtr(cl));
#endif
ajSysFileUnlink(fn);
ajStrDel(&cl);
ajStrDel(&fn);
ajStrDel(&stmp);
ajStrDel(&email);
ajStrDel(&fmt);
ajStrDel(&trtab);
ajStrDelarray(&applist);
ajSeqoutDel(&seqout);
ajSeqsetDel(&seqset);
embExit();
return 0;
}
