int main(int argc, char **argv)
{
ajint begin, end;
AjPSeqall seqall;
AjPSeq seq;
EmbPShow ss;
AjPFile outfile;
AjPStr tablename;
ajint table;
AjPRange uppercase;
AjPRange highlight;
AjBool threeletter;
AjBool numberseq;
AjBool nameseq;
ajint width;
ajint length;
ajint margin;
AjBool description;
ajint offset;
AjBool html;
AjPStr descriptionline;
ajint orfminsize;
AjPTrn trnTable;
AjBool translation;
AjBool reverse;
AjBool cutlist;
AjBool flat;
EmbPMatMatch mm = NULL;
AjPStr *framelist;
AjBool frames[6]; /* frames to be translated 1 to 3, -1 to -3 */
/* stuff for tables and lists of enzymes and hits */
ajint default_mincuts = 1;
ajint default_maxcuts = 2000000000;
AjPTable hittable; /* enzyme hits */
/* stuff lifted from Alan's 'restrict.c' */
AjPStr enzymes = NULL;
ajint mincuts;
ajint maxcuts;
ajint sitelen;
AjBool single;
AjBool blunt;
AjBool sticky;
AjBool ambiguity;
AjBool plasmid;
AjBool commercial;
AjBool limit;
AjBool methyl;
AjPFile enzfile = NULL;
AjPFile equfile = NULL;
AjPFile methfile = NULL;
AjPTable retable = NULL;
ajint hits;
AjPList restrictlist = NULL;
embInit("remap", argc, argv);
seqall = ajAcdGetSeqall("sequence");
outfile = ajAcdGetOutfile("outfile");
tablename = ajAcdGetListSingle("table");
uppercase = ajAcdGetRange("uppercase");
highlight = ajAcdGetRange("highlight");
threeletter = ajAcdGetBoolean("threeletter");
numberseq = ajAcdGetBoolean("number");
width = ajAcdGetInt("width");
length = ajAcdGetInt("length");
margin = ajAcdGetInt("margin");
nameseq = ajAcdGetBoolean("name");
description = ajAcdGetBoolean("description");
offset = ajAcdGetInt("offset");
html = ajAcdGetBoolean("html");
orfminsize = ajAcdGetInt("orfminsize");
translation = ajAcdGetBoolean("translation");
reverse = ajAcdGetBoolean("reverse");
cutlist = ajAcdGetBoolean("cutlist");
flat = ajAcdGetBoolean("flatreformat");
framelist = ajAcdGetList("frame");
/* restriction enzyme stuff */
mincuts = ajAcdGetInt("mincuts");
maxcuts = ajAcdGetInt("maxcuts");
sitelen = ajAcdGetInt("sitelen");
single = ajAcdGetBoolean("single");
blunt = ajAcdGetBoolean("blunt");
sticky = ajAcdGetBoolean("sticky");
ambiguity = ajAcdGetBoolean("ambiguity");
plasmid = ajAcdGetBoolean("plasmid");
commercial = ajAcdGetBoolean("commercial");
limit = ajAcdGetBoolean("limit");
enzymes = ajAcdGetString("enzymes");
methfile = ajAcdGetDatafile("mfile");
methyl = ajAcdGetBoolean("methylation");
if(!blunt && !sticky)
ajFatal("Blunt/Sticky end cutters shouldn't both be disabled.");
/* get the number of the genetic code used */
ajStrToInt(tablename, &table);
trnTable = ajTrnNewI(table);
/* read the local file of enzymes names */
remap_read_file_of_enzyme_names(&enzymes);
/* get the frames to be translated */
remap_GetFrames(framelist, frames);
while(ajSeqallNext(seqall, &seq))
{
/* get begin and end positions */
begin = ajSeqGetBegin(seq)-1;
end = ajSeqGetEnd(seq)-1;
/* do the name and description */
if(nameseq)
{
if(html)
ajFmtPrintF(outfile, "<H2>%S</H2>\n",
ajSeqGetNameS(seq));
else
ajFmtPrintF(outfile, "%S\n", ajSeqGetNameS(seq));
}
if(description)
{
/*
** wrap the description line at the width of the sequence
** plus margin
*/
if(html)
ajFmtPrintF(outfile, "<H3>%S</H3>\n",
ajSeqGetDescS(seq));
else
{
descriptionline = ajStrNew();
ajStrAssignS(&descriptionline, ajSeqGetDescS(seq));
ajStrFmtWrap(&descriptionline, width+margin);
ajFmtPrintF(outfile, "%S\n", descriptionline);
ajStrDel(&descriptionline);
}
}
/* get the restriction cut sites */
/*
** most of this is lifted from the program 'restrict.c' by Alan
** Bleasby
*/
if(single)
maxcuts=mincuts=1;
retable = ajTablestrNew(EQUGUESS);
enzfile = ajDatafileNewInNameC(ENZDATA);
if(!enzfile)
ajFatal("Cannot locate enzyme file. Run REBASEEXTRACT");
if(limit)
{
equfile = ajDatafileNewInNameC(EQUDATA);
if(!equfile)
limit = ajFalse;
else
remap_read_equiv(&equfile, &retable, commercial);
}
ajFileSeek(enzfile, 0L, 0);
restrictlist = ajListNew();
/* search for hits, but don't use mincuts and maxcuts criteria yet */
hits = embPatRestrictMatch(seq, begin+1, end+1, enzfile, methfile,
enzymes, sitelen,plasmid, ambiguity,
default_mincuts, default_maxcuts, blunt,
sticky, commercial, methyl,
restrictlist);
ajDebug("Remap found %d hits\n", hits);
if(hits)
{
/* this bit is lifted from printHits */
embPatRestrictRestrict(restrictlist, hits, !limit,
ajFalse);
if(limit)
remap_RestrictPreferred(restrictlist,retable);
}
ajFileClose(&enzfile);
ajFileClose(&methfile);
/*
** Remove those violating the mincuts and maxcuts
** criteria, but save them in hittable for printing out later.
** Keep a count of how many hits each enzyme gets in hittable.
*/
hittable = ajTablestrNewCase(TABLEGUESS);
remap_RemoveMinMax(restrictlist, hittable, mincuts, maxcuts);
/* make the Show Object */
ss = embShowNew(seq, begin, end, width, length, margin, html, offset);
if(html)
ajFmtPrintF(outfile, "<PRE>");
/* create the format to display */
embShowAddBlank(ss);
embShowAddRE(ss, 1, restrictlist, plasmid, flat);
embShowAddSeq(ss, numberseq, threeletter, uppercase, highlight);
if(!numberseq)
embShowAddTicknum(ss);
embShowAddTicks(ss);
if(reverse)
{
embShowAddComp(ss, numberseq);
embShowAddRE(ss, -1, restrictlist, plasmid, flat);
}
if(translation)
{
if(reverse)
embShowAddBlank(ss);
if(frames[0])
embShowAddTran(ss, trnTable, 1, threeletter,
numberseq, NULL, orfminsize,
AJFALSE, AJFALSE, AJFALSE, AJFALSE);
if(frames[1])
embShowAddTran(ss, trnTable, 2, threeletter,
numberseq, NULL, orfminsize,
AJFALSE, AJFALSE, AJFALSE, AJFALSE);
if(frames[2])
embShowAddTran(ss, trnTable, 3, threeletter,
numberseq, NULL, orfminsize,
AJFALSE, AJFALSE, AJFALSE, AJFALSE);
if(reverse)
{
embShowAddTicks(ss);
if(frames[5])
embShowAddTran(ss, trnTable, -3, threeletter,
numberseq, NULL, orfminsize,
AJFALSE, AJFALSE, AJFALSE, AJFALSE);
if(frames[4])
embShowAddTran(ss, trnTable, -2, threeletter,
numberseq, NULL, orfminsize,
AJFALSE, AJFALSE, AJFALSE, AJFALSE);
if(frames[3])
embShowAddTran(ss, trnTable, -1, threeletter,
numberseq, NULL, orfminsize,
AJFALSE, AJFALSE, AJFALSE, AJFALSE);
}
}
embShowPrint(outfile, ss);
/* display a list of the Enzymes that cut and don't cut */
if(cutlist)
{
remap_CutList(outfile, hittable,
limit, html, mincuts, maxcuts);
remap_NoCutList(outfile, hittable, html, enzymes, blunt,
sticky, sitelen, commercial, ambiguity,
limit, retable);
}
/* add a gratuitous newline at the end of the sequence */
ajFmtPrintF(outfile, "\n");
/* tidy up */
embShowDel(&ss);
while(ajListPop(restrictlist,(void **)&mm))
embMatMatchDel(&mm);
ajListFree(&restrictlist);
remap_DelTable(&hittable);
ajTablestrFree(&retable);
}
ajTrnDel(&trnTable);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajFileClose(&outfile);
ajStrDel(&tablename);
ajStrDel(&enzymes);
ajStrDelarray(&framelist);
ajRangeDel(&uppercase);
ajRangeDel(&highlight);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPList idlist;
AjPList* fieldList = NULL;
AjBool systemsort;
AjBool cleanup;
ajuint maxindex;
ajuint maxidlen = 0;
ajuint maxlen;
AjPFile elistfile = NULL;
AjPFile* alistfile = NULL;
AjPStr dbname = NULL;
AjPStr release = NULL;
AjPStr datestr = NULL;
AjPStr sortopt = NULL;
void **entryIds = NULL;
AjPStr directory;
AjPStr indexdir;
AjPStr filename;
AjPStr exclude;
AjPStr curfilename = NULL;
AjPFile libr=NULL;
AjPStr idformat = NULL;
EmbPEntry entry;
ajuint idtype = 0;
ajuint idCount = 0;
ajuint idDone;
AjPList listInputFiles = NULL;
void ** inputFiles = NULL;
ajuint nfiles;
ajuint ifile;
ajuint filesize;
short recsize;
ajuint maxfilelen = 20;
char date[4] =
{
0,0,0,0
};
AjPStr tmpfname = NULL;
AjPStr* fields = NULL;
AjPFile entFile = NULL;
AjPStr* divfiles = NULL;
AjPRegexp regIdExp = NULL;
ajint* maxFieldLen = NULL;
ajuint ifield = 0;
ajuint nfields = 0;
AjPFile logfile = NULL;
ajuint* countField = NULL;
ajuint* fieldTot = NULL;
ajuint idCountFile = 0;
ajuint i;
embInit("dbifasta", argc, argv);
idformat = ajAcdGetListSingle("idformat");
fields = ajAcdGetList("fields");
directory = ajAcdGetDirectoryName("directory");
indexdir = ajAcdGetOutdirName("indexoutdir");
filename = ajAcdGetString("filenames");
exclude = ajAcdGetString("exclude");
dbname = ajAcdGetString("dbname");
release = ajAcdGetString("release");
datestr = ajAcdGetString("date");
systemsort = ajAcdGetBoolean("systemsort");
cleanup = ajAcdGetBoolean("cleanup");
sortopt = ajAcdGetString("sortoptions");
maxindex = ajAcdGetInt("maxindex");
logfile = ajAcdGetOutfile("outfile");
while(fields[nfields]) /* array ends with a NULL */
nfields++;
if(nfields)
{
AJCNEW(maxFieldLen, nfields);
AJCNEW0(countField, nfields);
AJCNEW0(fieldTot, nfields);
for(ifield=0; ifield < nfields; ifield++)
maxFieldLen[ifield] = (ajint)maxindex * -1;
if(systemsort)
AJCNEW(alistfile, nfields);
else
{
AJCNEW(fieldList, nfields);
for(ifield=0; ifield < nfields; ifield++)
fieldList[ifield] = ajListNew();
}
}
if(ajStrMatchC(datestr, "00/00/00"))
ajFmtPrintS(&datestr, "%D", ajTimeRefTodayFmt("dbindex"));
ajStrRemoveWhite(&dbname); /* used for temp filenames */
embDbiDateSet(datestr, date);
idlist = ajListNew();
regIdExp = dbifasta_getExpr(idformat, &idtype);
ajDebug("reading '%S/%S'\n", directory, filename);
ajDebug("writing '%S/'\n", indexdir);
listInputFiles = embDbiFileListExc(directory, filename, exclude);
ajListSort(listInputFiles, &ajStrVcmp);
nfiles = (ajuint) ajListToarray(listInputFiles, &inputFiles);
if(!nfiles)
ajDie("No input files in '%S' matched filename '%S'",
directory, filename);
embDbiLogHeader(logfile, dbname, release, datestr,
indexdir, maxindex);
embDbiLogFields(logfile, fields, nfields);
embDbiLogSource(logfile, directory, filename, exclude,
(AjPStr*) inputFiles, nfiles);
embDbiLogCmdline(logfile);
AJCNEW0(divfiles, nfiles);
/*
** process each input file, one at a time
*/
for(ifile=0; ifile < nfiles; ifile++)
{
ajStrAssignS(&curfilename,(AjPStr) inputFiles[ifile]);
embDbiFlatOpenlib(curfilename, &libr);
ajFilenameTrimPath(&curfilename);
if(ajStrGetLen(curfilename) >= maxfilelen)
maxfilelen = ajStrGetLen(curfilename) + 1;
ajDebug("processing filename '%S' ...\n", curfilename);
ajDebug("processing file '%F' ...\n", libr);
ajStrAssignS(&divfiles[ifile], curfilename);
if(systemsort) /* elistfile for entries, alist for fields */
elistfile = embDbiSortOpen(alistfile, ifile,
dbname, fields, nfields);
idCountFile = 0;
for(i=0;i<nfields;i++)
countField[i] = 0;
while((entry=dbifasta_NextFlatEntry(libr, ifile,
regIdExp, idtype,
systemsort, fields,
maxFieldLen, &maxidlen,
countField, elistfile,
alistfile)))
{
idCountFile++;
if(!systemsort) /* save the entry data in lists */
embDbiMemEntry(idlist, fieldList, nfields,
entry, ifile);
entry = NULL;
}
idCount += idCountFile;
if(systemsort)
{
embDbiSortClose(&elistfile, alistfile, nfields);
AJFREE(entry);
}
else
{
embDbiEntryDel(&dbifastaGEntry);
}
embDbiLogFile(logfile, curfilename, idCountFile, fields,
countField, nfields);
}
/* write the division.lkp file */
embDbiWriteDivision(indexdir, dbname, release, date,
maxfilelen, nfiles, divfiles, NULL);
/* Write the entryname.idx index */
ajStrAssignC(&tmpfname, "entrynam.idx");
entFile = ajFileNewOutNamePathS(tmpfname, indexdir);
recsize = maxidlen+10;
filesize = 300 + (idCount*(ajint)recsize);
embDbiHeader(entFile, filesize, idCount, recsize, dbname, release, date);
if(systemsort)
idDone = embDbiSortWriteEntry(entFile, maxidlen,
dbname, nfiles, cleanup, sortopt);
else /* save entries in entryIds array */
{
idDone = embDbiMemWriteEntry(entFile, maxidlen,
idlist, &entryIds);
if(idDone != idCount)
ajFatal("Duplicates not allowed for in-memory processing");
}
embDbiHeaderSize(entFile, 300+(idDone*(ajint)recsize), idDone);
ajFileClose(&entFile);
/* Write the fields index files */
for(ifield=0; ifield < nfields; ifield++)
{
if(maxindex)
maxlen = maxindex;
else
{
if(maxFieldLen[ifield] >= 0)
maxlen = maxFieldLen[ifield];
else
maxlen = - maxFieldLen[ifield];
}
if(systemsort)
fieldTot[ifield] = embDbiSortWriteFields(dbname, release,
date, indexdir,
fields[ifield], maxlen,
nfiles, idCount,
cleanup, sortopt);
else
fieldTot[ifield] = embDbiMemWriteFields(dbname, release,
date, indexdir,
fields[ifield], maxlen,
fieldList[ifield],
entryIds);
}
embDbiLogFinal(logfile,maxindex, maxFieldLen, fields, fieldTot,
nfields, nfiles, idDone, idCount);
if(systemsort)
embDbiRmEntryFile(dbname, cleanup);
ajStrDel(&idformat);
ajStrDelarray(&fields);
ajStrDel(&filename);
ajStrDel(&exclude);
ajStrDel(&dbname);
ajStrDel(&release);
ajStrDel(&datestr);
ajStrDel(&sortopt);
ajStrDel(&directory);
ajStrDel(&indexdir);
ajStrDel(&tmpfname);
ajFileClose(&libr);
ajFileClose(&logfile);
for(i=0;i<nfields;i++)
{
if(systemsort)
{
ajFileClose(&alistfile[i]);
}
else
{
ajListMap(fieldList[i], &embDbiFieldDelMap, NULL);
ajListFree(&fieldList[i]);
}
}
AJFREE(alistfile);
AJFREE(fieldList);
AJFREE(maxFieldLen);
AJFREE(countField);
AJFREE(fieldTot);
for(i=0;i<nfiles;i++)
{
ajStrDel(&divfiles[i]);
}
AJFREE(divfiles);
AJFREE(inputFiles);
embDbiEntryDel(&dbifastaGEntry);
ajStrDel(&dbifastaGRline);
ajStrDel(&dbifastaGTmpId);
if(dbifastaGFdl)
{
for(i=0; i < nfields; i++)
ajListFree(&dbifastaGFdl[i]);
AJFREE(dbifastaGFdl);
}
ajListMap(idlist, &embDbiEntryDelMap, NULL);
ajListFree(&idlist);
ajListstrFreeData(&listInputFiles);
AJFREE(entryIds);
ajRegFree(&dbifastaGIdexp);
ajRegFree(&dbifastaGWrdexp);
ajRegFree(®IdExp);
ajStrDel(&dbifastaGTmpAc);
ajStrDel(&dbifastaGTmpSv);
ajStrDel(&dbifastaGTmpGi);
ajStrDel(&dbifastaGTmpDb);
ajStrDel(&dbifastaGTmpDes);
ajStrDel(&dbifastaGTmpFd);
ajStrDel(&curfilename);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPList idlist;
AjPList* fieldList = NULL;
AjBool systemsort;
AjBool cleanup;
ajint blastv = 0;
char dbtype = '\0';
ajuint maxindex;
ajuint maxidlen = 0;
ajuint maxlen;
AjPStr version = NULL;
AjPStr seqtype = NULL;
AjPFile elistfile = NULL;
AjPFile* alistfile = NULL;
AjPStr dbname = NULL;
AjPStr release = NULL;
AjPStr datestr = NULL;
AjPStr sortopt = NULL;
void **entryIds = NULL;
AjBool usesrc = AJTRUE;
AjPStr directory;
AjPStr indexdir;
AjPStr filename;
AjPStr exclude;
AjPStr curfilename = NULL;
AjPStr idformat = NULL;
EmbPEntry entry;
PBlastDb db = NULL;
ajuint idCount = 0;
ajuint idDone;
AjPList listTestFiles = NULL;
void ** testFiles = NULL;
ajuint nfiles;
ajuint ifile;
ajuint jfile;
ajuint filesize;
short recsize;
ajuint maxfilelen = 20;
char date[4] =
{
0,0,0,0
};
AjPStr tmpfname = NULL;
AjPStr* fields = NULL;
AjPFile entFile = NULL;
AjPStr* divfiles = NULL;
ajint* maxFieldLen = NULL;
ajuint ifield = 0;
ajuint nfields = 0;
AjPFile logfile = NULL;
ajuint* countField = NULL;
ajuint* fieldTot = NULL;
ajuint idCountFile = 0;
ajuint i = 0;
embInit("dbiblast", argc, argv);
idformat = ajStrNewC("NCBI");
fields = ajAcdGetList("fields");
directory = ajAcdGetDirectoryName("directory");
indexdir = ajAcdGetOutdirName("indexoutdir");
filename = ajAcdGetString("filenames");
exclude = ajAcdGetString("exclude");
dbname = ajAcdGetString("dbname");
release = ajAcdGetString("release");
datestr = ajAcdGetString("date");
systemsort = ajAcdGetBoolean("systemsort");
cleanup = ajAcdGetBoolean("cleanup");
sortopt = ajAcdGetString("sortoptions");
maxindex = ajAcdGetInt("maxindex");
version = ajAcdGetListSingle("blastversion");
seqtype = ajAcdGetListSingle("seqtype");
usesrc = ajAcdGetBoolean("sourcefile");
logfile = ajAcdGetOutfile("outfile");
while(fields[nfields]) /* array ends with a NULL */
nfields++;
if(nfields)
{
AJCNEW(maxFieldLen, nfields);
AJCNEW0(countField, nfields);
AJCNEW0(fieldTot, nfields);
for(ifield=0; ifield < nfields; ifield++)
maxFieldLen[ifield] = (ajint) maxindex * -1;
if(systemsort)
AJCNEW(alistfile, nfields);
else
{
AJCNEW(fieldList, nfields);
for(ifield=0; ifield < nfields; ifield++)
fieldList[ifield] = ajListNew();
}
}
if(ajStrMatchC(datestr, "00/00/00"))
ajFmtPrintS(&datestr, "%D", ajTimeRefTodayFmt("dbindex"));
ajStrRemoveWhite(&dbname); /* used for temp filenames */
embDbiDateSet(datestr, date);
idlist = ajListNew();
if(ajUtilGetBigendian())
readReverse = ajFalse;
else
readReverse = ajTrue;
ajStrToInt(version, &blastv);
dbtype = ajStrGetCharFirst(seqtype);
ajDebug("reading '%S/%S'\n", directory, filename);
ajDebug("writing '%S/'\n", indexdir);
listTestFiles = embDbiFileListExc(directory, filename, exclude);
ajListSort(listTestFiles, ajStrVcmp);
nfiles = ajListToarray(listTestFiles, &testFiles);
if(!nfiles)
ajDie("No input files in '%S' matched filename '%S'",
directory, filename);
embDbiLogHeader(logfile, dbname, release, datestr,
indexdir, maxindex);
embDbiLogFields(logfile, fields, nfields);
embDbiLogSource(logfile, directory, filename, exclude,
(AjPStr*) testFiles, nfiles);
embDbiLogCmdline(logfile);
AJCNEW0(divfiles, nfiles);
/*
** process each input file, one at a time
*/
jfile = 0;
for(ifile=0; ifile < nfiles; ifile++)
{
curfilename = (AjPStr) testFiles[ifile];
if(!dbiblast_blastopenlib(curfilename,
usesrc, blastv, dbtype, &db))
continue; /* could be the wrong file type with "*.*" */
ajDebug("processing filename '%S' ...\n", curfilename);
ajDebug("processing file '%S' ...\n", db->TFile->Name);
ajStrAssignS(&divfiles[jfile], db->TFile->Name);
ajFilenameTrimPath(&divfiles[jfile]);
if(ajStrGetLen(divfiles[jfile]) >= maxfilelen)
maxfilelen = ajStrGetLen(divfiles[jfile]) + 1;
if(systemsort) /* elistfile for entries, alist for fields */
elistfile = embDbiSortOpen(alistfile, jfile,
dbname, fields, nfields);
idCountFile = 0;
for(i=0;i<nfields;i++)
countField[i] = 0;
while((entry=dbiblast_nextblastentry(db, jfile,
idformat, systemsort,
fields,
maxFieldLen,
&maxidlen, countField,
elistfile, alistfile)))
{
idCountFile++;
if(!systemsort) /* save the entry data in lists */
{
embDbiMemEntry(idlist, fieldList, nfields, entry, jfile);
}
}
idCount += idCountFile;
if(systemsort)
{
embDbiSortClose(&elistfile, alistfile, nfields);
/* lost the entry, so can't free it :-) */
}
embDbiLogFile(logfile, curfilename, idCountFile, fields,
countField, nfields);
dbiblast_dbfree(&db);
jfile++;
}
nfiles = jfile;
/*
** write the division.lkp file
*/
embDbiWriteDivision(indexdir, dbname, release, date,
maxfilelen, nfiles, divfiles, NULL);
/*
** Write the entryname.idx index
*/
ajStrAssignC(&tmpfname, "entrynam.idx");
entFile = ajFileNewOutNamePathS(tmpfname, indexdir);
recsize = maxidlen+10;
filesize = 300 + (idCount*(ajint)recsize);
embDbiHeader(entFile, filesize, idCount, recsize, dbname, release, date);
if(systemsort)
idDone = embDbiSortWriteEntry(entFile, maxidlen,
dbname, nfiles, cleanup, sortopt);
else /* save entries in entryIds array */
{
idDone = embDbiMemWriteEntry(entFile, maxidlen,
idlist, &entryIds);
if(idDone != idCount)
ajFatal("Duplicates not allowed for in-memory processing");
}
embDbiHeaderSize(entFile, 300+(idDone*(ajint)recsize), idDone);
ajFileClose(&entFile);
/*
** Write the fields index files
*/
for(ifield=0; ifield < nfields; ifield++)
{
if(maxindex)
maxlen = maxindex;
else
{
if(maxFieldLen[ifield] >= 0)
maxlen = maxFieldLen[ifield];
else
maxlen = - maxFieldLen[ifield];
}
if(systemsort)
fieldTot[ifield] = embDbiSortWriteFields(dbname, release,
date, indexdir,
fields[ifield], maxlen,
nfiles, idCount,
cleanup, sortopt);
else
fieldTot[ifield] = embDbiMemWriteFields(dbname, release,
date, indexdir,
fields[ifield], maxlen,
fieldList[ifield],
entryIds);
}
embDbiLogFinal(logfile,maxindex, maxFieldLen, fields, fieldTot,
nfields, nfiles, idDone, idCount);
if(systemsort)
embDbiRmEntryFile(dbname, cleanup);
ajListMap(idlist, embDbiEntryDelMap, NULL);
ajListFree(&idlist);
AJFREE(entryIds);
ajStrDelarray(&fields);
for(i=0;i<nfields;i++)
{
if(systemsort)
{
ajFileClose(&alistfile[i]);
}
else
{
ajListMap(fieldList[i], embDbiFieldDelMap, NULL);
ajListFree(&fieldList[i]);
}
}
AJFREE(alistfile);
AJFREE(fieldList);
ajStrDel(&version);
ajStrDel(&seqtype);
ajFileClose(&elistfile);
for(i=0;i<nfiles;i++)
{
ajStrDel(&divfiles[i]);
}
AJFREE(countField);
AJFREE(fieldTot);
ajStrDel(&dbname);
ajStrDel(&release);
ajStrDel(&datestr);
ajStrDel(&sortopt);
ajStrDel(&directory);
ajStrDel(&indexdir);
ajStrDel(&filename);
ajStrDel(&exclude);
ajStrDel(&idformat);
ajStrDel(&tmpfname);
AJFREE(maxFieldLen);
ajFileClose(&logfile);
ajListstrFreeData(&listTestFiles);
ajStrDel(&t);
ajStrDel(&id);
ajStrDel(&acc);
ajStrDel(&hline);
ajStrDel(&tmpdes);
ajStrDel(&tmpfd);
ajStrDel(&tmpgi);
ajStrDel(&tmpdb);
ajStrDel(&tmpac);
ajStrDel(&tmpsv);
ajRegFree(&wrdexp);
embDbiEntryDel(&dbiblastEntry);
if(fdl)
{
for(i=0; i < nfields; i++)
ajListFree(&fdl[i]);
AJFREE(fdl);
}
for(i=0;i<nfiles;i++)
{
ajStrDel(&divfiles[i]);
}
AJFREE(divfiles);
AJFREE(testFiles);
embExit();
return 0;
}
int main(int argc, char **argv)
{
ajint famn = 0; /* Counter for the families. */
ajint nset = 0; /* No. entries in family. */
ajint last_nodeid = 0; /* SCOP Sunid of last family that was
processed. */
AjPStr last_node = NULL; /* Last family that was processed. */
AjPStr exec = NULL; /* The UNIX command line to be executed. */
AjPStr out = NULL; /* Name of stamp alignment file. */
AjPStr align = NULL; /* Name of sequence alignment file. */
AjPStr alignc = NULL; /* Name of structure alignment file. */
AjPStr log = NULL; /* Name of STAMP log file. */
AjPStr dom = NULL; /* Name of file containing single domain. */
AjPStr set = NULL; /* Name of file containing set of domains. */
AjPStr scan = NULL; /* Name of temp. file used by STAMP. */
AjPStr sort = NULL; /* Name of temp. file used by STAMP. */
AjPStr name = NULL; /* Base name of STAMP temp files. */
AjPStr pdbnames = NULL; /* Names of domain pdb files to be passed to
TCOFFEEE. */
AjPDir pdb = NULL; /* Path of domain coordinate files (pdb
format input). */
AjPDirout daf = NULL; /* Path of sequence alignment files for output. */
AjPDirout super = NULL; /* Path of structure alignment files for output. */
AjPDirout singlets = NULL; /* Path of FASTA singlet sequence files for output. */
AjPStr temp1 = NULL; /* A temporary string. */
AjPFile dcfin = NULL; /* File pointer for original Escop.dat file.*/
AjPFile domf = NULL; /* File pointer for single domain file. */
AjPFile setf = NULL; /* File pointer for domain set file. */
AjPFile logf = NULL; /* Log file. */
AjPDomain domain = NULL; /* Pointer to domain structure. */
AjPDomain prevdomain = NULL; /* Pointer to previous domain structure. */
ajint type = 0; /* Type of domain (ajSCOP or ajCATH) in the
DCF file. */
AjPStr *node = NULL; /* Node of alignment . */
ajint noden = 0; /*1: Class (SCOP), 2: Fold (SCOP) etc, see
ACD file. */
AjPStr *mode = NULL; /* Mode of operation from acd*/
ajint moden = 0; /* Program mode, 1: MODE_STAMP, 2: MODE_TCOFFEE (not
yet implemented). */
AjBool keepsinglets= ajFalse; /*Whether to retain sequences of singlet families
and write them to an output file. */
AjPStr temp = NULL; /* A temporary string. */
AjPStr cmd = NULL; /* The command line to execute t-coffee. */
/* Initialise strings etc*/
last_node = ajStrNew();
exec = ajStrNew();
out = ajStrNew();
align = ajStrNew();
alignc = ajStrNew();
log = ajStrNew();
dom = ajStrNew();
set = ajStrNew();
scan = ajStrNew();
sort = ajStrNew();
name = ajStrNew();
temp = ajStrNew();
temp1 = ajStrNew();
cmd = ajStrNew();
pdbnames = ajStrNew();
/* Read data from acd. */
embInitPV("domainalign",argc,argv,"DOMALIGN",VERSION);
dcfin = ajAcdGetInfile("dcfinfile");
pdb = ajAcdGetDirectory("pdbdir");
daf = ajAcdGetOutdir("dafoutdir");
super = ajAcdGetOutdir("superoutdir");
singlets = ajAcdGetOutdir("singletsoutdir");
node = ajAcdGetList("node");
mode = ajAcdGetList("mode");
keepsinglets = ajAcdGetToggle("keepsinglets");
logf = ajAcdGetOutfile("logfile");
/* Convert the selected node and mode to an integer. */
if(!(ajStrToInt(node[0], &noden)))
ajFatal("Could not parse ACD node option");
if(!(ajStrToInt(mode[0], &moden)))
ajFatal("Could not parse ACD node option");
/* Initialise random number generator for naming of temp. files. */
ajRandomSeed();
ajFilenameSetTempname(&name);
/* Create names for temp. files. */
ajStrAssignS(&log, name);
ajStrAppendC(&log, ".log");
ajStrAssignS(&dom, name);
ajStrAppendC(&dom, ".dom");
ajStrAssignS(&set, name);
ajStrAppendC(&set, ".set");
ajStrAssignS(&scan, name);
ajStrAppendC(&scan, ".scan");
ajStrAssignS(&sort, name);
ajStrAppendC(&sort, ".sort");
ajStrAssignS(&out, name);
ajStrAppendC(&out, ".out");
/* Initialise last_node with something that is not in SCOP. */
ajStrAssignC(&last_node,"!!!!!");
/* Open STAMP domain set file. */
if(moden == MODE_STAMP)
{
if(!(setf=ajFileNewOutNameS(set)))
ajFatal("Could not open domain set file\n");
}
/* Get domain type. */
type = ajDomainDCFType(dcfin);
/* Start of main application loop. */
while((domain=(ajDomainReadCNew(dcfin, "*", type))))
{
/* A new family. */
if(((domain->Type == ajSCOP) &&
(((noden==1) && (last_nodeid != domain->Scop->Sunid_Class)) ||
((noden==2) && (last_nodeid != domain->Scop->Sunid_Fold)) ||
((noden==3) && (last_nodeid != domain->Scop->Sunid_Superfamily))||
((noden==4) && (last_nodeid != domain->Scop->Sunid_Family)))) ||
((domain->Type == ajCATH) &&
(((noden==5) && (last_nodeid != domain->Cath->Class_Id)) ||
((noden==6) && (last_nodeid != domain->Cath->Arch_Id)) ||
((noden==7) && (last_nodeid != domain->Cath->Topology_Id)) ||
((noden==8) && (last_nodeid != domain->Cath->Superfamily_Id)) ||
((noden==9) && (last_nodeid != domain->Cath->Family_Id)))))
{
/* If we have done the first family. */
if(famn)
{
/* Create the output file for the alignment - the name will
be the same as the Sunid for the DOMAIN family. */
domainalign_writeid(prevdomain, noden, daf, super,
&align, &alignc);
if(moden == MODE_STAMP)
{
/* Close domain set file. */
ajFileClose(&setf);
/* Call STAMP. */
/* Family with 2 or more entries. */
if(nset > 1)
{
domainalign_stamp(prevdomain,
domain,
daf,
super,
singlets,
align,
alignc,
dom,
name,
set,
scan,
sort,
log,
out,
keepsinglets,
moden,
noden,
nset,
logf);
}
else if(keepsinglets) /* Singlet family. */
domainalign_keepsinglets(prevdomain, noden,
singlets, logf);
/* Open STAMP domain set file. */
if(!(setf=ajFileNewOutNameS(set)))
ajFatal("Could not open domain set file\n");
}
else
{
/* Call TCOFEE. */
if(nset > 1)
domainalign_tcoffee(prevdomain, out, align,
alignc, pdbnames, noden, logf);
else if(keepsinglets) /* Singlet family. */
domainalign_keepsinglets(prevdomain, noden,
singlets, logf);
}
/* Set the number of members of the new family to zero. */
nset = 0;
/* Clear TCOFFEE argument. */
ajStrSetClear(&pdbnames);
}
/* Open, write and close STAMP domain file. */
if(moden == MODE_STAMP)
{
if(!(domf=ajFileNewOutNameS(dom)))
ajFatal("Could not open domain file\n");
ajStrAssignS(&temp, ajDomainGetId(domain));
ajStrFmtLower(&temp);
ajFmtPrintF(domf, "%S %S { ALL }\n", temp, temp);
ajFileClose(&domf);
}
/* Copy current family name to last_node. */
domainalign_writelast(domain, noden, &last_node, &last_nodeid);
/* Copy current domain pointer to prevdomain. */
ajDomainDel(&prevdomain);
prevdomain=NULL;
ajDomainCopy(&prevdomain, domain);
/* Increment family counter. */
famn++;
}
ajStrAssignS(&temp, ajDomainGetId(domain));
ajStrFmtLower(&temp);
/* Write STAMP domain set file. */
if(moden == MODE_STAMP)
ajFmtPrintF(setf, "%S %S { ALL }\n", temp, temp);
/* Write TCOFFEE argument. */
else
{
ajStrAppendS(&pdbnames, ajDirGetPath(pdb));
ajStrAppendS(&pdbnames, temp);
ajStrAppendC(&pdbnames, ".");
ajStrAppendS(&pdbnames, ajDirGetExt(pdb));
ajStrAppendC(&pdbnames, " ");
}
ajDomainDel(&domain);
/* Increment number of members in family. */
nset++;
}
/* End of main application loop. */
domain=prevdomain;
ajFmtPrint("\nProcessing node %d\n", last_nodeid);
/* Create the output file for the alignment - the name will
be the same as the Sunid for the DOMAIN family. */
domainalign_writeid(prevdomain, noden, daf, super, &align, &alignc);
/* Code to process last family. */
if(moden == MODE_STAMP)
{
/*Close domain set file. */
ajFileClose(&setf);
/* ajFmtPrint("\n***** SECOND CALL\n");. */
if(nset > 1)
{
domainalign_stamp(prevdomain,
domain,
daf,
super,
singlets,
align,
alignc,
dom,
name,
set,
scan,
sort,
log,
out,
keepsinglets,
moden,
noden,
nset,
logf);
}
else if(keepsinglets) /* Singlet family. */
domainalign_keepsinglets(prevdomain, noden, singlets, logf);
}
else
{
/* Call TCOFEE. */
if(nset > 1)
domainalign_tcoffee(prevdomain, out, align, alignc,
pdbnames, noden, logf);
else if(keepsinglets) /* Singlet family. */
domainalign_keepsinglets(prevdomain, noden, singlets, logf);
}
/* Remove all temporary files. */
ajSysFileUnlinkS(log);
ajSysFileUnlinkS(dom);
ajSysFileUnlinkS(set);
ajSysFileUnlinkS(scan);
ajSysFileUnlinkS(sort);
ajSysFileUnlinkS(out);
ajStrAssignS(&temp, name);
ajStrAppendC(&temp, ".mat");
ajSysFileUnlinkS(temp);
/* Tidy up*/
ajDomainDel(&domain);
ajFileClose(&dcfin);
ajStrDel(&last_node);
ajStrDel(&exec);
ajStrDel(&log);
ajStrDel(&dom);
ajStrDel(&set);
ajStrDel(&scan);
ajStrDel(&sort);
ajStrDel(&name);
ajStrDel(&out);
ajStrDel(&align);
ajStrDel(&alignc);
ajStrDel(&pdbnames);
ajDirDel(&pdb);
ajDiroutDel(&daf);
ajDiroutDel(&super);
ajDiroutDel(&singlets);
ajStrDel(&temp);
ajStrDel(&temp1);
ajStrDel(&node[0]);
AJFREE(node);
ajStrDel(&mode[0]);
AJFREE(mode);
ajFileClose(&logf);
ajExit();
return 0;
}
int main(int argc, char **argv)
{
/* Global details */
AjBool explain_flag;
AjBool file_flag;
AjPStr* task;
AjBool do_primer;
AjBool do_hybrid;
ajint num_return;
ajint first_base_index;
/* "Sequence" Input Tags */
AjPSeqall sequence;
AjPRange included_region;
AjPRange target;
AjPRange excluded_region;
AjPStr left_input;
AjPStr right_input;
/* Primer details */
AjBool pick_anyway;
AjPFile mispriming_library;
float max_mispriming;
float pair_max_mispriming;
ajint gc_clamp;
ajint opt_size;
ajint min_size;
ajint max_size;
float opt_tm;
float min_tm;
float max_tm;
float max_diff_tm;
float opt_gc_percent;
float min_gc;
float max_gc;
float salt_conc;
float dna_conc;
ajint num_ns_accepted;
float self_any;
float self_end;
ajint max_poly_x;
/* Sequence Quality. These are not (yet) implemented */
/*
AjPFile sequence_quality;
ajint min_quality;
ajint min_end_quality;
ajint quality_range_min;
ajint quality_range_max;
*/
/* Product details */
ajint product_opt_size;
AjPRange product_size_range;
float product_opt_tm;
float product_min_tm;
float product_max_tm;
/* Objective Function Penalty Weights for Primers */
float max_end_stability;
/* these are not (yet) implemented */
/*
float inside_penalty;
float outside_penalty;
*/
/* Primer penalties */
/* these are not (yet) implemented */
/* Internal Oligo "Sequence" Input Tags */
AjPRange internal_oligo_excluded_region;
/* Internal Oligo "Global" Input Tags */
AjPStr internal_oligo_input;
ajint internal_oligo_opt_size;
ajint internal_oligo_min_size;
ajint internal_oligo_max_size;
float internal_oligo_opt_tm;
float internal_oligo_min_tm;
float internal_oligo_max_tm;
float internal_oligo_opt_gc_percent;
float internal_oligo_min_gc;
float internal_oligo_max_gc;
float internal_oligo_salt_conc;
float internal_oligo_dna_conc;
float internal_oligo_self_any;
float internal_oligo_self_end;
ajint internal_oligo_max_poly_x;
AjPFile internal_oligo_mishyb_library;
float internal_oligo_max_mishyb;
/*
ajint internal_oligo_min_quality;
*/
/* Internal Oligo penalties */
/* these are not (yet) implemented */
/* EMBOSS-wrapper-specific stuff */
AjPFile outfile;
/* other variables */
AjPStr result = NULL;
AjPStr strand = NULL;
AjPStr substr = NULL;
AjPSeq seq = NULL;
ajint begin = 0;
ajint end;
FILE* stream;
AjPStr taskstr = NULL;
const AjPStr program = NULL;
/* pipe variables */
int *pipeto; /* pipe to feed the exec'ed program input */
int *pipefrom; /* pipe to get the exec'ed program output */
embInit("eprimer3", argc, argv);
/* Global details */
explain_flag = ajAcdGetBoolean("explainflag");
file_flag = ajAcdGetBoolean("fileflag");
task = ajAcdGetList("task");
do_primer = ajAcdGetToggle("primer");
do_hybrid = ajAcdGetToggle("hybridprobe");
num_return = ajAcdGetInt("numreturn");
first_base_index = ajAcdGetInt("firstbaseindex");
/* "Sequence" Input Tags */
sequence = ajAcdGetSeqall("sequence");
included_region = ajAcdGetRange("includedregion");
target = ajAcdGetRange("targetregion");
excluded_region = ajAcdGetRange("excludedregion");
left_input = ajAcdGetString("forwardinput");
right_input = ajAcdGetString("reverseinput");
/* Primer details */
pick_anyway = ajAcdGetBoolean("pickanyway");
mispriming_library = ajAcdGetInfile("mispriminglibraryfile");
max_mispriming = ajAcdGetFloat("maxmispriming");
pair_max_mispriming = ajAcdGetFloat("pairmaxmispriming");
gc_clamp = ajAcdGetInt("gcclamp");
opt_size = ajAcdGetInt("osize");
min_size = ajAcdGetInt("minsize");
max_size = ajAcdGetInt("maxsize");
opt_tm = ajAcdGetFloat("otm");
min_tm = ajAcdGetFloat("mintm");
max_tm = ajAcdGetFloat("maxtm");
max_diff_tm = ajAcdGetFloat("maxdifftm");
opt_gc_percent = ajAcdGetFloat("ogcpercent");
min_gc = ajAcdGetFloat("mingc");
max_gc = ajAcdGetFloat("maxgc");
salt_conc = ajAcdGetFloat("saltconc");
dna_conc = ajAcdGetFloat("dnaconc");
num_ns_accepted = ajAcdGetInt("numnsaccepted");
self_any = ajAcdGetFloat("selfany");
self_end = ajAcdGetFloat("selfend");
max_poly_x = ajAcdGetInt("maxpolyx");
AJCNEW0(pipeto,2);
AJCNEW0(pipefrom,2);
/* Sequence Quality */
/* these are not (yet) implemented */
/*
sequence_quality = ajAcdGetInfile("sequencequality");
min_quality = ajAcdGetInt("minquality");
min_end_quality = ajAcdGetInt("minendquality");
quality_range_min = ajAcdGetInt("qualityrangemin");
quality_range_max = ajAcdGetInt("qualityrangemax");
*/
/* Product details */
product_opt_size = ajAcdGetInt("psizeopt");
product_size_range = ajAcdGetRange("prange");
product_opt_tm = ajAcdGetFloat("ptmopt");
product_min_tm = ajAcdGetFloat("ptmmin");
product_max_tm = ajAcdGetFloat("ptmmax");
/* Objective Function Penalty Weights for Primers */
max_end_stability = ajAcdGetFloat("maxendstability");
/* these are not (yet) implemented */
/*
inside_penalty = ajAcdGetFloat("insidepenalty");
outside_penalty = ajAcdGetFloat("outsidepenalty");
*/
/* Primer penalties */
/* these are not (yet) implemented */
/* Internal Oligo "Sequence" Input Tags */
internal_oligo_excluded_region = ajAcdGetRange("oexcludedregion");
internal_oligo_input = ajAcdGetString("oligoinput");
/* Internal Oligo "Global" Input Tags */
internal_oligo_opt_size = ajAcdGetInt("osizeopt");
internal_oligo_min_size = ajAcdGetInt("ominsize");
internal_oligo_max_size = ajAcdGetInt("omaxsize");
internal_oligo_opt_tm = ajAcdGetFloat("otmopt");
internal_oligo_min_tm = ajAcdGetFloat("otmmin");
internal_oligo_max_tm = ajAcdGetFloat("otmmax");
internal_oligo_opt_gc_percent = ajAcdGetFloat("ogcopt");
internal_oligo_min_gc = ajAcdGetFloat("ogcmin");
internal_oligo_max_gc = ajAcdGetFloat("ogcmax");
internal_oligo_salt_conc = ajAcdGetFloat("osaltconc");
internal_oligo_dna_conc = ajAcdGetFloat("odnaconc");
internal_oligo_self_any = ajAcdGetFloat("oanyself");
internal_oligo_self_end = ajAcdGetFloat("oendself");
internal_oligo_max_poly_x = ajAcdGetInt("opolyxmax");
internal_oligo_mishyb_library = ajAcdGetInfile("mishyblibraryfile");
internal_oligo_max_mishyb = ajAcdGetFloat("omishybmax");
/*
internal_oligo_min_quality = ajAcdGetInt("oligominquality");
*/
/* Internal Oligo penalties */
/* these are not (yet) implemented */
/* EMBOSS-wrapper-specific stuff */
outfile = ajAcdGetOutfile("outfile");
ajStrRemoveWhite(&left_input);
ajStrRemoveWhite(&right_input);
/*
** OK - we will now try to do a separate fork-exec for each sequence.
*/
result = ajStrNew();
while(ajSeqallNext(sequence, &seq))
{
program = ajAcdGetpathC("primer3_core");
if(!ajSysExecRedirectC(ajStrGetPtr(program),&pipeto,&pipefrom))
ajFatal("eprimer3: Could not exec primer3_core");
stream = eprimer3_start_write(pipeto[1]);
/* send primer3 Primer "Global" parameters */
eprimer3_send_bool(stream, "PRIMER_EXPLAIN_FLAG", explain_flag);
eprimer3_send_bool(stream, "PRIMER_FILE_FLAG", file_flag);
if(do_hybrid)
{
if(!ajStrCmpC(task[0], "1"))
ajStrAssignC(&taskstr, "pick_pcr_primers_and_hyb_probe");
else if(!ajStrCmpC(task[0], "2"))
ajStrAssignC(&taskstr, "pick_left_only");
else if(!ajStrCmpC(task[0], "3"))
ajStrAssignC(&taskstr, "pick_right_only");
else if(!ajStrCmpC(task[0], "4"))
ajStrAssignC(&taskstr, "pick_hyb_probe_only");
if (!do_primer)
ajStrAssignC(&taskstr, "pick_hyb_probe_only");
}
else
{
if(!ajStrCmpC(task[0], "1"))
ajStrAssignC(&taskstr, "pick_pcr_primers");
else if(!ajStrCmpC(task[0], "2"))
ajStrAssignC(&taskstr, "pick_left_only");
else if(!ajStrCmpC(task[0], "3"))
ajStrAssignC(&taskstr, "pick_right_only");
else if(!ajStrCmpC(task[0], "4"))
ajStrAssignC(&taskstr, "pick_hyb_probe_only");
}
eprimer3_send_string(stream, "PRIMER_TASK", taskstr);
eprimer3_send_int(stream, "PRIMER_NUM_RETURN", num_return);
eprimer3_send_int(stream, "PRIMER_FIRST_BASE_INDEX",
first_base_index);
eprimer3_send_bool(stream, "PRIMER_PICK_ANYWAY", pick_anyway);
/* mispriming library may not have been specified */
if(mispriming_library)
eprimer3_send_stringC(stream, "PRIMER_MISPRIMING_LIBRARY",
ajFileGetPrintnameC(mispriming_library));
eprimer3_send_float(stream, "PRIMER_MAX_MISPRIMING",
max_mispriming);
eprimer3_send_float(stream, "PRIMER_PAIR_MAX_MISPRIMING",
pair_max_mispriming);
eprimer3_send_int(stream, "PRIMER_GC_CLAMP", gc_clamp);
eprimer3_send_int(stream, "PRIMER_OPT_SIZE", opt_size);
eprimer3_send_int(stream, "PRIMER_MIN_SIZE", min_size);
eprimer3_send_int(stream, "PRIMER_MAX_SIZE", max_size);
eprimer3_send_float(stream, "PRIMER_OPT_TM", opt_tm);
eprimer3_send_float(stream, "PRIMER_MIN_TM", min_tm);
eprimer3_send_float(stream, "PRIMER_MAX_TM", max_tm);
eprimer3_send_float(stream, "PRIMER_MAX_DIFF_TM", max_diff_tm);
eprimer3_send_float(stream, "PRIMER_OPT_GC_PERCENT",
opt_gc_percent);
eprimer3_send_float(stream, "PRIMER_MIN_GC", min_gc);
eprimer3_send_float(stream, "PRIMER_MAX_GC", max_gc);
eprimer3_send_float(stream, "PRIMER_SALT_CONC", salt_conc);
eprimer3_send_float(stream, "PRIMER_DNA_CONC", dna_conc);
eprimer3_send_int(stream, "PRIMER_NUM_NS_ACCEPTED",
num_ns_accepted);
eprimer3_send_float(stream, "PRIMER_SELF_ANY", self_any);
eprimer3_send_float(stream, "PRIMER_SELF_END", self_end);
eprimer3_send_int(stream, "PRIMER_MAX_POLY_X", max_poly_x);
eprimer3_send_int(stream, "PRIMER_PRODUCT_OPT_SIZE",
product_opt_size);
eprimer3_send_range2(stream, "PRIMER_PRODUCT_SIZE_RANGE",
product_size_range);
eprimer3_send_float(stream, "PRIMER_PRODUCT_OPT_TM",
product_opt_tm);
eprimer3_send_float(stream, "PRIMER_PRODUCT_MIN_TM",
product_min_tm);
eprimer3_send_float(stream, "PRIMER_PRODUCT_MAX_TM",
product_max_tm);
eprimer3_send_float(stream, "PRIMER_MAX_END_STABILITY",
max_end_stability);
/* send primer3 Internal Oligo "Global" parameters */
eprimer3_send_int(stream, "PRIMER_INTERNAL_OLIGO_OPT_SIZE",
internal_oligo_opt_size);
eprimer3_send_int(stream, "PRIMER_INTERNAL_OLIGO_MIN_SIZE",
internal_oligo_min_size);
eprimer3_send_int(stream, "PRIMER_INTERNAL_OLIGO_MAX_SIZE",
internal_oligo_max_size);
eprimer3_send_float(stream, "PRIMER_INTERNAL_OLIGO_OPT_TM",
internal_oligo_opt_tm);
eprimer3_send_float(stream, "PRIMER_INTERNAL_OLIGO_MIN_TM",
internal_oligo_min_tm);
eprimer3_send_float(stream, "PRIMER_INTERNAL_OLIGO_MAX_TM",
internal_oligo_max_tm);
eprimer3_send_float(stream, "PRIMER_INTERNAL_OLIGO_OPT_GC_PERCENT",
internal_oligo_opt_gc_percent);
eprimer3_send_float(stream, "PRIMER_INTERNAL_OLIGO_MIN_GC",
internal_oligo_min_gc);
eprimer3_send_float(stream, "PRIMER_INTERNAL_OLIGO_MAX_GC",
internal_oligo_max_gc);
eprimer3_send_float(stream, "PRIMER_INTERNAL_OLIGO_SALT_CONC",
internal_oligo_salt_conc);
eprimer3_send_float(stream, "PRIMER_INTERNAL_OLIGO_DNA_CONC",
internal_oligo_dna_conc);
eprimer3_send_float(stream, "PRIMER_INTERNAL_OLIGO_SELF_ANY",
internal_oligo_self_any);
eprimer3_send_float(stream, "PRIMER_INTERNAL_OLIGO_SELF_END",
internal_oligo_self_end);
eprimer3_send_int(stream, "PRIMER_INTERNAL_OLIGO_MAX_POLY_X",
internal_oligo_max_poly_x);
/*
** internal oligo mishybridising library may not have been
** specified
*/
if(internal_oligo_mishyb_library)
eprimer3_send_stringC(stream,
"PRIMER_INTERNAL_OLIGO_MISHYB_LIBRARY",
ajFileGetPrintnameC(internal_oligo_mishyb_library));
eprimer3_send_float(stream, "PRIMER_INTERNAL_OLIGO_MAX_MISHYB",
internal_oligo_max_mishyb);
/*
** Start sequence-specific stuff
*/
begin = ajSeqallGetseqBegin(sequence) - 1;
end = ajSeqallGetseqEnd(sequence) - 1;
strand = ajSeqGetSeqCopyS(seq);
ajStrFmtUpper(&strand);
ajStrAssignSubC(&substr,ajStrGetPtr(strand), begin, end);
/* send flags to turn on using optimal product size */
eprimer3_send_float(stream, "PRIMER_PAIR_WT_PRODUCT_SIZE_GT",
(float)0.05);
eprimer3_send_float(stream, "PRIMER_PAIR_WT_PRODUCT_SIZE_LT",
(float)0.05);
/* send primer3 Primer "Sequence" parameters */
eprimer3_send_string(stream, "SEQUENCE", substr);
/* if no ID name, use the USA */
if(ajStrMatchC(ajSeqGetNameS(seq),""))
eprimer3_send_string(stream, "PRIMER_SEQUENCE_ID",
ajSeqGetUsaS(seq));
else
eprimer3_send_string(stream, "PRIMER_SEQUENCE_ID",
ajSeqGetNameS(seq));
eprimer3_send_range(stream, "INCLUDED_REGION", included_region,
begin);
eprimer3_send_range(stream, "TARGET", target, begin);
eprimer3_send_range(stream, "EXCLUDED_REGION", excluded_region,
begin);
eprimer3_send_string(stream, "PRIMER_LEFT_INPUT", left_input);
eprimer3_send_string(stream, "PRIMER_RIGHT_INPUT", right_input);
/* send primer3 Internal Oligo "Sequence" parameters */
eprimer3_send_range(stream,
"PRIMER_INTERNAL_OLIGO_EXCLUDED_REGION",
internal_oligo_excluded_region, begin);
eprimer3_send_string(stream, "PRIMER_INTERNAL_OLIGO_INPUT",
internal_oligo_input);
/* end the primer3 input sequence record with a '=' */
eprimer3_send_end(stream);
/* and close the ouput pipe stream */
eprimer3_end_write(stream);
/* read the primer3 output */
eprimer3_read(pipefrom[0], &result);
eprimer3_report(outfile, result, num_return, begin);
ajStrSetClear(&result);
#ifndef WIN32
close(pipeto[1]);
close(pipefrom[0]);
#endif
} /* end of sequence loop */
ajStrDel(&result);
ajSeqDel(&seq);
ajStrDel(&strand);
ajStrDel(&substr);
ajFileClose(&outfile);
ajStrDel(&taskstr);
ajStrDelarray(&task);
ajSeqallDel(&sequence);
ajSeqDel(&seq);
ajRangeDel(&included_region);
ajRangeDel(&target);
ajRangeDel(&excluded_region);
ajRangeDel(&product_size_range);
ajRangeDel(&internal_oligo_excluded_region);
ajStrDel(&left_input);
ajStrDel(&right_input);
ajStrDel(&internal_oligo_input);
AJFREE(pipeto);
AJFREE(pipefrom);
ajFileClose(&mispriming_library);
embExit();
return 0;
}
int main(int argc, char **argv)
{
EmbPBtreeEntry entry = NULL;
AjPStr dbname = NULL;
AjPStr dbrs = NULL;
AjPStr release = NULL;
AjPStr datestr = NULL;
AjBool statistics;
AjBool compressed;
AjPStr directory;
AjPStr indexdir;
AjPStr filename;
AjPStr exclude;
AjPStr dbtype = NULL;
AjPFile outf = NULL;
AjPStr *fieldarray = NULL;
ajint nfields;
ajint nfiles;
AjPStr tmpstr = NULL;
AjPStr thysfile = NULL;
ajint i;
AjPFile inf = NULL;
AjPStr word = NULL;
AjPBtId idobj = NULL;
AjPBtPri priobj = NULL;
AjPBtHybrid hyb = NULL;
ajulong nentries = 0L;
ajulong ientries = 0L;
AjPTime starttime = NULL;
AjPTime begintime = NULL;
AjPTime nowtime = NULL;
ajlong startclock = 0;
ajlong beginclock = 0;
ajlong nowclock = 0;
ajulong idcache=0L, idread = 0L, idwrite = 0L, idsize= 0L;
ajulong accache=0L, acread = 0L, acwrite = 0L, acsize= 0L;
ajulong svcache=0L, svread = 0L, svwrite = 0L, svsize= 0L;
ajulong kwcache=0L, kwread = 0L, kwwrite = 0L, kwsize= 0L;
ajulong decache=0L, deread = 0L, dewrite = 0L, desize= 0L;
ajulong txcache=0L, txread = 0L, txwrite = 0L, txsize= 0L;
double tdiff = 0.0;
ajint days = 0;
ajint hours = 0;
ajint mins = 0;
embInit("dbxflat", argc, argv);
dbtype = ajAcdGetListSingle("idformat");
fieldarray = ajAcdGetList("fields");
directory = ajAcdGetDirectoryName("directory");
outf = ajAcdGetOutfile("outfile");
indexdir = ajAcdGetOutdirName("indexoutdir");
filename = ajAcdGetString("filenames");
exclude = ajAcdGetString("exclude");
dbname = ajAcdGetString("dbname");
dbrs = ajAcdGetString("dbresource");
release = ajAcdGetString("release");
datestr = ajAcdGetString("date");
statistics = ajAcdGetBoolean("statistics");
compressed = ajAcdGetBoolean("compressed");
entry = embBtreeEntryNew();
if(compressed)
embBtreeEntrySetCompressed(entry);
tmpstr = ajStrNew();
idobj = ajBtreeIdNew();
priobj = ajBtreePriNew();
hyb = ajBtreeHybNew();
nfields = embBtreeSetFields(entry,fieldarray);
embBtreeSetDbInfo(entry,dbname,dbrs,datestr,release,dbtype,directory,
indexdir);
for(i=0; i< nfields; i++)
{
if(ajStrMatchC(fieldarray[i], "acc"))
{
accfield = embBtreeGetFieldS(entry, fieldarray[i]);
if(compressed)
embBtreeFieldSetCompressed(accfield);
}
else if(ajStrMatchC(fieldarray[i], "sv"))
{
svfield = embBtreeGetFieldS(entry, fieldarray[i]);
if(compressed)
embBtreeFieldSetCompressed(svfield);
}
else if(ajStrMatchC(fieldarray[i], "des"))
{
desfield = embBtreeGetFieldS(entry, fieldarray[i]);
if(compressed)
embBtreeFieldSetCompressed(desfield);
}
else if(ajStrMatchC(fieldarray[i], "key"))
{
keyfield = embBtreeGetFieldS(entry, fieldarray[i]);
if(compressed)
embBtreeFieldSetCompressed(keyfield);
}
else if(ajStrMatchC(fieldarray[i], "org"))
{
orgfield = embBtreeGetFieldS(entry, fieldarray[i]);
if(compressed)
embBtreeFieldSetCompressed(orgfield);
}
else if(!ajStrMatchC(fieldarray[i], "id"))
ajErr("Unknown field '%S' specified for indexing", fieldarray[i]);
}
embBtreeGetRsInfo(entry);
nfiles = embBtreeGetFiles(entry,directory,filename,exclude);
if(!nfiles)
ajDie("No input files in '%S' matched filename '%S'",
directory, filename);
embBtreeWriteEntryFile(entry);
embBtreeOpenCaches(entry);
starttime = ajTimeNewToday();
ajFmtPrintF(outf, "Processing directory: %S\n", directory);
for(i=0;i<nfiles;++i)
{
begintime = ajTimeNewToday();
beginclock = ajClockNow();
ajListPop(entry->files,(void **)&thysfile);
ajListPushAppend(entry->files,(void *)thysfile);
ajFmtPrintS(&tmpstr,"%S%S",entry->directory,thysfile);
if(!(inf=ajFileNewInNameS(tmpstr)))
ajFatal("Cannot open input file %S\n",tmpstr);
ajFilenameTrimPath(&tmpstr);
ajFmtPrintF(outf,"Processing file: %S",tmpstr);
ientries = 0L;
while(dbxflat_NextEntry(entry,inf))
{
++ientries;
if(entry->do_id)
{
if(ajStrGetLen(entry->id) > entry->idlen)
{
if(ajStrGetLen(entry->id) > maxidlen)
{
ajWarn("id '%S' too long, truncating to idlen %d",
entry->id, entry->idlen);
maxidlen = ajStrGetLen(entry->id);
}
idtrunc++;
ajStrKeepRange(&entry->id,0,entry->idlen-1);
}
ajStrFmtLower(&entry->id);
ajStrAssignS(&hyb->key1,entry->id);
hyb->dbno = i;
hyb->offset = entry->fpos;
hyb->dups = 0;
ajBtreeHybInsertId(entry->idcache,hyb);
++idtot;
}
if(accfield)
{
while(ajListPop(accfield->data,(void **)&word))
{
ajStrFmtLower(&word);
ajStrAssignS(&hyb->key1,word);
hyb->dbno = i;
hyb->offset = entry->fpos;
hyb->dups = 0;
ajBtreeHybInsertId(accfield->cache,hyb);
++acctot;
ajStrDel(&word);
}
}
if(svfield)
{
while(ajListPop(svfield->data,(void **)&word))
{
ajStrFmtLower(&word);
ajStrAssignS(&hyb->key1,word);
hyb->dbno = i;
hyb->offset = entry->fpos;
hyb->dups = 0;
ajBtreeHybInsertId(svfield->cache,hyb);
++svtot;
ajStrDel(&word);
}
}
if(keyfield)
{
while(ajListPop(keyfield->data,(void **)&word))
{
ajStrFmtLower(&word);
ajStrAssignS(&priobj->id,entry->id);
ajStrAssignS(&priobj->keyword,word);
priobj->treeblock = 0;
ajBtreeInsertKeyword(keyfield->cache, priobj);
++keytot;
ajStrDel(&word);
}
}
if(desfield)
{
while(ajListPop(desfield->data,(void **)&word))
{
ajStrFmtLower(&word);
ajStrAssignS(&priobj->id,entry->id);
ajStrAssignS(&priobj->keyword,word);
priobj->treeblock = 0;
if(ajBtreeInsertKeyword(desfield->cache, priobj))
++destot;
ajStrDel(&word);
}
}
if(orgfield)
{
while(ajListPop(orgfield->data,(void **)&word))
{
ajStrFmtLower(&word);
ajStrAssignS(&priobj->id,entry->id);
ajStrAssignS(&priobj->keyword,word);
priobj->treeblock = 0;
ajBtreeInsertKeyword(orgfield->cache, priobj);
++orgtot;
ajStrDel(&word);
}
}
}
ajFileClose(&inf);
nentries += ientries;
nowtime = ajTimeNewToday();
nowclock = ajClockNow();
ajFmtPrintF(outf, " entries: %Lu (%Lu) time: %.1f/%.1fs (%.1f/%.1fs)\n",
nentries, ientries,
ajClockDiff(startclock,nowclock),
ajTimeDiff(starttime, nowtime),
ajClockDiff(beginclock,nowclock),
ajTimeDiff(begintime, nowtime));
if(statistics)
{
if(entry->do_id)
ajBtreeCacheStatsOut(outf, entry->idcache,
&idcache, &idread, &idwrite, &idsize);
if(accfield)
ajBtreeCacheStatsOut(outf, accfield->cache,
&accache, &acread, &acwrite, &acsize);
if(svfield)
ajBtreeCacheStatsOut(outf, svfield->cache,
&svcache, &svread, &svwrite, &svsize);
if(keyfield)
ajBtreeCacheStatsOut(outf, keyfield->cache,
&kwcache, &kwread, &kwwrite, &kwsize);
if(desfield)
ajBtreeCacheStatsOut(outf, desfield->cache,
&decache, &deread, &dewrite, &desize);
if(orgfield)
ajBtreeCacheStatsOut(outf, orgfield->cache,
&txcache, &txread, &txwrite, &txsize);
}
ajTimeDel(&begintime);
ajTimeDel(&nowtime);
}
embBtreeDumpParameters(entry);
embBtreeCloseCaches(entry);
nowtime = ajTimeNewToday();
tdiff = ajTimeDiff(starttime, nowtime);
days = (ajint) (tdiff/(24.0*3600.0));
tdiff -= (24.0*3600.0)*(double)days;
hours = (ajint) (tdiff/3600.0);
tdiff -= 3600.0*(double)hours;
mins = (ajint) (tdiff/60.0);
tdiff -= 60.0 * (double) mins;
if(days)
ajFmtPrintF(outf, "Total time: %d %02d:%02d:%04.1f\n",
days, hours, mins, tdiff);
else if (hours)
ajFmtPrintF(outf, "Total time: %d:%02d:%04.1f\n",
hours, mins, tdiff);
else
ajFmtPrintF(outf, "Total time: %d:%04.1f\n",
mins, tdiff);
ajTimeDel(&nowtime);
ajTimeDel(&starttime);
if(maxidlen)
{
ajFmtPrintF(outf,
"Resource idlen truncated %u IDs. "
"Maximum ID length was %u.",
idtrunc, maxidlen);
ajWarn("Resource idlen truncated %u IDs. Maximum ID length was %u.",
idtrunc, maxidlen);
}
ajFileClose(&outf);
embBtreeEntryDel(&entry);
ajStrDel(&tmpstr);
ajStrDel(&filename);
ajStrDel(&exclude);
ajStrDel(&dbname);
ajStrDel(&dbrs);
ajStrDel(&release);
ajStrDel(&datestr);
ajStrDel(&directory);
ajStrDel(&indexdir);
ajStrDel(&dbtype);
nfields = 0;
while(fieldarray[nfields])
ajStrDel(&fieldarray[nfields++]);
AJFREE(fieldarray);
ajBtreeIdDel(&idobj);
ajBtreePriDel(&priobj);
ajBtreeHybDel(&hyb);
ajRegFree(&dbxflat_wrdexp);
embExit();
return 0;
}
int main(int argc, char **argv)
{
EmbPBtreeEntry entry = NULL;
AjPStr dbname = NULL;
AjPStr dbrs = NULL;
AjPStr release = NULL;
AjPStr datestr = NULL;
AjPStr directory;
AjPStr indexdir;
AjPStr filename;
AjPStr exclude;
AjPStr dbtype = NULL;
AjPFile outf = NULL;
AjPStr *fieldarray = NULL;
ajint nfields;
ajint nfiles;
AjPStr tmpstr = NULL;
AjPStr thysfile = NULL;
ajint i;
AjPFile inf = NULL;
AjPStr word = NULL;
AjPBtId idobj = NULL;
AjPBtPri priobj = NULL;
AjPBtHybrid hyb = NULL;
ajulong nentries = 0L;
ajulong ientries = 0L;
AjPTime starttime = NULL;
AjPTime begintime = NULL;
AjPTime nowtime = NULL;
ajlong startclock = 0;
ajlong beginclock = 0;
ajlong nowclock = 0;
embInit("dbxflat", argc, argv);
dbtype = ajAcdGetListSingle("idformat");
fieldarray = ajAcdGetList("fields");
directory = ajAcdGetDirectoryName("directory");
outf = ajAcdGetOutfile("outfile");
indexdir = ajAcdGetOutdirName("indexoutdir");
filename = ajAcdGetString("filenames");
exclude = ajAcdGetString("exclude");
dbname = ajAcdGetString("dbname");
dbrs = ajAcdGetString("dbresource");
release = ajAcdGetString("release");
datestr = ajAcdGetString("date");
entry = embBtreeEntryNew();
tmpstr = ajStrNew();
idobj = ajBtreeIdNew();
priobj = ajBtreePriNew();
hyb = ajBtreeHybNew();
nfields = embBtreeSetFields(entry,fieldarray);
embBtreeSetDbInfo(entry,dbname,dbrs,datestr,release,dbtype,directory,
indexdir);
embBtreeGetRsInfo(entry);
nfiles = embBtreeGetFiles(entry,directory,filename,exclude);
embBtreeWriteEntryFile(entry);
embBtreeOpenCaches(entry);
starttime = ajTimeNewToday();
ajFmtPrintF(outf, "Processing directory: %S\n", directory);
for(i=0;i<nfiles;++i)
{
begintime = ajTimeNewToday();
beginclock = ajClockNow();
ajListPop(entry->files,(void **)&thysfile);
ajListPushAppend(entry->files,(void *)thysfile);
ajFmtPrintS(&tmpstr,"%S%S",entry->directory,thysfile);
if(!(inf=ajFileNewInNameS(tmpstr)))
ajFatal("Cannot open input file %S\n",tmpstr);
ajFilenameTrimPath(&tmpstr);
ajFmtPrintF(outf,"Processing file: %S",tmpstr);
ientries = 0L;
while(dbxflat_NextEntry(entry,inf))
{
++ientries;
if(entry->do_id)
{
if(ajStrGetLen(entry->id) > entry->idlen)
{
if(ajStrGetLen(entry->id) > maxidlen)
{
ajWarn("id '%S' too long, truncating to idlen %d",
entry->id, entry->idlen);
maxidlen = ajStrGetLen(entry->id);
}
idtrunc++;
ajStrKeepRange(&entry->id,0,entry->idlen-1);
}
ajStrFmtLower(&entry->id);
ajStrAssignS(&hyb->key1,entry->id);
hyb->dbno = i;
hyb->offset = entry->fpos;
hyb->dups = 0;
ajBtreeHybInsertId(entry->idcache,hyb);
}
if(entry->do_accession)
{
while(ajListPop(entry->ac,(void **)&word))
{
ajStrFmtLower(&word);
ajStrAssignS(&hyb->key1,word);
hyb->dbno = i;
hyb->offset = entry->fpos;
hyb->dups = 0;
ajBtreeHybInsertId(entry->accache,hyb);
ajStrDel(&word);
}
}
if(entry->do_sv)
{
while(ajListPop(entry->sv,(void **)&word))
{
ajStrFmtLower(&word);
ajStrAssignS(&hyb->key1,word);
hyb->dbno = i;
hyb->offset = entry->fpos;
hyb->dups = 0;
ajBtreeHybInsertId(entry->svcache,hyb);
ajStrDel(&word);
}
}
if(entry->do_keyword)
{
while(ajListPop(entry->kw,(void **)&word))
{
ajStrFmtLower(&word);
ajStrAssignS(&priobj->id,entry->id);
ajStrAssignS(&priobj->keyword,word);
priobj->treeblock = 0;
ajBtreeInsertKeyword(entry->kwcache, priobj);
ajStrDel(&word);
}
}
if(entry->do_description)
{
while(ajListPop(entry->de,(void **)&word))
{
ajStrFmtLower(&word);
ajStrAssignS(&priobj->id,entry->id);
ajStrAssignS(&priobj->keyword,word);
priobj->treeblock = 0;
ajBtreeInsertKeyword(entry->decache, priobj);
ajStrDel(&word);
}
}
if(entry->do_taxonomy)
{
while(ajListPop(entry->tx,(void **)&word))
{
ajStrFmtLower(&word);
ajStrAssignS(&priobj->id,entry->id);
ajStrAssignS(&priobj->keyword,word);
priobj->treeblock = 0;
ajBtreeInsertKeyword(entry->txcache, priobj);
ajStrDel(&word);
}
}
}
ajFileClose(&inf);
nentries += ientries;
nowtime = ajTimeNewToday();
nowclock = ajClockNow();
ajFmtPrintF(outf, " entries: %Lu (%Lu) time: %.1f/%.1fs (%.1f/%.1fs)\n",
nentries, ientries,
ajClockDiff(startclock,nowclock),
ajTimeDiff(starttime, nowtime),
ajClockDiff(beginclock,nowclock),
ajTimeDiff(begintime, nowtime));
ajTimeDel(&begintime);
ajTimeDel(&nowtime);
}
embBtreeDumpParameters(entry);
embBtreeCloseCaches(entry);
nowtime = ajTimeNewToday();
ajFmtPrintF(outf, "Total time: %.1fs\n", ajTimeDiff(starttime, nowtime));
ajTimeDel(&nowtime);
ajTimeDel(&starttime);
if(maxidlen)
{
ajFmtPrintF(outf,
"Resource idlen truncated %u IDs. "
"Maximum ID length was %u.",
idtrunc, maxidlen);
ajWarn("Resource idlen truncated %u IDs. Maximum ID length was %u.",
idtrunc, maxidlen);
}
ajFileClose(&outf);
embBtreeEntryDel(&entry);
ajStrDel(&tmpstr);
ajStrDel(&filename);
ajStrDel(&exclude);
ajStrDel(&dbname);
ajStrDel(&dbrs);
ajStrDel(&release);
ajStrDel(&datestr);
ajStrDel(&directory);
ajStrDel(&indexdir);
ajStrDel(&dbtype);
nfields = 0;
while(fieldarray[nfields])
ajStrDel(&fieldarray[nfields++]);
AJFREE(fieldarray);
ajBtreeIdDel(&idobj);
ajBtreePriDel(&priobj);
ajBtreeHybDel(&hyb);
ajRegFree(&dbxflat_wrdexp);
embExit();
return 0;
}
int main(ajint argc, char **argv)
{
AjPList ccfin = NULL; /* List of CCF (input) files. */
AjPDir pdbin = NULL; /* Path of pdb input files. */
AjPStr pdbprefix = NULL; /* Prefix of pdb input files. */
AjPStr pdb_name = NULL; /* Full name (path/name/extension) of
pdb format input file. */
AjPDirout ccfout = NULL; /* Path of coordinate output file. */
AjPStr randomname = NULL; /* Name for temp file tempf. */
AjPStr ccf_this = NULL;
AjPStr exec = NULL;
AjPStr naccess_str = NULL;
AjPStr line = NULL;
AjPStr syscmd = NULL; /* Command line arguments. */
AjPStr *mode = NULL; /* Mode of operation from acd. */
AjPFile errf = NULL; /* pdbplus error file pointer. */
AjPFile serrf = NULL; /* stride error file pointer. */
AjPFile nerrf = NULL; /* stride error file pointer. */
AjPFile tempf = NULL; /* Temp file for holding STRIDE output. */
AjPFile ccf_inf = NULL; /* Protein coordinate input file. */
AjPFile ccf_outf = NULL; /* Protein coordinate output file. */
AjIList iter = NULL;
AjBool done_naccess= ajFalse;
AjBool done_stride = ajFalse;
AjBool found = ajFalse;
AjPResidue temp_res = NULL; /* Pointer to Residue object. */
AjPPdb pdb_old = NULL; /* Pointer to PDB object - without new
stride elements. */
AjPPdb pdb = NULL; /* Pointer to PDB object. */
ajint idn = 0; /* Chain identifier as a number (1,2,...) */
ajint chain_num = 0; /* Chain identifier index (0,1,...). */
ajint tS = 0; /* User-defined threshold size for SSEs. */
ajint nostride = 0; /* No. times stride failed */
ajint nonaccess = 0; /* No. times naccess failed */
ajint nofile = 0; /* No. times of file error */
/* Variables for each item that will be parsed from the ASG line. */
AjPStr res = NULL; /* Residue id from STRIDE ASG line (ALA etc). */
AjPStr res_num = NULL; /* PDB residue number from STRIDE ASG line. */
char pcid = ' '; /* Protein chain identifier from STRIDE or
NACESS output (A,B, etc). */
char ss = ' '; /* One-letter secondary structure code from
STRIDE ASG line. */
float ph = 0.0; /* Phi angle from STRIDE ASG line. */
float ps = 0.0; /* Psi angle from STRIDE ASG line. */
float sa = 0.0; /* Residue solvent accessible area from STRIDE
ASG line. */
float f1 = 0;
float f2 = 0;
float f3 = 0;
float f4 = 0;
float f5 = 0;
float f6 = 0;
float f7 = 0;
float f8 = 0;
float f9 = 0;
float f10 = 0;
/* Allocate strings; this section is used for variables that are
allocated once only. */
pdb_name = ajStrNew();
res = ajStrNew();
res_num = ajStrNew();
randomname = ajStrNew();
syscmd = ajStrNew();
line = ajStrNew();
naccess_str = ajStrNew();
exec = ajStrNew();
/* Read data from acd. */
embInitPV("pdbplus",argc,argv,"STRUCTURE",VERSION);
ccfin = ajAcdGetDirlist("ccfinpath");
pdbin = ajAcdGetDirectory("pdbindir");
pdbprefix = ajAcdGetString("pdbprefix");
ccfout = ajAcdGetOutdir("ccfoutdir");
mode = ajAcdGetList("mode");
errf = ajAcdGetOutfile("logfile");
if(ajStrGetCharFirst(*mode) != '2')
serrf = ajAcdGetOutfile("slogfile");
if(ajStrGetCharFirst(*mode) != '1')
nerrf = ajAcdGetOutfile("nlogfile");
tS = ajAcdGetInt("thresholdsize");
ajRandomSeed();
ajFilenameSetTempname(&randomname);
/*
** Start of main application loop.
** Process each PDB/ protein coordinate file (EMBL format) in turn.
*/
while(ajListPop(ccfin,(void **)&ccf_this))
{
/* Open protein coordinate file. If it cannot be opened, write a
message to the error file, delete ccf_this and continue. */
if((ccf_inf = ajFileNewInNameS(ccf_this)) == NULL)
{
ajWarn("%s%S\n//\n",
"clean coordinate file not found: ", ccf_this);
ajFmtPrintF(errf, "%s%S\n//\n",
"clean coordinate file not found: ", ccf_this);
ajStrDel(&ccf_this);
nofile++;
continue;
}
ajFmtPrint("Processing %S\n", ccf_this);
fflush(stdout);
/* Parse protein coordinate data (from clean format file) into
AjPPdb object. ajPdbReadAllModelsNew will create the AjPPdb object. */
if(!(pdb_old=ajPdbReadAllModelsNew(ccf_inf)))
{
ajWarn("ERROR Clean coordinate file read"
"error: %S\n//\n", ccf_this);
ajFmtPrintF(errf, "ERROR Clean coordinate file read"
"error: %S\n//\n", ccf_this);
ajFileClose(&ccf_inf);
ajStrDel(&ccf_this);
nofile++;
continue;
}
ajFileClose(&ccf_inf);
ajPdbCopy(&pdb, pdb_old);
ajPdbDel(&pdb_old);
/* Construct name of corresponding PDB file.
NACCESS does *not* generate an output file if the path is './' e.g.
naccess ./1rbp.ent , therefore replace './' with null. */
ajStrAssignS(&pdb_name, ajDirGetPath(pdbin));
if(ajStrMatchC(pdb_name, "./") || ajStrMatchC(pdb_name, "."))
ajStrAssignC(&pdb_name, "");
ajStrAppendS(&pdb_name, pdbprefix);
ajStrFmtLower(&pdb->Pdb);
ajStrAppendS(&pdb_name, pdb->Pdb);
ajStrAppendC(&pdb_name, ".");
ajStrAppendS(&pdb_name, ajDirGetExt(pdbin));
/* Check corresponding PDB file exists for reading using ajFileStat. */
if(!(ajFilenameExistsRead(pdb_name)))
{
ajFmtPrintF(errf, "%s%S\n//\n", "PDB file not found: ", pdb_name);
ajWarn("%s%S\n//\n", "PDB file not found: ", pdb_name);
ajStrDel(&ccf_this);
ajPdbDel(&pdb);
nofile++;
continue;
}
if(ajStrGetCharFirst(*mode) != '2')
{
/*
** Create a string containing the STRIDE command line (it needs
** PDB file name & name of temp output file).
** Call STRIDE by using ajSystem.
*/
ajFmtPrintS(&syscmd, "%S %S -f%S >> %s 2>&1",
ajAcdGetpathC("stride"),
pdb_name, randomname, ajFileGetNameC(serrf));
ajFmtPrint("%S %S -f%S >> %s 2>&1\n",
ajAcdGetpathC("stride"),
pdb_name, randomname,ajFileGetNameC(serrf));
system(ajStrGetPtr(syscmd));
/* Open the stride output file */
if (((tempf = ajFileNewInNameS(randomname)) == NULL))
{
ajWarn("%s%S\n//\n",
"no stride output for: ", pdb_name);
ajFmtPrintF(errf, "%s%S\n//\n",
"no stride output for: ", pdb_name);
nostride++;
ajStrDel(&ccf_this);
ajPdbDel(&pdb);
continue;
}
else
ajFmtPrintF(errf, "%s%S\n//\n",
"stride output for: ", pdb_name);
done_stride = ajFalse;
/* Parse STRIDE output from temp output file a line at a time. */
while(ajReadlineTrim(tempf,&line))
{
if(ajStrPrefixC(line,"ASG"))
{
ajFmtScanS(line, "%*S %S %c %S %*d %c %*S %f %f %f %*S",
&res, &pcid, &res_num, &ss, &ph, &ps, &sa);
/*
** Populate pdbplus object with the data from this parsed
** line. This means first identifying the chain, then
** finding the residue.
*/
/* Determine the chain number. ajDmxPdbplusChain does not
recognise '-', so change '-' to '.' */
if (pcid == '-')
pcid = '.';
/* Get chain number from the chain identifier. */
if(!ajPdbChnidToNum(pcid, pdb, &idn))
{
ajWarn("Could not convert chain id %c to chain"
" number in pdb file %S\n//\n",
pcid, pdb_name);
ajFmtPrintF(errf, "Could not convert chain id %c "
"to chain number in pdb file %S\n//\n",
pcid, pdb_name);
continue;
}
/*
** The chain number that will get written starts at 1, but
** we want an index into an array which must start at 0,
** so subtract 1 from the chain number to get the index.
*/
chain_num = idn-1;
/*
** Iiterate through the list of residues in the Pdb object,
** found switches to true when first residue corresponding
** to the line is found.
*/
/* iter = ajListIterNewread(pdb->Chains[chain_num]->Atoms); */
iter = ajListIterNewread(pdb->Chains[chain_num]->Residues);
found = ajFalse;
while((temp_res = (AjPResidue)ajListIterGet(iter)))
{
/* If we have found the residue we want */
if((ajStrMatchS(res_num, temp_res->Pdb) &&
ajStrMatchS(res, temp_res->Id3)))
{
done_stride = ajTrue;
found = ajTrue;
temp_res->eStrideType = ss;
temp_res->Phi = ph;
temp_res->Psi = ps;
temp_res->Area = sa;
}
/* If the matching residue has been processed
move on to next ASG line, next residue. */
else if(found == ajTrue)
break;
else
/* Matching residue not found yet. */
continue;
}
ajListIterDel(&iter);
} /* End of if ASG loop. */
} /* End of while line loop. */
if(done_stride)
ajFmtPrintF(errf, "%s%S\n//\n",
"stride data for: ", pdb_name);
else
{
ajFmtPrintF(errf, "%s%S\n//\n",
"no stride data for: ", pdb_name);
ajWarn("%s%S\n//\n", "no stride data for: ", pdb_name);
nostride++;
}
/* Close STRIDE temp file. & tidy up. */
ajFileClose(&tempf);
/* Remove temporary file (stride output file). */
ajFmtPrintS(&exec, "rm %S", randomname);
ajSysSystem(exec);
/*
** Calculate element serial numbers (eStrideNum)& ammend residue
** objects, count no's of elements and ammend chain object
** (numHelices, num Strands).
*/
pdbplus_sort(pdb, tS);
}
if(ajStrGetCharFirst(*mode) != '1')
{
/*
** Create a string containing the NACCESS command line (it needs
** PDB file name & name of temp output file) & call NACCESS.
** If e.g. /data/structure/pdbfred.ent was parsed and the program
** was run from /stuff, then /stuff/fred.asa and /stuff/fred.rsa
** would be written. These must be deleted once parsed (only
** use the .rsa file here).
*/
ajFmtPrintS(&syscmd, "%S %S >> %s 2>&1",
ajAcdGetpathC("naccess"), pdb_name,
ajFileGetNameC(nerrf));
ajFmtPrint("%S %S >> %s 2>&1\n",
ajAcdGetpathC("naccess"), pdb_name,
ajFileGetNameC(nerrf));
system(ajStrGetPtr(syscmd));
ajStrAssignS(&naccess_str, pdbprefix);
ajStrAppendS(&naccess_str, pdb->Pdb);
ajStrAppendC(&naccess_str, ".rsa");
/* Open the NACCESS output file. */
if (((tempf = ajFileNewInNameS(naccess_str)) == NULL))
{
ajFmtPrintF(errf, "%s%S\n//\n",
"no naccess output for: ", pdb_name);
ajWarn("%s%S\n//\n", "no naccess output for: ", pdb_name);
nonaccess++;
ajStrDel(&ccf_this);
ajPdbDel(&pdb);
continue;
}
else
ajFmtPrintF(errf, "%s%S\n//\n",
"naccess output for: ", pdb_name);
done_naccess = ajFalse;
/* Parse NACCESS output from temp output file a line at a time. */
while(ajReadlineTrim(tempf,&line))
{
if(ajStrPrefixC(line,"RES"))
{
/* Read data from lines. */
if((pcid = line->Ptr[8]) == ' ')
ajFmtScanS(line, "%*S %S %S %f %f %f "
"%f %f %f %f %f %f %f",
&res, &res_num, &f1, &f2, &f3, &f4, &f5,
&f6, &f7, &f8, &f9, &f10);
else
ajFmtScanS(line, "%*S %S %*c %S %f %f "
"%f %f %f %f %f %f %f %f",
&res, &res_num, &f1, &f2, &f3, &f4, &f5,
&f6, &f7, &f8, &f9, &f10);
/* Identify the chain, then finding all the residues
corresponding to the residue. */
/* Get the chain number from the chain identifier. */
if(!ajPdbChnidToNum(pcid, pdb, &idn))
{
ajWarn("Could not convert chain id %c to chain"
" number in pdb file %S\n//\n",
pcid, pdb_name);
ajFmtPrintF(errf, "Could not convert chain id"
" %c to chain number in pdb file %S\n//\n",
pcid, pdb_name);
continue;
}
/*
** Chain number will start at 1, but we want an index
** into an array which must start at 0, so subtract 1
** from the chain number to get the index.
*/
chain_num = idn-1;
/*
** Iiterate through the list of residues in the Pdb object,
** temp_res is an AjPResidue used to point to the current
** residue.
** ajBool found switches to true when first residue
** corresponding to the line is found.
*/
iter = ajListIterNewread(pdb->Chains[chain_num]->Residues);
found = ajFalse;
while((temp_res = (AjPResidue)ajListIterGet(iter)))
{
/* If we have found the residue we want, write the residue
object. */
if((ajStrMatchS(res_num, temp_res->Pdb) &&
ajStrMatchS(res, temp_res->Id3)))
{
found = ajTrue;
done_naccess = ajTrue;
temp_res->all_abs = f1;
temp_res->all_rel = f2;
temp_res->side_abs = f3;
temp_res->side_rel = f4;
temp_res->main_abs = f5;
temp_res->main_rel = f6;
temp_res->npol_abs = f7;
temp_res->npol_rel = f8;
temp_res->pol_abs = f9;
temp_res->pol_rel = f10;
}
/* If the matching residues have all been processed.
move on to next ASG line, next residue. */
else if(found == ajTrue)
break;
else
/* Matching residues not found yet, move on to next
residue. */
continue;
}
ajListIterDel(&iter);
}
}
if(done_naccess)
ajFmtPrintF(errf, "%s%S\n//\n",
"naccess data for: ", pdb_name);
else
{
ajFmtPrintF(errf, "%s%S\n//\n",
"no naccess data for: ", pdb_name);
ajWarn("%s%S\n//\n", "no naccess data for: ", pdb_name);
nonaccess++;
}
/* Remove temporary file (naccess output files). */
ajFileClose(&tempf);
ajFmtPrintS(&exec, "rm %S", naccess_str);
ajSysSystem(exec);
ajStrAssignS(&naccess_str, pdbprefix);
ajStrAppendS(&naccess_str, pdb->Pdb);
ajStrAppendC(&naccess_str, ".asa");
ajFmtPrintS(&exec, "rm %S", naccess_str);
ajSysSystem(exec);
ajStrAssignS(&naccess_str, pdbprefix);
ajStrAppendS(&naccess_str, pdb->Pdb);
ajStrAppendC(&naccess_str, ".log");
ajFmtPrintS(&exec, "rm %S", naccess_str);
ajSysSystem(exec);
}
/* Open CCF (output) file. */
ccf_outf = ajFileNewOutNameDirS(pdb->Pdb, ccfout);
/* Write AjPPdb object to the output file in clean format. */
if(!ajPdbWriteAll(ccf_outf, pdb))
{
ajWarn("%s%S\n//\n","Could not write results file for: ",
pdb->Pdb);
ajFmtPrintF(errf,"%s%S\n//\n","Could not write results file for ",
pdb->Pdb);
}
ajFileClose(&ccf_outf);
ajPdbDel(&pdb);
ajStrDel(&ccf_this);
} /* End of main application loop. */
ajFmtPrint("STRIDE failures: %d\n", nostride);
ajFmtPrint("NACCESS failures: %d\n", nonaccess);
ajFmtPrintF(errf, "\n\nSTRIDE failures: %d\nNACCESS failures: %d\n",
nostride, nonaccess);
ajListFree(&ccfin);
ajDirDel(&pdbin);
ajStrDel(&pdbprefix);
ajStrDel(&pdb_name);
ajDiroutDel(&ccfout);
ajStrDel(&res);
ajStrDel(&res_num);
ajStrDel(&randomname);
ajStrDel(&line);
ajStrDel(&naccess_str);
ajStrDel(&exec);
ajStrDel(&syscmd);
ajFileClose(&errf);
if(ajStrGetCharFirst(*mode) != '2')
ajFileClose(&serrf);
if(ajStrGetCharFirst(*mode) != '1')
ajFileClose(&nerrf);
ajStrDel(&mode[0]);
AJFREE(mode);
ajExit();
return 0;
}
int main(int argc, char **argv)
{
/* Variable declarations */
AjPOutfile outfile = NULL;
AjPStr* ranks = NULL;
AjBool hidden = ajFalse;
AjPTax tax = NULL;
AjPTax taxparent = NULL;
AjPTaxall taxall = NULL;
AjPTaxin taxinparent = NULL;
AjPStr taxqryup = NULL;
AjPTable foundtable = NULL;
const AjPStr taxrank = NULL;
ajuint up;
AjPList uplist = NULL;
ajuint i;
/* ACD processing */
embInit("taxgetrank", argc, argv);
taxall = ajAcdGetTaxonall("taxons");
ranks = ajAcdGetList("rank");
outfile = ajAcdGetOuttaxon("outfile");
hidden = ajAcdGetBoolean("hidden");
for(i=0; ranks[i]; i++)
{
ajStrExchangeKK(&ranks[i], '_', ' ');
}
taxinparent = ajTaxinNew();
taxparent = ajTaxNew();
uplist = ajListNew();
foundtable = ajTablestrNew(600);
while(ajTaxallNext(taxall, &tax))
{
up = ajTaxGetParent(tax);
while (up > 1)
{
ajFmtPrintS(&taxqryup, "%S-id:%u", ajTaxGetDb(tax), up);
ajTaxinQryS(taxinparent, taxqryup);
if(!ajTaxinRead(taxinparent, taxparent))
break;
if(hidden || !ajTaxIsHidden(taxparent))
{
taxrank = ajTaxGetRank(taxparent);
for(i=0; ranks[i]; i++)
{
if(ajStrMatchS(taxrank, ranks[i]))
{
if(!ajTableMatchS(foundtable, taxparent->Id))
{
ajTaxoutWrite(outfile, taxparent);
ajTablePut(foundtable,
ajStrNewS(taxparent->Id),
(void *) 1);
}
}
}
}
up = ajTaxGetParent(taxparent);
}
}
/* Memory clean-up and exit */
ajTaxallDel(&taxall);
ajTaxinDel(&taxinparent);
ajTaxDel(&tax);
ajTaxDel(&taxparent);
ajListFree(&uplist);
ajTablestrFreeKey(&foundtable);
ajStrDel(&taxqryup);
ajStrDelarray(&ranks);
ajOutfileClose(&outfile);
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;
}