static void emira_dolistsingles(AjPStr *cl, AjPTable table)
{
ajuint i;
AjPStr squal = NULL;
AjPStr prefix = NULL;
AjPStr key = NULL;
AjPStr value = NULL;
prefix = ajStrNew();
key = ajStrNew();
i = 0;
while(miralistsingles[i].qname)
{
squal = ajAcdGetListSingle(miralistsingles[i].qname);
ajStrAssignC(&key,miralistsingles[i].qname);
ajStrAssignC(&prefix,"");
value = ajTableFetch(table, key);
if(value)
ajStrAssignS(&prefix,value);
if(!ajStrMatchC(squal,miralistsingles[i].def))
ajFmtPrintAppS(cl," -%S%s=%S",prefix,miralistsingles[i].mname,
squal);
ajStrDel(&squal);
++i;
}
ajStrDel(&key);
ajStrDel(&prefix);
return;
}
int main(int argc, char **argv)
{
AjPSeqall seqall;
AjPSeq a;
AjPSeqout outf;
AjPStr substr;
AjPStr back;
AjPStr gctable;
AjPCod codon = NULL;
ajint gctablenum;
ajint beg;
ajint end;
embInit("backtranambig", argc, argv);
seqall = ajAcdGetSeqall("sequence");
outf = ajAcdGetSeqoutall("outfile");
gctable = ajAcdGetListSingle("table");
ajStrToInt(gctable, &gctablenum);
codon = ajCodNewCodenum(gctablenum);
while(ajSeqallNext(seqall, &a))
{
substr = ajStrNew();
beg = ajSeqGetBegin(a);
end = ajSeqGetEnd(a);
ajStrAssignSubC(&substr,ajSeqGetSeqC(a),beg-1,end-1);
back = ajStrNew();
ajCodBacktranslateAmbig(&back,substr,codon);
ajSeqAssignSeqS (a, back);
ajSeqSetNuc(a);
ajSeqoutWriteSeq(outf,a);
}
ajSeqoutClose(outf);
ajStrDel(&back);
ajStrDel(&substr);
ajSeqoutDel(&outf);
ajCodDel(&codon);
ajStrDel(&gctable);
ajSeqallDel(&seqall);
ajSeqDel(&a);
embExit();
return 0;
}
int main(int argc, char **argv)
{
/* Variable Declarations */
AjPFile inf = NULL;
AjPFile outf = NULL;
AjPStr line = NULL; /* Line from inf */
AjPStr option = NULL;
AjBool doall = AJFALSE;
AjBool doend = AJFALSE;
AjBool doexcess = AJFALSE;
/* ACD File Processing */
embInit("nospace", argc, argv);
inf = ajAcdGetInfile("infile");
outf = ajAcdGetOutfile("outfile");
option = ajAcdGetListSingle("menu");
if(ajStrMatchC(option, "all"))
doall = ajTrue;
else if(ajStrMatchC(option, "end"))
doend = ajTrue;
else if(ajStrMatchC(option, "excess"))
doexcess = ajTrue;
/* Application logic */
line = ajStrNew();
while(ajReadline(inf,&line))
{
if(doall)
ajStrRemoveWhite(&line);
else if(doend)
ajStrTrimWhiteEnd(&line);
else if(doexcess)
ajStrRemoveWhiteExcess(&line);
ajFmtPrintF(outf, "%S\n", line);
}
/* Memory management and exit */
ajFileClose(&inf);
ajFileClose(&outf);
ajStrDel(&line);
ajStrDel(&option);
embExit();
return 0;
}
int getorf_acd(int argc, char **argv) {
AjPSeqout seqout;
AjPSeqall seqall;
AjPStr tablestr;
ajuint minsize;
ajuint maxsize;
AjPStr findstr;
AjBool methionine;
AjBool circular;
AjBool reverse;
ajint around;
embInit("getorf", argc, argv);
seqout = ajAcdGetSeqoutall("outseq");
seqall = ajAcdGetSeqall("sequence");
tablestr = ajAcdGetListSingle("table");
minsize = ajAcdGetInt("minsize");
maxsize = ajAcdGetInt("maxsize");
findstr = ajAcdGetListSingle("find");
methionine = ajAcdGetBoolean("methionine");
circular = ajAcdGetBoolean("circular");
reverse = ajAcdGetBoolean("reverse");
around = ajAcdGetInt("flanking");
getorf(seqout, seqall, tablestr, minsize, maxsize, findstr, methionine, circular, reverse, around);
ajSeqoutClose(seqout);
ajSeqallDel(&seqall);
ajSeqoutDel(&seqout);
ajStrDel(&tablestr);
ajStrDel(&findstr);
embExit();
return 0;
}
int main(int argc, char *argv[])
{
char *start;
char *structure;
char *rstart;
char *str2;
char *line;
int i;
int length;
int l;
int hd;
double energy = 0.;
double kT;
int pf = 0;
int mfe = 0;
int istty;
int repeat;
int found;
AjPFile inf = NULL;
AjPSeq seq = NULL;
AjPFile paramfile = NULL;
AjPFile outf = NULL;
float eT = 0.;
AjBool eGU;
AjBool eclose;
AjBool lonely;
AjBool etloop;
AjPStr eenergy = NULL;
char ewt = '\0';
AjPStr edangles = NULL;
AjPStr method = NULL;
AjPStr ealpha = NULL;
AjBool showfails = ajFalse;
AjBool succeed = ajFalse;
char edangle = '\0';
ajint len;
FILE *fp;
embInitPV("vrnainverse",argc,argv,"VIENNA",VERSION);
inf = ajAcdGetInfile("structuresfile");
seq = ajAcdGetSeq("sequence");
paramfile = ajAcdGetInfile("paramfile");
eT = ajAcdGetFloat("temperature");
eGU = ajAcdGetBoolean("gu");
eclose = ajAcdGetBoolean("closegu");
lonely = ajAcdGetBoolean("lp");
etloop = ajAcdGetBoolean("tetraloop");
eenergy = ajAcdGetListSingle("energy");
edangles = ajAcdGetListSingle("dangles");
method = ajAcdGetListSingle("folding");
ealpha = ajAcdGetString("alphabet");
final_cost = ajAcdGetFloat("final");
repeat = ajAcdGetInt("repeats");
showfails = ajAcdGetBoolean("showfails");
succeed = ajAcdGetBoolean("succeed");
outf = ajAcdGetOutfile("outfile");
do_backtrack = 0;
structure = NULL;
istty = 0;
temperature = (double) eT;
noGU = (eGU) ? 0 : 1;
no_closingGU = (eclose) ? 0 : 1;
noLonelyPairs = (lonely) ? 0 : 1;
tetra_loop = !!etloop;
ewt = *ajStrGetPtr(eenergy);
if(ewt == '0')
energy_set = 0;
else if(ewt == '1')
energy_set = 1;
else if(ewt == '2')
energy_set = 2;
edangle = *ajStrGetPtr(edangles);
if(edangle == '0')
dangles = 0;
else if(edangle == '1')
dangles = 1;
else if(edangle == '2')
dangles = 2;
else if(edangle == '3')
dangles = 3;
if(ajStrMatchC(method,"mp"))
{
mfe = 1;
pf = 1;
}
else if(ajStrMatchC(method,"m"))
{
mfe = 1;
pf = 0;
}
else if(ajStrMatchC(method,"p"))
{
mfe = 0;
pf = 1;
}
len = ajStrGetLen(ealpha);
symbolset = (char *) space(len + 1);
strcpy(symbolset, ajStrGetPtr(ealpha));
for (l = 0; l < len; l++)
symbolset[l] = toupper(symbolset[l]);
inv_verbose = !!showfails;
fp = ajFileGetFileptr(inf);
init_rand();
kT = (temperature+273.15)*1.98717/1000.0;
istty = (isatty(fileno(stdout))&&isatty(fileno(stdin)));
if (paramfile)
read_parameter_file(paramfile);
give_up = succeed;
do {
if ((line = get_line(fp))==NULL) break;
/* read structure, skipping over comment lines */
while ((*line=='*')||(*line=='\0')||(*line=='>'))
{
free(line);
if ((line = get_line(fp))==NULL)
break;
}
/* stop at eof or '@' */
if (line==NULL) break;
if (strcmp(line, "@") == 0)
{
free(line);
break;
}
structure = (char *) space(strlen(line)+1);
/* scanf gets rid of trailing junk */
(void) sscanf(line,"%s",structure);
free(line);
length = (int) strlen(structure);
str2 = (char *) space((unsigned)length+1);
/* now look for a sequence to match the structure */
/*
if ((line = get_line(fp))!=NULL)
if (strcmp(line, "@") == 0)
{
free(line);
break;
}
*/
start = (char *) space((unsigned) length+1);
if(seq)
(void) strncpy(start, ajSeqGetSeqC(seq), length);
if (repeat!=0)
found = repeat;
else
found = 1;
initialize_fold(length);
rstart = (char *) space((unsigned)length+1);
while(found>0)
{
char *string;
string = (char *) space((unsigned)length+1);
strcpy(string, start);
for (i=0; i<length; i++)
{
/* lower case characters are kept fixed, any other character
not in symbolset is replaced by a random character */
if (islower(string[i]))
continue;
if (string[i]=='\0' || (strchr(symbolset,string[i])==NULL))
string[i]=symbolset[int_urn(0,strlen(symbolset)-1)];
}
strcpy(rstart, string); /* remember start string */
if (mfe)
{
energy = inverse_fold(string, structure);
if( (!succeed) || (energy<=0.0) ) {
found--;
hd = hamming(rstart, string);
ajFmtPrintF(outf,"%s %3d", string, hd);
if (energy>0)
{ /* no solution found */
ajFmtPrintF(outf," d = %f\n", energy);
}
else
ajFmtPrintF(outf,"\n");
}
}
if (pf)
{
if (!(mfe && give_up && (energy>0)))
{
/* unless we gave up in the mfe part */
double prob, min_en, sfact=1.07;
/* get a reasonable pf_scale */
min_en = fold(string,str2);
pf_scale = exp(-(sfact*min_en)/kT/length);
init_pf_fold(length);
energy = inverse_pf_fold(string, structure);
prob = exp(-energy/kT);
hd = hamming(rstart, string);
ajFmtPrintF(outf,"%s %3d (%f)\n", string, hd, prob);
free_pf_arrays();
}
if (!mfe)
found--;
}
free(string);
}
free(rstart);
free_arrays();
free(structure);
free(str2);
free(start);
} while (1);
ajSeqDel(&seq);
ajStrDel(&eenergy);
ajStrDel(&edangles);
ajStrDel(&method);
ajStrDel(&ealpha);
ajFileClose(&inf);
ajFileClose(¶mfile);
ajFileClose(&outf);
AJFREE(symbolset);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPSeqall seqall;
AjPSeq seq = NULL;
AjPReport report = NULL;
AjPStr jaspdir = NULL;
AjPStr menu = NULL;
AjPStr substr = NULL;
AjPStr mats = NULL;
AjPStr excl = NULL;
float thresh = 0.;
ajuint recurs = 0;
AjPStr dir = NULL;
AjPStr mfname = NULL;
AjPList flist = NULL;
AjPList hits = NULL;
AjPStr head = NULL;
ajint begin;
ajint end;
ajuint mno;
char cp;
ajuint i;
AjPTable mattab = NULL;
AjPFeattable TabRpt = NULL;
AjBool both = ajFalse;
embInit("jaspscan", argc, argv);
seqall = ajAcdGetSeqall("sequence");
menu = ajAcdGetListSingle("menu");
mats = ajAcdGetString("matrices");
excl = ajAcdGetString("exclude");
thresh = ajAcdGetFloat("threshold");
report = ajAcdGetReport("outfile");
both = ajAcdGetBoolean("both");
jaspdir = ajStrNew();
substr = ajStrNew();
flist = ajListNew();
hits = ajListNew();
dir = ajStrNew();
head = ajStrNew();
cp = ajStrGetCharFirst(menu);
if(cp=='C')
ajStrAssignC(&jaspdir,J_COR);
else if(cp=='F')
ajStrAssignC(&jaspdir,J_FAM);
else if(cp=='P')
ajStrAssignC(&jaspdir,J_PHY);
else if(cp=='N')
ajStrAssignC(&jaspdir,J_CNE);
else if(cp=='O')
ajStrAssignC(&jaspdir,J_POL);
else if(cp=='S')
ajStrAssignC(&jaspdir,J_SPL);
else
ajFatal("Invalid JASPAR database selection");
ajStrAssignS(&dir, ajDatafileValuePath());
if(!ajStrGetLen(dir))
ajFatal("EMBOSS DATA directory couldn't be determined");
jaspscan_ParseInput(dir, jaspdir, mats, excl, &recurs, flist);
mno = ajListGetLength(flist);
if(cp == 'C')
mattab = jaspscan_ReadCoreList(jaspdir);
if(cp == 'F')
mattab = jaspscan_ReadFamList(jaspdir);
if(cp == 'P')
mattab = jaspscan_ReadCoreList(jaspdir);
if(cp == 'N')
mattab = jaspscan_ReadCoreList(jaspdir);
if(cp == 'O')
mattab = jaspscan_ReadCoreList(jaspdir);
if(cp == 'S')
mattab = jaspscan_ReadCoreList(jaspdir);
ajFmtPrintS(&head,"Database scanned: %S Threshold: %.3f",jaspdir,thresh);
ajReportSetHeaderS(report,head);
while(ajSeqallNext(seqall, &seq))
{
begin = ajSeqallGetseqBegin(seqall);
end = ajSeqallGetseqEnd(seqall);
ajStrAssignSubC(&substr,ajSeqGetSeqC(seq),begin-1,end-1);
ajStrFmtUpper(&substr);
TabRpt = ajFeattableNewSeq(seq);
for(i=0; i < mno; ++i)
{
ajListPop(flist,(void **)&mfname);
jaspscan_scan(substr,begin,mfname, cp, thresh, both, hits);
ajListPushAppend(flist, (void **)mfname);
}
jaspscan_ReportHits(TabRpt,mattab,hits);
ajReportWrite(report, TabRpt, seq);
ajFeattableDel(&TabRpt);
}
while(ajListPop(flist,(void **)&mfname))
ajStrDel(&mfname);
ajStrDel(&dir);
ajStrDel(&menu);
ajStrDel(&excl);
ajStrDel(&substr);
ajStrDel(&mats);
ajStrDel(&head);
ajStrDel(&jaspdir);
ajSeqDel(&seq);
ajTableMapDel(mattab,jaspscan_ClearTable,NULL);
ajTableFree(&mattab);
ajListFree(&flist);
ajListFree(&hits);
ajSeqallDel(&seqall);
ajReportDel(&report);
embExit();
return 0;
}
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;
}
void emboss_getoptions(char *pgm, int argc, char *argv[])
{
ajint numseqs=0;
ajint numwts=0;
AjPStr method = NULL;
ancvar = false;
dollo = true;
jumble = false;
njumble = 1;
trout = true;
usertree = false;
goteof = false;
weights = false;
justwts = false;
printdata = false;
progress = true;
treeprint = true;
stepbox = false;
ancseq = false;
mulsets = false;
msets = 1;
embInitPV(pgm, argc, argv, "PHYLIPNEW",VERSION);
phylostates = ajAcdGetDiscretestates("infile");
while (phylostates[numseqs])
numseqs++;
phylotrees = ajAcdGetTree("intreefile");
if (phylotrees)
{
numtrees = 0;
while (phylotrees[numtrees])
numtrees++;
usertree = true;
}
phyloweights = ajAcdGetProperties("weights");
if (phyloweights)
{
weights = true;
numwts = ajPhyloPropGetSize(phyloweights);
}
if (numseqs > 1) {
mulsets = true;
msets = numseqs;
}
else if (numwts > 1) {
mulsets = true;
msets = numwts;
justwts = true;
}
method = ajAcdGetListSingle("method");
if(ajStrMatchC(method, "d")) dollo = true;
else dollo = false;
if(!usertree) {
njumble = ajAcdGetInt("njumble");
if(njumble >0) {
inseed = ajAcdGetInt("seed");
jumble = true;
emboss_initseed(inseed, &inseed0, seed);
}
else njumble = 1;
}
if((mulsets) && (!jumble)) {
jumble = true;
inseed = ajAcdGetInt("seed");
emboss_initseed(inseed, &inseed0, seed);
}
phyloanc = ajAcdGetProperties("ancfile");
if(phyloanc) ancvar = true;
threshold = ajAcdGetFloat("threshold");
printdata = ajAcdGetBoolean("printdata");
progress = ajAcdGetBoolean("progress");
treeprint = ajAcdGetBoolean("treeprint");
trout = ajAcdGetToggle("trout");
stepbox = ajAcdGetBoolean("stepbox");
ancseq = ajAcdGetBoolean("ancseq");
embossoutfile = ajAcdGetOutfile("outfile");
emboss_openfile(embossoutfile, &outfile, &outfilename);
if(trout) {
embossouttree = ajAcdGetOutfile("outtreefile");
emboss_openfile(embossouttree, &outtree, &outtreename);
}
printf("\nDollo and polymorphism parsimony algorithm, version %s\n\n", VERSION);
fprintf(outfile,"\nDollo and polymorphism parsimony algorithm,");
fprintf(outfile," version %s\n\n",VERSION);
} /* emboss_getoptions */
int main(int argc, char **argv)
{
AjPSeqset seq1;
AjPSeqset seq2;
AjPFile list;
ajint n1;
ajint n2;
ajint *lengths1;
ajint *lengths2;
ajuint *order1;
ajuint *order2;
ajint *hits1;
ajint *hits2;
ajint curr1;
ajint curr2;
ajint tmp1;
ajint tmp2 = 0;
ajint i;
AjPStr operator;
ajint OperatorCode=0;
embInit("listor", argc, argv);
seq1 = ajAcdGetSeqset("firstsequences");
seq2 = ajAcdGetSeqset("secondsequences");
list = ajAcdGetOutfile("outfile");
operator = ajAcdGetListSingle("operator");
/* get the operator value */
switch(ajStrGetCharFirst(operator))
{
case 'O':
OperatorCode = L_OR;
break;
case 'A':
OperatorCode = L_AND;
break;
case 'X':
OperatorCode = L_XOR;
break;
case 'N':
OperatorCode = L_NOT;
break;
default:
ajFatal("Invalid operator type: %S", operator);
embExitBad();
}
/* get the order of seqset 1 by length */
n1 = ajSeqsetGetSize(seq1);
/* lengths of seq1 entries */
lengths1 = AJCALLOC0(n1, sizeof(ajint));
/* seq1 entries which match seq2 */
hits1 = AJCALLOC0(n1, sizeof(ajint));
/* seq1 entries in length order */
order1 = AJCALLOC0(n1, sizeof(ajint));
for(i=0; i<n1; i++)
{
lengths1[i] = ajSeqGetLen(ajSeqsetGetseqSeq(seq1, i));
order1[i] = i;
hits1[i] = -1;
}
ajSortIntIncI(lengths1, order1, n1);
/* get the order of seqset 2 by length */
n2 = ajSeqsetGetSize(seq2);
lengths2 = AJCALLOC0(n2, sizeof(ajint));
hits2 = AJCALLOC0(n2, sizeof(ajint));
order2 = AJCALLOC0(n2, sizeof(ajint));
for(i=0; i<n2; i++)
{
lengths2[i] = ajSeqGetLen(ajSeqsetGetseqSeq(seq2, i));
order2[i] = i;
hits2[i] = -1;
}
ajSortIntIncI(lengths2, order2, n2);
/*
** go down the two sequence sets, by size order, looking for identical
**lengths
*/
curr1 = 0;
curr2 = 0;
while(curr1 < n1 && curr2 < n2)
{
if(lengths1[order1[curr1]] < lengths2[order2[curr2]])
/* seq1 is shorter - increment curr1 index */
curr1++;
else if(lengths1[order1[curr1]] > lengths2[order2[curr2]])
/* seq2 is shorter - increment curr2 index */
curr2++;
else
{
/* identical lengths - check all seq1/seq2 entries of this len */
for(tmp1=curr1; tmp1<n1
&& lengths1[order1[tmp1]] == lengths2[order2[curr2]]; tmp1++)
for(tmp2=curr2; tmp2<n2 && lengths2[order2[tmp2]] ==
lengths2[order2[curr2]]; tmp2++)
/* check to see if the sequences are identical */
if(!ajStrCmpCaseS(ajSeqGetSeqS(ajSeqsetGetseqSeq(seq1,
order1[tmp1])),
ajSeqGetSeqS(ajSeqsetGetseqSeq(seq2,
order2[tmp2]))))
{
hits1[order1[tmp1]] = order2[tmp2];
hits2[order2[tmp2]] = order1[tmp1];
}
curr1 = tmp1;
curr2 = tmp2;
}
}
/* output the required entries to the list file */
listor_Output(list, OperatorCode, seq1, seq2, hits1, hits2, n1, n2);
AJFREE(lengths1);
AJFREE(lengths2);
AJFREE(order1);
AJFREE(order2);
AJFREE(hits1);
AJFREE(hits2);
ajFileClose(&list);
ajStrDel(&operator);
ajSeqsetDel(&seq1);
ajSeqsetDel(&seq2);
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;
}
void emboss_getoptions(char *pgm, int argc, char *argv[])
{
/* get from user the relevant parameters for the plotter and diagram */
boolean getgrows;
int m, n;
AjPStr getstyle = NULL;
AjPStr plottercode = NULL;
AjPStr getpreviewer = NULL;
AjPStr getnodeposition = NULL;
embInitPV(pgm, argc, argv, "PHYLIPNEW",VERSION);
n = (int)((pagex-hpmargin-0.01)/(paperx-hpmargin)+1.0);
m = (int)((pagey-vpmargin-0.01)/(papery-vpmargin)+1.0);
phylotrees = ajAcdGetTree("intreefile");
plottercode = ajAcdGetListSingle("plotter");
getplotter(ajStrGetCharFirst(plottercode));
preview = true;
getpreviewer = ajAcdGetListSingle("previewer"); /* sets plotter variable */
if(ajStrMatchC(getpreviewer, "n")) {
preview = false;
previewer = other; /* Added by Dan F. */
}
else if(ajStrMatchC(getpreviewer, "i")) previewer = ibm;
else if(ajStrMatchC(getpreviewer, "m")) previewer = mac;
else if(ajStrMatchC(getpreviewer, "x")) previewer = xpreview;
else if(ajStrMatchC(getpreviewer, "w")) previewer = winpreview;
else if(ajStrMatchC(getpreviewer, "i")) previewer = tek;
else if(ajStrMatchC(getpreviewer, "i")) previewer = decregis;
else if(ajStrMatchC(getpreviewer, "o")) previewer = other;
getgrows = ajAcdGetBoolean("grows");
if(getgrows) grows = horizontal;
else grows = vertical;
getstyle = ajAcdGetListSingle("style");
if(ajStrMatchC(getstyle, "c")) style = cladogram;
else if(ajStrMatchC(getstyle, "p")) style = phenogram;
else if(ajStrMatchC(getstyle, "e")) style = eurogram;
else if(ajStrMatchC(getstyle, "s")) style = swoopogram;
else if(ajStrMatchC(getstyle, "v")) style = curvogram;
else if(ajStrMatchC(getstyle, "o")) {
style = circular;
treedepth = 1.0;
}
uselengths = ajAcdGetBoolean("lengths");
labelrotation = ajAcdGetFloat("labelrotation");
if(plotter==ray) {
xmargin = ajAcdGetFloat("xrayshade");
ymargin = ajAcdGetFloat("yrayshade");
}
else {
xmargin = ajAcdGetFloat("xmargin");
ymargin = ajAcdGetFloat("ymargin");
}
rescaled = ajAcdGetToggle("rescaled");
if(rescaled) bscale = ajAcdGetFloat("bscale");
treedepth = ajAcdGetFloat("treedepth");
stemlength = ajAcdGetFloat("stemlength");
nodespace = ajAcdGetFloat("nodespace");
nodespace = 1.0 / nodespace;
m = ajAcdGetFloat("pagesheight");
n = ajAcdGetFloat("pageswidth");
paperx = ajAcdGetFloat("paperx");
papery = ajAcdGetFloat("papery");
hpmargin = ajAcdGetFloat("hpmargin");
vpmargin = ajAcdGetFloat("vpmargin");
pagex = ((double)n * (paperx-hpmargin)+hpmargin);
pagey = ((double)m * (papery-vpmargin)+vpmargin);
getnodeposition = ajAcdGetListSingle("nodeposition");
if(ajStrMatchC(getnodeposition, "i")) nodeposition = intermediate;
else if(ajStrMatchC(getnodeposition, "w")) nodeposition = weighted;
else if(ajStrMatchC(getnodeposition, "c")) nodeposition = centered;
else if(ajStrMatchC(getnodeposition, "i")) nodeposition = inner;
else if(ajStrMatchC(getnodeposition, "v")) nodeposition = vshaped;
embossplotfile = ajAcdGetOutfile("plotfile");
emboss_openfile(embossplotfile, &plotfile, &pltfilename);
} /* getparms */
int main(int argc, char *argv[])
{
char *string;
char *structure=NULL;
char *cstruc=NULL;
char *ns_bases=NULL;
char *c;
int n_seq;
int i;
int length;
int sym;
int endgaps = 0;
int mis = 0;
double min_en;
double real_en;
double sfact = 1.07;
int pf = 0;
int istty;
char *AS[MAX_NUM_NAMES]; /* aligned sequences */
char *names[MAX_NUM_NAMES]; /* sequence names */
AjPSeqset seq = NULL;
AjPFile confile = NULL;
AjPFile alifile = NULL;
AjPFile paramfile = NULL;
AjPFile outf = NULL;
AjPFile essfile = NULL;
AjPFile dotfile = NULL;
AjPStr constring = NULL;
float eT = 0.;
AjBool eGU;
AjBool eclose;
AjBool lonely;
AjPStr ensbases = NULL;
AjBool etloop;
AjPStr eenergy = NULL;
char ewt = '\0';
float escale = 0.;
AjPStr edangles = NULL;
char edangle = '\0';
ajint len;
AjPSeq tseq = NULL;
AjPStr tname = NULL;
int circ = 0;
int doAlnPS = 0;
int doColor = 0;
embInitPV("vrnaalifoldpf",argc,argv,"VIENNA",VERSION);
constring = ajStrNew();
seq = ajAcdGetSeqset("sequence");
confile = ajAcdGetInfile("constraintfile");
paramfile = ajAcdGetInfile("paramfile");
eT = ajAcdGetFloat("temperature");
eGU = ajAcdGetBoolean("gu");
eclose = ajAcdGetBoolean("closegu");
lonely = ajAcdGetBoolean("lp");
ensbases = ajAcdGetString("nsbases");
etloop = ajAcdGetBoolean("tetraloop");
eenergy = ajAcdGetListSingle("energy");
escale = ajAcdGetFloat("scale");
edangles = ajAcdGetListSingle("dangles");
mis = !!ajAcdGetBoolean("most");
endgaps = !!ajAcdGetBoolean("endgaps");
nc_fact = (double) ajAcdGetFloat("nspenalty");
cv_fact = (double) ajAcdGetFloat("covariance");
outf = ajAcdGetOutfile("outfile");
essfile = ajAcdGetOutfile("ssoutfile");
alifile = ajAcdGetOutfile("alignoutfile");
circ = !!ajAcdGetBoolean("circular");
doColor = !!ajAcdGetBoolean("colour");
dotfile = ajAcdGetOutfile("dotoutfile");
do_backtrack = 1;
pf = 1;
string = NULL;
istty = 0;
dangles = 2;
temperature = (double) eT;
noGU = (eGU) ? 0 : 1;
no_closingGU = (eclose) ? 0 : 1;
noLonelyPairs = (lonely) ? 0 : 1;
ns_bases = (ajStrGetLen(ensbases)) ? MAJSTRGETPTR(ensbases) : NULL;
tetra_loop = !!etloop;
ewt = *ajStrGetPtr(eenergy);
if(ewt == '0')
energy_set = 0;
else if(ewt == '1')
energy_set = 1;
else if(ewt == '2')
energy_set = 2;
sfact = (double) escale;
edangle = *ajStrGetPtr(edangles);
if(edangle == '0')
dangles = 0;
else if(edangle == '1')
dangles = 1;
else if(edangle == '2')
dangles = 2;
else if(edangle == '3')
dangles = 3;
if(paramfile)
read_parameter_file(paramfile);
if (ns_bases != NULL)
{
nonstandards = space(33);
c=ns_bases;
i=sym=0;
if (*c=='-')
{
sym=1;
c++;
}
while (*c!='\0')
{
if (*c!=',')
{
nonstandards[i++]=*c++;
nonstandards[i++]=*c;
if ((sym)&&(*c!=*(c-1)))
{
nonstandards[i++]=*c;
nonstandards[i++]=*(c-1);
}
}
c++;
}
}
if(alifile)
doAlnPS = 1;
if(confile)
vienna_GetConstraints(confile,&constring);
n_seq = ajSeqsetGetSize(seq);
if(n_seq > MAX_NUM_NAMES - 1)
ajFatal("[e]RNAalifold is restricted to %d sequences\n",
MAX_NUM_NAMES - 1);
if (n_seq==0)
ajFatal("No sequences found");
for(i=0;i<n_seq;++i)
{
tseq = (AjPSeq) ajSeqsetGetseqSeq(seq,i);
ajSeqGapStandard(tseq, '-');
tname = (AjPStr) ajSeqsetGetseqNameS(seq,i);
len = ajSeqGetLen(tseq);
AS[i] = (char *) space(len+1);
names[i] = (char *) space(ajStrGetLen(tname)+1);
strcpy(AS[i],ajSeqGetSeqC(tseq));
strcpy(names[i],ajStrGetPtr(tname));
}
AS[n_seq] = NULL;
names[n_seq] = NULL;
if (endgaps)
for (i=0; i<n_seq; i++)
mark_endgaps(AS[i], '~');
length = (int) strlen(AS[0]);
structure = (char *) space((unsigned) length+1);
if(confile)
{
fold_constrained = 1;
strcpy(structure,ajStrGetPtr(constring));
}
if (circ && noLonelyPairs)
ajWarn(
"warning, depending on the origin of the circular sequence, "
"some structures may be missed when using -noLP\n"
"Try rotating your sequence a few times\n");
if (circ)
min_en = circalifold((const char **)AS, structure);
else
min_en = alifold(AS, structure);
{
int i;
double s=0;
extern int eos_debug;
eos_debug=-1; /* shut off warnings about nonstandard pairs */
for (i=0; AS[i]!=NULL; i++)
if (circ)
s += energy_of_circ_struct(AS[i], structure);
else
s += energy_of_struct(AS[i], structure);
real_en = s/i;
}
string = (mis) ?
consens_mis((const char **) AS) : consensus((const char **) AS);
ajFmtPrintF(outf,"%s\n%s", string, structure);
ajFmtPrintF(outf," (%6.2f = %6.2f + %6.2f) \n", min_en, real_en,
min_en-real_en );
if (length<=2500) {
char **A;
A = annote(structure, (const char**) AS);
if (doColor)
(void) PS_rna_plot_a(string, structure, essfile, A[0], A[1]);
else
(void) PS_rna_plot_a(string, structure, essfile, NULL, A[1]);
free(A[0]); free(A[1]);free(A);
} else
ajWarn("INFO: structure too long, not doing xy_plot\n");
if (doAlnPS)
PS_color_aln(structure, alifile, AS, names);
{ /* free mfe arrays but preserve base_pair for PS_dot_plot */
struct bond *bp;
bp = base_pair; base_pair = space(16);
free_alifold_arrays(); /* free's base_pair */
free_alipf_arrays();
base_pair = bp;
}
if (pf) {
double energy, kT;
pair_info *pi;
char * mfe_struc;
mfe_struc = strdup(structure);
kT = (temperature+273.15)*1.98717/1000.; /* in Kcal */
pf_scale = exp(-(sfact*min_en)/kT/length);
if (length>2000)
ajWarn("scaling factor %f\n", pf_scale);
/* init_alipf_fold(length); */
if (confile)
strncpy(structure, ajStrGetPtr(constring), length+1);
energy = (circ) ? alipf_circ_fold(AS, structure, &pi) : alipf_fold(AS, structure, &pi);
if (do_backtrack) {
ajFmtPrintF(outf,"%s", structure);
ajFmtPrintF(outf," [%6.2f]\n", energy);
}
if ((istty)||(!do_backtrack))
ajFmtPrintF(outf," free energy of ensemble = %6.2f kcal/mol\n", energy);
ajFmtPrintF(outf," frequency of mfe structure in ensemble %g\n",
exp((energy-min_en)/kT));
if (do_backtrack) {
FILE *aliout;
cpair *cp;
short *ptable; int k;
ptable = make_pair_table(mfe_struc);
ajFmtPrintF(outf,"\n# Alignment section\n\n");
aliout = ajFileGetFileptr(outf);
fprintf(aliout, "%d sequences; length of alignment %d\n",
n_seq, length);
fprintf(aliout, "alifold output\n");
for (k=0; pi[k].i>0; k++) {
pi[k].comp = (ptable[pi[k].i] == pi[k].j) ? 1:0;
print_pi(pi[k], aliout);
}
fprintf(aliout, "%s\n", structure);
free(ptable);
cp = make_color_pinfo(pi);
(void) PS_color_dot_plot(string, cp, dotfile);
free(cp);
free(mfe_struc);
free(pi);
}
}
if (cstruc!=NULL) free(cstruc);
free(base_pair);
(void) fflush(stdout);
free(string);
free(structure);
for (i=0; AS[i]; i++) {
free(AS[i]); free(names[i]);
}
ajSeqsetDel(&seq);
ajStrDel(&constring);
ajStrDel(&eenergy);
ajStrDel(&edangles);
ajStrDel(&ensbases);
ajFileClose(&confile);
ajFileClose(¶mfile);
ajFileClose(&outf);
ajFileClose(&essfile);
ajFileClose(&alifile);
ajFileClose(&dotfile);
embExit();
return 0;
}
int main(int argc, char **argv)
{
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(int argc, char **argv)
{
AjPStr cl = NULL;
AjPStr stmp = NULL;
AjPStr squal = NULL;
/* AjBool bqual = ajFalse; */
AjPTable preftab = NULL;
embInitPV("emira", argc, argv, "MIRA",VERSION);
cl = ajStrNewS(ajAcdGetpathC("mira"));
stmp = ajStrNew();
preftab = emira_makepreftab();
if(ajAcdIsUserdefinedC("genome"))
{
squal = ajAcdGetListSingle("genome");
ajFmtPrintAppS(&cl," -genome%S",squal);
ajStrDel(&squal);
}
if(ajAcdIsUserdefinedC("mapping"))
{
squal = ajAcdGetListSingle("mapping");
ajFmtPrintAppS(&cl," -mapping%S",squal);
ajStrDel(&squal);
}
if(ajAcdIsUserdefinedC("clipping"))
{
squal = ajAcdGetListSingle("clipping");
ajFmtPrintAppS(&cl," -clipping%S",squal);
ajStrDel(&squal);
}
if(ajAcdIsUserdefinedC("setparam"))
{
squal = ajAcdGetListSingle("setparam");
if(!ajStrMatchC(squal,"unspecified"))
ajFmtPrintAppS(&cl," -%S",squal);
ajStrDel(&squal);
}
emira_dostrings(&cl, preftab);
emira_doinfiles(&cl, preftab);
emira_dodirectories(&cl, preftab);
emira_dobools(&cl, preftab);
emira_dointegers(&cl, preftab);
emira_dolistsingles(&cl, preftab);
ajDebug("Constructed command line: %S\n",cl);
#if 0
ajFmtPrint("%S\n",cl);
#endif
#if 1
system(ajStrGetPtr(cl));
#endif
ajStrDel(&stmp);
ajStrDel(&cl);
ajTablestrFree(&preftab);
embExit();
return 0;
}
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[])
{
char *string/*, *line*/;
char *structure=NULL, *cstruc=NULL;
/*char fname[13], ffname[20], gfname[20];*/
/*char *ParamFile=NULL;*/
char *ns_bases=NULL, *c;
int i, length, l, sym/*, r*/;
double energy, min_en;
double kT, sfact=1.07;
int pf=0, noPS=0, istty;
int noconv=0;
int circ=0;
AjPSeq seq = NULL;
AjPFile confile = NULL;
AjPFile paramfile = NULL;
AjPFile outf = NULL;
AjPFile essfile = NULL;
AjPFile dotfilea = NULL;
AjPFile dotfileb = NULL;
AjPStr seqstring = NULL;
AjPStr constring = NULL;
AjPStr seqname = NULL;
float eT = 0.;
AjBool eGU;
AjBool ecirc = ajFalse;
AjBool eclose;
AjBool lonely;
AjBool convert;
AjPStr ensbases = NULL;
AjBool etloop;
AjPStr eenergy = NULL;
char ewt = '\0';
float escale = 0.;
AjPStr edangles = NULL;
char edangle = '\0';
ajint len;
embInitPV("vrnafold",argc,argv,"VIENNA",VERSION);
seqstring = ajStrNew();
constring = ajStrNew();
seqname = ajStrNew();
seq = ajAcdGetSeq("sequence");
confile = ajAcdGetInfile("constraintfile");
paramfile = ajAcdGetInfile("paramfile");
eT = ajAcdGetFloat("temperature");
ecirc = ajAcdGetBoolean("circular");
eGU = ajAcdGetBoolean("gu");
eclose = ajAcdGetBoolean("closegu");
lonely = ajAcdGetBoolean("lp");
convert = ajAcdGetBoolean("convert");
ensbases = ajAcdGetString("nsbases");
etloop = ajAcdGetBoolean("tetraloop");
eenergy = ajAcdGetListSingle("energy");
escale = ajAcdGetFloat("scale");
edangles = ajAcdGetListSingle("dangles");
outf = ajAcdGetOutfile("outfile");
essfile = ajAcdGetOutfile("ssoutfile");
/*
dotfilea = ajAcdGetOutfile("adotoutfile");
dotfileb = ajAcdGetOutfile("bdotoutfile");
*/
do_backtrack = 2;
pf = 0;
string = NULL;
istty = 0;
temperature = (double) eT;
circ = !!ecirc;
noGU = (eGU) ? 0 : 1;
no_closingGU = (eclose) ? 0 : 1;
noLonelyPairs = (lonely) ? 0 : 1;
noconv = (convert) ? 0 : 1;
ns_bases = (ajStrGetLen(ensbases)) ? MAJSTRGETPTR(ensbases) : NULL;
tetra_loop = !!etloop;
ewt = *ajStrGetPtr(eenergy);
if(ewt == '0')
energy_set = 0;
else if(ewt == '1')
energy_set = 1;
else if(ewt == '2')
energy_set = 2;
sfact = (double) escale;
edangle = *ajStrGetPtr(edangles);
if(edangle == '0')
dangles = 0;
else if(edangle == '1')
dangles = 1;
else if(edangle == '2')
dangles = 2;
else if(edangle == '3')
dangles = 3;
if(circ && noLonelyPairs)
{
ajWarn("Depending on the origin of the circular sequence\n"
"some structures may be missed when using -noLP\nTry "
"rotating your sequence a few times\n");
}
if(paramfile)
read_parameter_file(paramfile);
if (ns_bases != NULL)
{
nonstandards = space(33);
c=ns_bases;
i=sym=0;
if (*c=='-')
{
sym=1; c++;
}
while (*c!='\0')
{
if (*c!=',')
{
nonstandards[i++]=*c++;
nonstandards[i++]=*c;
if ((sym)&&(*c!=*(c-1)))
{
nonstandards[i++]=*c;
nonstandards[i++]=*(c-1);
}
}
c++;
}
}
if(confile)
vienna_GetConstraints(confile,&constring);
string = NULL;
structure = NULL;
length = ajSeqGetLen(seq);
string = (char *) space(length+1);
strcpy(string,ajSeqGetSeqC(seq));
len = ajStrGetLen(constring);
structure = (char *) space(length+1);
if(len)
{
fold_constrained = 1;
strcpy(structure,ajStrGetPtr(constring));
}
for (l = 0; l < length; l++) {
string[l] = toupper(string[l]);
if (!noconv && string[l] == 'T') string[l] = 'U';
}
/* initialize_fold(length); */
if (circ)
min_en = circfold(string, structure);
else
min_en = fold(string, structure);
ajFmtPrintF(outf,"%s\n%s", string, structure);
if (istty)
printf("\n minimum free energy = %6.2f kcal/mol\n", min_en);
else
ajFmtPrintF(outf," (%6.2f)\n", min_en);
if (!noPS)
{
if (length<2000)
(void) PS_rna_plot(string, structure, essfile);
else
ajWarn("Structure too long, not doing xy_plot\n");
}
if (length>=2000) free_arrays();
if (pf)
{
char *pf_struc;
pf_struc = (char *) space((unsigned) length+1);
if (dangles==1)
{
dangles=2; /* recompute with dangles as in pf_fold() */
min_en = (circ) ? energy_of_circ_struct(string, structure) :
energy_of_struct(string, structure);
dangles=1;
}
kT = (temperature+273.15)*1.98717/1000.; /* in Kcal */
pf_scale = exp(-(sfact*min_en)/kT/length);
if (length>2000)
ajWarn("scaling factor %f\n", pf_scale);
(circ) ? init_pf_circ_fold(length) : init_pf_fold(length);
if (cstruc!=NULL)
strncpy(pf_struc, cstruc, length+1);
energy = (circ) ? pf_circ_fold(string, pf_struc) :
pf_fold(string, pf_struc);
if (do_backtrack)
{
ajFmtPrintF(outf,"%s", pf_struc);
ajFmtPrintF(outf," [%6.2f]\n", energy);
}
if ((istty)||(!do_backtrack))
ajFmtPrintF(outf," free energy of ensemble = %6.2f kcal/mol\n",
energy);
if (do_backtrack)
{
plist *pl1,*pl2;
char *cent;
double dist, cent_en;
cent = centroid(length, &dist);
cent_en = (circ) ? energy_of_circ_struct(string, cent) :
energy_of_struct(string, cent);
ajFmtPrintF(outf,"%s {%6.2f d=%.2f}\n", cent, cent_en, dist);
free(cent);
pl1 = make_plist(length, 1e-5);
pl2 = b2plist(structure);
(void) PS_dot_plot_list(string, dotfilea, pl1, pl2, "");
free(pl2);
if (do_backtrack==2)
{
pl2 = stackProb(1e-5);
PS_dot_plot_list(string, dotfileb, pl1, pl2,
"Probabilities for stacked pairs (i,j)(i+1,j-1)");
free(pl2);
}
free(pl1);
free(pf_struc);
}
ajFmtPrintF(outf," frequency of mfe structure in ensemble %g; ",
exp((energy-min_en)/kT));
if (do_backtrack)
ajFmtPrintF(outf,"ensemble diversity %-6.2f", mean_bp_dist(length));
ajFmtPrintF(outf,"\n");
free_pf_arrays();
}
if (cstruc!=NULL)
free(cstruc);
free(string);
free(structure);
ajStrDel(&seqstring);
ajStrDel(&constring);
ajStrDel(&seqname);
ajStrDel(&ensbases);
ajStrDel(&eenergy);
ajStrDel(&edangles);
ajSeqDel(&seq);
ajFileClose(&confile);
ajFileClose(¶mfile);
ajFileClose(&outf);
ajFileClose(&essfile);
/*
ajFileClose(&dotfilea);
ajFileClose(&dotfileb);
*/
if (length<2000) free_arrays();
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)
{
AjPSeqall seqall = NULL;
AjPFile dend_outfile = NULL;
AjPStr tmp_dendfilename = NULL;
AjPFile tmp_dendfile = NULL;
AjPStr tmp_aln_outfile = NULL;
AjPSeqset seqset = NULL;
AjPSeqout seqout = NULL;
AjPSeqin seqin = NULL;
AjBool only_dend;
AjBool are_prot = ajFalse;
AjBool do_slow;
AjBool use_dend;
AjPFile dend_file = NULL;
AjPStr dend_filename = NULL;
ajint ktup;
ajint gapw;
ajint topdiags;
ajint window;
AjBool nopercent;
AjPStr pw_matrix = NULL;
AjPStr pw_dna_matrix = NULL;
AjPFile pairwise_matrix = NULL;
float pw_gapc;
float pw_gapv;
AjPStr pwmstr = NULL;
char pwmc = '\0';
AjPStr pwdstr = NULL;
char pwdc = '\0';
AjPStr m1str = NULL;
AjPStr m2str = NULL;
char m1c = '\0';
char m2c = '\0';
AjPStr matrix = NULL;
AjPStr dna_matrix = NULL;
AjPFile ma_matrix = NULL;
float gapc;
float gapv;
AjBool endgaps;
AjBool norgap;
AjBool nohgap;
ajint gap_dist;
ajint maxdiv;
AjPStr hgapres = NULL;
AjPSeqout fil_file = NULL;
AjPSeq seq = NULL;
AjPStr cmd = NULL;
AjPStr tmp = NULL;
AjPStr tmpFilename;
AjPStr line = NULL;
ajint nb = 0;
/* get all the parameters */
embInit("emma", argc, argv);
pwmstr = ajStrNew();
pwdstr = ajStrNew();
m1str = ajStrNew();
m2str = ajStrNew();
seqall = ajAcdGetSeqall("sequence");
seqout = ajAcdGetSeqoutset("outseq");
dend_outfile = ajAcdGetOutfile("dendoutfile");
only_dend = ajAcdGetToggle("onlydend");
use_dend = ajAcdGetToggle("dendreuse");
dend_file = ajAcdGetInfile("dendfile");
if (dend_file)
ajStrAssignS(&dend_filename, ajFileGetPrintnameS(dend_file));
ajFileClose(&dend_file);
do_slow = ajAcdGetToggle("slowalign");
ktup = ajAcdGetInt("ktup");
gapw = ajAcdGetInt("gapw");
topdiags = ajAcdGetInt("topdiags");
window = ajAcdGetInt("window");
nopercent = ajAcdGetBoolean("nopercent");
pw_matrix = ajAcdGetListSingle("pwmatrix");
pwmc = ajStrGetCharFirst(pw_matrix);
if(pwmc=='b')
ajStrAssignC(&pwmstr,"blosum");
else if(pwmc=='p')
ajStrAssignC(&pwmstr,"pam");
else if(pwmc=='g')
ajStrAssignC(&pwmstr,"gonnet");
else if(pwmc=='i')
ajStrAssignC(&pwmstr,"id");
else if(pwmc=='o')
ajStrAssignC(&pwmstr,"own");
pw_dna_matrix = ajAcdGetListSingle("pwdnamatrix");
pwdc = ajStrGetCharFirst(pw_dna_matrix);
if(pwdc=='i')
ajStrAssignC(&pwdstr,"iub");
else if(pwdc=='c')
ajStrAssignC(&pwdstr,"clustalw");
else if(pwdc=='o')
ajStrAssignC(&pwdstr,"own");
pairwise_matrix = ajAcdGetInfile("pairwisedatafile");
pw_gapc = ajAcdGetFloat( "pwgapopen");
pw_gapv = ajAcdGetFloat( "pwgapextend");
matrix = ajAcdGetListSingle( "matrix");
m1c = ajStrGetCharFirst(matrix);
if(m1c=='b')
ajStrAssignC(&m1str,"blosum");
else if(m1c=='p')
ajStrAssignC(&m1str,"pam");
else if(m1c=='g')
ajStrAssignC(&m1str,"gonnet");
else if(m1c=='i')
ajStrAssignC(&m1str,"id");
else if(m1c=='o')
ajStrAssignC(&m1str,"own");
dna_matrix = ajAcdGetListSingle( "dnamatrix");
m2c = ajStrGetCharFirst(dna_matrix);
if(m2c=='i')
ajStrAssignC(&m2str,"iub");
else if(m2c=='c')
ajStrAssignC(&m2str,"clustalw");
else if(m2c=='o')
ajStrAssignC(&m2str,"own");
ma_matrix = ajAcdGetInfile("mamatrixfile");
gapc = ajAcdGetFloat("gapopen");
gapv = ajAcdGetFloat("gapextend");
endgaps = ajAcdGetBoolean("endgaps");
norgap = ajAcdGetBoolean("norgap");
nohgap = ajAcdGetBoolean("nohgap");
gap_dist = ajAcdGetInt("gapdist");
hgapres = ajAcdGetString("hgapres");
maxdiv = ajAcdGetInt("maxdiv");
tmp = ajStrNewC("fasta");
/*
** Start by writing sequences into a unique temporary file
** get file pointer to unique file
*/
fil_file = ajSeqoutNew();
tmpFilename = emma_getUniqueFileName();
if(!ajSeqoutOpenFilename( fil_file, tmpFilename))
embExitBad();
/* Set output format to fasta */
ajSeqoutSetFormatS( fil_file, tmp);
while(ajSeqallNext(seqall, &seq))
{
/*
** Check sequences are all of the same type
** Still to be done
** Write out sequences
*/
if (!nb)
are_prot = ajSeqIsProt(seq);
ajSeqoutWriteSeq(fil_file, seq);
++nb;
}
ajSeqoutClose(fil_file);
if(nb < 2)
ajFatal("Multiple alignments need at least two sequences");
/* Generate clustalw command line */
cmd = ajStrNewS(ajAcdGetpathC("clustalw"));
/* add tmp file containing sequences */
ajStrAppendC(&cmd, " -infile=");
ajStrAppendS(&cmd, tmpFilename);
/* add out file name */
tmp_aln_outfile = emma_getUniqueFileName();
ajStrAppendC(&cmd, " -outfile=");
ajStrAppendS(&cmd, tmp_aln_outfile);
/* calculating just the nj tree or doing full alignment */
if(only_dend)
ajStrAppendC(&cmd, " -tree");
else
if(!use_dend)
ajStrAppendC(&cmd, " -align");
/* Set sequence type from information from acd file */
if(are_prot)
ajStrAppendC(&cmd, " -type=protein");
else
ajStrAppendC(&cmd, " -type=dna");
/*
** set output to MSF format - will read in this file later and output
** user requested format
*/
ajStrAppendC(&cmd, " -output=");
ajStrAppendC(&cmd, "gcg");
/* If going to do pairwise alignment */
if(!use_dend)
{
/* add fast pairwise alignments*/
if(!do_slow)
{
ajStrAppendC(&cmd, " -quicktree");
ajStrAppendC(&cmd, " -ktuple=");
ajStrFromInt(&tmp, ktup);
ajStrAppendS(&cmd, tmp);
ajStrAppendC(&cmd, " -window=");
ajStrFromInt(&tmp, window);
ajStrAppendS(&cmd, tmp);
if(nopercent)
ajStrAppendC(&cmd, " -score=percent");
else
ajStrAppendC(&cmd, " -score=absolute");
ajStrAppendC(&cmd, " -topdiags=");
ajStrFromInt(&tmp, topdiags);
ajStrAppendS(&cmd, tmp);
ajStrAppendC(&cmd, " -pairgap=");
ajStrFromInt(&tmp, gapw);
ajStrAppendS(&cmd, tmp);
}
else
{
if(pairwise_matrix)
{
if(are_prot)
ajStrAppendC(&cmd, " -pwmatrix=");
else
ajStrAppendC(&cmd, " -pwdnamatrix=");
ajStrAppendS(&cmd, ajFileGetPrintnameS(pairwise_matrix));
}
else
{
if(are_prot)
{
ajStrAppendC(&cmd, " -pwmatrix=");
ajStrAppendS(&cmd, pwmstr);
}
else
{
ajStrAppendC(&cmd, " -pwdnamatrix=");
ajStrAppendS(&cmd, pwdstr);
}
}
ajStrAppendC(&cmd, " -pwgapopen=");
ajStrFromFloat(&tmp, pw_gapc, 3);
ajStrAppendS(&cmd, tmp);
ajStrAppendC(&cmd, " -pwgapext=");
ajStrFromFloat(&tmp, pw_gapv, 3);
ajStrAppendS(&cmd, tmp);
}
}
/* Multiple alignments */
/* using existing tree or generating new tree? */
if(use_dend)
{
ajStrAppendC(&cmd, " -usetree=");
ajStrAppendS(&cmd, dend_filename);
}
else
{
/* use tmp file to hold dend file, will read back in later */
tmp_dendfilename = emma_getUniqueFileName();
ajStrAppendC(&cmd, " -newtree=");
ajStrAppendS(&cmd, tmp_dendfilename);
}
if(ma_matrix)
{
if(are_prot)
ajStrAppendC(&cmd, " -matrix=");
else
ajStrAppendC(&cmd, " -pwmatrix=");
ajStrAppendS(&cmd, ajFileGetPrintnameS(ma_matrix));
}
else
{
if(are_prot)
{
ajStrAppendC(&cmd, " -matrix=");
ajStrAppendS(&cmd, m1str);
}
else
{
ajStrAppendC(&cmd, " -dnamatrix=");
ajStrAppendS(&cmd, m2str);
}
}
ajStrAppendC(&cmd, " -gapopen=");
ajStrFromFloat(&tmp, gapc, 3);
ajStrAppendS(&cmd, tmp);
ajStrAppendC(&cmd, " -gapext=");
ajStrFromFloat(&tmp, gapv, 3);
ajStrAppendS(&cmd, tmp);
ajStrAppendC(&cmd, " -gapdist=");
ajStrFromInt(&tmp, gap_dist);
ajStrAppendS(&cmd, tmp);
ajStrAppendC(&cmd, " -hgapresidues=");
ajStrAppendS(&cmd, hgapres);
if(!endgaps)
ajStrAppendC(&cmd, " -endgaps");
if(norgap)
ajStrAppendC(&cmd, " -nopgap");
if(nohgap)
ajStrAppendC(&cmd, " -nohgap");
ajStrAppendC(&cmd, " -maxdiv=");
ajStrFromInt(&tmp, maxdiv);
ajStrAppendS(&cmd, tmp);
/* run clustalw */
/* ajFmtError("..%s..\n\n", ajStrGetPtr( cmd)); */
ajDebug("Executing '%S'\n", cmd);
ajSysExecS(cmd);
/* produce alignment file only if one was produced */
if(!only_dend)
{
/* read in tmp alignment output file to output through EMBOSS output */
seqin = ajSeqinNew();
/*
** add the Usa format to the start of the filename to tell EMBOSS
** format of file
*/
ajStrInsertC(&tmp_aln_outfile, 0, "msf::");
ajSeqinUsa(&seqin, tmp_aln_outfile);
seqset = ajSeqsetNew();
if(ajSeqsetRead(seqset, seqin))
{
ajSeqoutWriteSet(seqout, seqset);
ajSeqoutClose(seqout);
ajSeqinDel(&seqin);
/* remove the Usa from the start of the string */
ajStrCutStart(&tmp_aln_outfile, 5);
}
else
ajFmtError("Problem writing out EMBOSS alignment file\n");
}
/* read in new tmp dend file (if produced) to output through EMBOSS */
if(tmp_dendfilename!=NULL)
{
tmp_dendfile = ajFileNewInNameS( tmp_dendfilename);
if(tmp_dendfile!=NULL){
while(ajReadlineTrim(tmp_dendfile, &line))
ajFmtPrintF(dend_outfile, "%s\n", ajStrGetPtr( line));
ajFileClose(&tmp_dendfile);
ajSysFileUnlinkS(tmp_dendfilename);
}
}
ajSysFileUnlinkS(tmpFilename);
if(!only_dend)
ajSysFileUnlinkS(tmp_aln_outfile);
ajStrDel(&pw_matrix);
ajStrDel(&matrix);
ajStrDel(&pw_dna_matrix);
ajStrDel(&dna_matrix);
ajStrDel(&tmp_dendfilename);
ajStrDel(&dend_filename);
ajStrDel(&tmp_aln_outfile);
ajStrDel(&pwmstr);
ajStrDel(&pwdstr);
ajStrDel(&m1str);
ajStrDel(&m2str);
ajStrDel(&hgapres);
ajStrDel(&cmd);
ajStrDel(&tmp);
ajStrDel(&tmpFilename);
ajStrDel(&line);
ajFileClose(&dend_outfile);
ajFileClose(&tmp_dendfile);
ajFileClose(&dend_file);
ajFileClose(&pairwise_matrix);
ajFileClose(&ma_matrix);
ajSeqallDel(&seqall);
ajSeqsetDel(&seqset);
ajSeqDel(&seq);
ajSeqoutDel(&seqout);
ajSeqoutDel(&fil_file);
ajSeqinDel(&seqin);
embExit();
return 0;
}
void emboss_getoptions(char *pgm, int argc, char *argv[])
{
AjPStr datatype = NULL;
global = false;
jumble = false;
njumble = 1;
lengths = false;
outgrno = 1;
outgropt = false;
all = true;
contchars = false;
trout = true;
usertree = false;
printdata = false;
progress = true;
treeprint = true;
mulsets = false;
datasets = 1;
embInitPV (pgm, argc, argv, "PHYLIPNEW",VERSION);
phylofreq = ajAcdGetFrequencies("infile");
phylotrees = ajAcdGetTree("intreefile");
if (phylotrees)
{
numtrees = 0;
while (phylotrees[numtrees])
numtrees++;
usertree = true;
lengths = ajAcdGetBoolean("lengths");
}
datatype = ajAcdGetListSingle("datatype");
if(ajStrMatchC(datatype, "c")) contchars = true;
outgrno = ajAcdGetInt("outgrno");
if(outgrno != 0) outgropt = true;
else outgrno = 1;
if(!usertree) {
global = ajAcdGetBoolean("global");
njumble = ajAcdGetInt("njumble");
if(njumble >0) {
inseed = ajAcdGetInt("seed");
jumble = true;
emboss_initseed(inseed, &inseed0, seed);
}
else njumble = 1;
}
printdata = ajAcdGetBoolean("printdata");
progress = ajAcdGetBoolean("progress");
treeprint = ajAcdGetBoolean("treeprint");
trout = ajAcdGetToggle("trout");
embossoutfile = ajAcdGetOutfile("outfile");
embossouttree = ajAcdGetOutfile("outtreefile");
emboss_openfile(embossoutfile, &outfile, &outfilename);
if(trout) emboss_openfile(embossouttree, &outtree, &outtreename);
fprintf(outfile, "\nContinuous character Maximum Likelihood");
fprintf(outfile, " method version %s\n\n",VERSION);
ajStrDel(&datatype);
} /* emboss_getoptions */
int main(int argc, char **argv)
{
AjPSeqall seqall;
AjPSeq seq = NULL;
AjPReport outf = NULL;
AjPFile inf = NULL;
ajint begin;
ajint end;
AjPList l = NULL;
AjPStr strand = NULL;
AjPStr substr = NULL;
AjPStr line = NULL;
AjPStr name = NULL;
AjPStr acc = NULL;
AjPStr bf = NULL;
AjPStr menu;
AjPStr pattern = NULL;
AjPStr opattern = NULL;
AjPStr pname = NULL;
AjPStr key = NULL;
AjPStr value = NULL;
AjPTable atable = NULL;
AjPTable btable = NULL;
ajint mismatch;
ajint minlength;
ajint sum;
ajint v;
char cp;
const char *p;
embInit("tfscan", argc, argv);
seqall = ajAcdGetSeqall("sequence");
outf = ajAcdGetReport("outfile");
mismatch = ajAcdGetInt("mismatch");
minlength = ajAcdGetInt("minlength");
menu = ajAcdGetListSingle("menu");
pname = ajStrNew();
cp=ajStrGetCharFirst(menu);
if(cp=='F')
ajStrAssignC(&pname,"tffungi");
else if(cp=='I')
ajStrAssignC(&pname,"tfinsect");
else if(cp=='O')
ajStrAssignC(&pname,"tfother");
else if(cp=='P')
ajStrAssignC(&pname,"tfplant");
else if(cp=='V')
ajStrAssignC(&pname,"tfvertebrate");
else if(cp=='C')
inf = ajAcdGetDatafile("custom");
if(cp!='C')
{
inf = ajDatafileNewInNameS(pname);
if(!inf)
ajFatal("Either EMBOSS_DATA undefined or TFEXTRACT needs running");
}
name = ajStrNew();
acc = ajStrNew();
bf = ajStrNewC("");
substr = ajStrNew();
line = ajStrNew();
pattern = ajStrNewC("AA");
opattern = ajStrNew();
while(ajSeqallNext(seqall, &seq))
{
begin=ajSeqallGetseqBegin(seqall);
end=ajSeqallGetseqEnd(seqall);
ajStrAssignC(&name,ajSeqGetNameC(seq));
strand=ajSeqGetSeqCopyS(seq);
ajStrAssignSubC(&substr,ajStrGetPtr(strand),begin-1,end-1);
ajStrFmtUpper(&substr);
l=ajListNew();
atable = ajTablestrNew(1000);
btable = ajTablestrNew(1000);
sum=0;
while(ajReadlineTrim(inf,&line))
{
p = ajStrGetPtr(line);
if(!*p || *p=='#' || *p=='\n' || *p=='!')
continue;
ajFmtScanS(line,"%S%S%S",&pname,&pattern,&acc);
p += ajStrGetLen(pname);
while(*p && *p==' ')
++p;
p += ajStrGetLen(pattern);
while(*p && *p==' ')
++p;
p += ajStrGetLen(acc);
while(*p && *p==' ')
++p;
ajStrAssignS(&opattern,pattern);
ajStrAssignC(&bf,p); /* rest of line */
v = embPatVariablePattern(pattern,substr,pname,l,0,
mismatch,begin);
if(v)
{
key = ajStrNewS(pname);
value = ajStrNewS(acc);
ajTablePut(atable,(void *)key,(void *)value);
key = ajStrNewS(pname);
value = ajStrNewS(bf);
ajTablePut(btable,(void *)key,(void *)value);
}
sum += v;
}
if(sum)
tfscan_print_hits(&l,sum,outf,atable,seq,minlength,
btable);
ajFileSeek(inf,0L,0);
ajListFree(&l);
ajTablestrFree(&atable);
ajTablestrFree(&btable);
ajStrDel(&strand);
}
ajStrDel(&line);
ajStrDel(&name);
ajStrDel(&acc);
ajStrDel(&pname);
ajStrDel(&opattern);
ajStrDel(&bf);
ajStrDel(&pattern);
ajStrDel(&substr);
ajSeqDel(&seq);
ajFileClose(&inf);
ajReportClose(outf);
ajReportDel(&outf);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&menu);
embExit();
return 0;
}
int main(int argc, char **argv)
{
ajint i;
ajint numseq;
ajint j = 0;
ajint numres;
ajint count;
ajint k;
ajint kmax;
float defheight;
float currentscale;
AjPStr shade = NULL;
AjPFloat pair = NULL;
AjPGraph graph = NULL;
AjPMatrix cmpmatrix = NULL;
AjPSeqCvt cvt = NULL;
AjPStr matcodes = NULL;
AjBool consensus;
AjBool colourbyconsensus;
AjBool colourbyresidues;
AjBool colourbyshade = AJFALSE;
AjBool boxit;
AjBool boxcol;
AjBool portrait;
AjBool collision;
ajint identity;
AjBool listoptions;
ajint alternative;
AjPStr altstr = NULL;
AjPStr sidentity = NULL;
AjPStr ssimilarity = NULL;
AjPStr sother = NULL;
AjPStr sboxcolval = NULL;
AjPStr options = NULL;
/* ajint showscore = 0; */
ajint iboxcolval = 0;
ajint cidentity = RED;
ajint csimilarity = GREEN;
ajint cother = BLACK;
float fxp;
float fyp;
float yincr;
float y;
ajint ixlen;
ajint iylen;
ajint ixoff;
ajint iyoff;
char res[2] = " ";
float *score = 0;
float scoremax = 0;
float *identical = NULL;
ajint identicalmaxindex;
float *matching = NULL;
ajint matchingmaxindex;
float *colcheck = NULL;
ajint **matrix;
ajint m1 = 0;
ajint m2 = 0;
ajint ms = 0;
ajint highindex = 0;
ajint myindex;
ajint *previous = 0;
AjBool iscons = ajFalse;
ajint currentstate = 0;
ajint oldfg = 0;
float fold = 0.0;
ajint *colmat = 0;
ajint *shadecolour = 0;
/* float identthresh = 1.5; */
/* float simthresh = 1.0; */
/* float relthresh = 0.5; */
float part = 0.0;
const char *cptr;
ajint resbreak;
float fplural;
float ystart;
float xmin;
float xmax;
float xmid;
AjPTime ajtime;
ajint gapcount = 0;
ajint countforgap = 0;
ajint boxindex;
float max;
ajint matsize;
ajint seqperpage = 0;
ajint startseq;
ajint endseq;
ajint newILend = 0;
ajint newILstart;
void *freeptr;
ajint itmp;
embInit("prettyplot", argc, argv);
seqset = ajAcdGetSeqset("sequences");
numres = ajAcdGetInt("residuesperline");
resbreak = ajAcdGetInt("resbreak");
ajSeqsetFill(seqset); /* Pads sequence set with gap characters */
numseq = ajSeqsetGetSize(seqset);
graph = ajAcdGetGraph("graph");
colourbyconsensus = ajAcdGetBoolean("ccolours");
colourbyresidues = ajAcdGetBoolean("docolour");
shade = ajAcdGetString("shade");
pair = ajAcdGetArray("pair");
identity = ajAcdGetInt("identity");
boxit = ajAcdGetBoolean("box");
ajtime = ajTimeNewTodayFmt("daytime");
ajSeqsetTrim(seqset);
/* offset = ajSeqsetGetOffset(seqset); Unused */
ajGraphAppendTitleS(graph, ajSeqsetGetUsa(seqset));
if(boxit)
{
AJCNEW(seqboxptr, numseq);
for(i=0;i<numseq;i++)
AJCNEW(seqboxptr[i], ajSeqsetGetLen(seqset));
}
boxcol = ajAcdGetBoolean("boxcol");
sboxcolval = ajAcdGetString("boxuse");
if(boxcol)
{
iboxcolval = ajGraphicsCheckColourS(sboxcolval);
if(iboxcolval == -1)
iboxcolval = GREY;
}
consensus = ajAcdGetBoolean("consensus");
if(consensus)
{
AJCNEW(constr, ajSeqsetGetLen(seqset)+1);
constr[0] = '\0';
}
shownames = ajAcdGetBoolean("name");
shownumbers = ajAcdGetBoolean("number");
charlen = ajAcdGetInt("maxnamelen");
fplural = ajAcdGetFloat("plurality");
portrait = ajAcdGetBoolean("portrait");
collision = ajAcdGetBoolean("collision");
listoptions = ajAcdGetBoolean("listoptions");
altstr = ajAcdGetListSingle("alternative");
cmpmatrix = ajAcdGetMatrix("matrixfile");
ajStrToInt(altstr, &alternative);
matrix = ajMatrixGetMatrix(cmpmatrix);
cvt = ajMatrixGetCvt(cmpmatrix);
matsize = ajMatrixGetSize(cmpmatrix);
AJCNEW(identical,matsize);
AJCNEW(matching,matsize);
AJCNEW(colcheck,matsize);
numgaps = numres/resbreak;
numgaps--;
if(portrait)
{
ajGraphicsSetPortrait(1);
ystart = (float) 75.0;
}
else
ystart = (float) 75.0;
/* pair is an array of three non-negative floats */
/* identthresh = ajFloatGet(pair,0); Unused */
/* simthresh = ajFloatGet(pair,1); Unused */
/* relthresh = ajFloatGet(pair,2); Unused */
/*
** shade is a formatted 4-character string. Characters BLPW only.
** controlled by a pattern in ACD.
*/
if(ajStrGetLen(shade))
{
AJCNEW(shadecolour,4);
cptr = ajStrGetPtr(shade);
for(i=0;i<4;i++){
if(cptr[i]== 'B' || cptr[i]== 'b')
shadecolour[i] = BLACK;
else if(cptr[i]== 'L' || cptr[i]== 'l')
shadecolour[i] = BROWN;
else if(cptr[i]== 'P' || cptr[i]== 'p')
shadecolour[i] = WHEAT;
else if(cptr[i]== 'W' || cptr[i]== 'w')
shadecolour[i] = WHITE;
}
colourbyconsensus = colourbyresidues = ajFalse;
colourbyshade = ajTrue;
}
/*
** we can colour by consensus or residue but not both
** if we have to choose, use the consensus
*/
if(colourbyconsensus && colourbyresidues)
colourbyconsensus = AJFALSE;
sidentity = ajAcdGetString("cidentity");
ssimilarity = ajAcdGetString("csimilarity");
sother = ajAcdGetString("cother");
if(colourbyconsensus)
{
cidentity = ajGraphicsCheckColourS(sidentity);
if(cidentity == -1)
cidentity = RED;
csimilarity = ajGraphicsCheckColourS(ssimilarity);
if(csimilarity == -1)
csimilarity = GREEN;
cother = ajGraphicsCheckColourS(sother);
if(cother == -1)
cother = BLACK;
}
else if(colourbyresidues)
{
matcodes = ajMatrixGetCodes(cmpmatrix);
if(ajSeqsetIsProt(seqset))
colmat = ajGraphicsBasecolourNewProt(matcodes);
else
colmat = ajGraphicsBasecolourNewNuc(matcodes);
}
/* output the options used as the subtitle for the bottom of the graph */
if(listoptions)
{
ajStrAssignC(&options,"");
ajFmtPrintAppS(&options,"-plurality %.1f",fplural);
if(collision)
ajStrAppendC(&options," -collision");
else
ajStrAppendC(&options," -nocollision");
if(boxit)
ajStrAppendC(&options," -box");
else
ajStrAppendC(&options," -nobox");
if(boxcol)
ajStrAppendC(&options," -boxcol");
else
ajStrAppendC(&options," -noboxcol");
if(colourbyconsensus)
ajStrAppendC(&options," -colbyconsensus");
else if(colourbyresidues)
ajStrAppendC(&options," -colbyresidues");
else if(colourbyshade)
ajStrAppendC(&options," -colbyshade");
else
ajStrAppendC(&options," -nocolour");
if(alternative==2)
ajStrAppendC(&options," -alt 2");
else if(alternative==1)
ajStrAppendC(&options," -alt 1");
else if(alternative==3)
ajStrAppendC(&options," -alt 3");
}
AJCNEW(seqcolptr, numseq);
for(i=0;i<numseq;i++)
AJCNEW(seqcolptr[i], ajSeqsetGetLen(seqset));
AJCNEW(seqcharptr, numseq);
AJCNEW(seqnames, numseq);
AJCNEW(score, numseq);
AJCNEW(previous, numseq);
AJCNEW(seqcount, numseq);
for(i=0;i<numseq;i++)
{
ajSeqsetFmtUpper(seqset);
seqcharptr[i] = ajSeqsetGetseqSeqC(seqset, i);
seqnames[i] = 0;
ajStrAppendS(&seqnames[i],ajSeqsetGetseqNameS(seqset, i));
ajStrTruncateLen(&seqnames[i],charlen);
previous[i] = 0;
seqcount[i] = 0;
}
/*
** user will pass the number of residues to fit a page
** therefore we now need to calculate the size of the chars
** based on this and get the new char width.
** 'charlen' maximum characters for the name (truncated above)
*/
ajGraphicsGetCharsize(&defheight,¤tscale);
xmin = -charlen - (float)2.0;
xmax = (float)numres+(float)11.0+(float)(numres/resbreak);
xmid = (xmax + xmin)/(float)2.0;
ajGraphOpenWin(graph, xmin, xmax,
(float)0.0, ystart+(float)1.0);
ajGraphGetParamsPage(graph, &fxp,&fyp,&ixlen,&iylen,&ixoff,&iyoff);
if(portrait)
{
itmp = ixlen;
ixlen = iylen;
iylen = itmp;
}
ajGraphicsGetCharsize(&defheight,¤tscale);
ajGraphicsSetCharscale(((float)ixlen/((float)(numres+charlen+1)*
(currentscale * (float) 1.5)))/
currentscale);
/* ajGraphicsSetCharscale(((float)ixlen/((float)(numres+charlen)*
(currentscale+(float)1.0)))/
currentscale); */
ajGraphicsGetCharsize(&defheight,¤tscale);
yincr = (currentscale + (float)3.0)*(float)0.3;
/*
** If we have titles (now the standard graph title and subtitle and footer)
** leave 7 rows of space for them
*/
y=ystart-(float)7.0;
if(ajStrGetLen(options))
{
fold = ajGraphicsSetCharscale(1.0);
ajGraphicsDrawposTextAtmid(xmid,2.0,
ajStrGetPtr(options));
ajGraphicsSetCharscale(fold);
}
/* if sequences per page not set then calculate it */
if(!seqperpage)
{
seqperpage = prettyplot_calcseqperpage(yincr,y,consensus);
if(seqperpage>numseq)
seqperpage=numseq;
}
count = 0;
/*
** for boxes we need to set a foreground colour for the box lines
** and save the current foreground colour
*/
if(boxit && boxcol)
oldfg = ajGraphicsSetFgcolour(iboxcolval);
/*
** step through each residue position
*/
kmax = ajSeqsetGetLen(seqset) - 1;
for(k=0; k<= kmax; k++)
{
/* reset column score array */
for(i=0;i<numseq;i++)
score[i] = 0.0;
/* reset matrix character testing arrays */
for(i=0;i<matsize;i++)
{
identical[i] = 0.0;
matching[i] = 0.0;
colcheck[i] = 0.0;
}
/* generate a score for this residue in each sequence */
for(i=0;i<numseq;i++)
{
m1 = ajSeqcvtGetCodeK(cvt, seqcharptr[i][k]);
for(j=0;j<numseq;j++)
{
m2 = ajSeqcvtGetCodeK(cvt, seqcharptr[j][k]);
if(m1 && m2)
score[i] += (float)matrix[m1][m2]*
ajSeqsetGetseqWeight(seqset, j);
}
if(m1)
identical[m1] += ajSeqsetGetseqWeight(seqset, i);
}
/* find the highest score */
highindex = -1;
scoremax = INT_MIN;
/*ajDebug("Scores at position %d:\n", k);*/
for(i=0;i<numseq;i++)
{
/*ajDebug(" seq %d: '%c' %f\n",i,seqcharptr[i][k],score[i]);*/
if(score[i] > scoremax)
{
scoremax = score[i];
highindex = i;
}
}
for(i=0;i<numseq;i++)
{
m1 = ajSeqcvtGetCodeK(cvt, seqcharptr[i][k]);
if(!matching[m1])
{
for(j=0;j<numseq;j++)
{
m2 = ajSeqcvtGetCodeK(cvt, seqcharptr[j][k]);
if(m1 && m2 && matrix[m1][m2] > 0)
matching[m1] += ajSeqsetGetseqWeight(seqset, j);
}
}
}
/* find highs for matching and identical */
matchingmaxindex = 0;
identicalmaxindex = 0;
for(i=0;i<numseq;i++)
{
m1 = ajSeqcvtGetCodeK(cvt, seqcharptr[i][k]);
if(identical[m1] > identical[identicalmaxindex])
identicalmaxindex = m1;
}
for(i=0;i<numseq;i++)
{
m1 = ajSeqcvtGetCodeK(cvt, seqcharptr[i][k]);
if(matching[m1] > matching[matchingmaxindex])
matchingmaxindex = m1;
else if(matching[m1] == matching[matchingmaxindex])
{
if(identical[m1] > identical[matchingmaxindex])
matchingmaxindex= m1;
}
}
iscons = ajFalse;
boxindex = -1;
max = -3;
ajDebug("k:%2d highindex:%2d matching:%4.2f\n",
k, highindex,
matching[ajSeqcvtGetCodeK(cvt, seqcharptr[highindex][k])]);
if(highindex != -1 &&
matching[ajSeqcvtGetCodeK(cvt, seqcharptr[highindex][k])] >= fplural)
{
iscons = ajTrue;
boxindex = highindex;
}
else
{
for(i=0;i<numseq;i++)
{
m1 = ajSeqcvtGetCodeK(cvt, seqcharptr[i][k]);
if(matching[m1] > max)
{
max = matching[m1];
highindex = i;
}
else if(matching[m1] == max)
{
if(identical[m1] >
identical[ajSeqcvtGetCodeK(cvt,
seqcharptr[highindex][k])] )
{
max = matching[m1];
highindex = i;
}
}
}
if(matching[ajSeqcvtGetCodeK(cvt,
seqcharptr[highindex][k])] >= fplural)
{
iscons = ajTrue;
boxindex = highindex;
}
}
if(iscons)
{
if(!collision)
{
/* check for collisions */
if(alternative == 1)
{
/* check to see if this is unique for collisions */
for(i=0;i<numseq;i++)
{
m1 = ajSeqcvtGetCodeK(cvt, seqcharptr[i][k]);
if(identical[m1] >= identical[identicalmaxindex] &&
m1 != identicalmaxindex)
iscons = ajFalse;
}
/*ajDebug("after (alt=1) iscons: %B",iscons);*/
}
else if(alternative == 2)
{
for(i=0;i<numseq;i++)
{
m1 = ajSeqcvtGetCodeK(cvt, seqcharptr[i][k]);
if((matching[m1] >= matching[matchingmaxindex] &&
m1 != matchingmaxindex &&
matrix[m1][matchingmaxindex] < 0.1)||
(identical[m1] >= identical[matchingmaxindex]
&& m1 != matchingmaxindex))
iscons = ajFalse;
}
}
else if(alternative == 3)
{
/*
** to do this check one is NOT in consensus to see if
** another score of fplural has been found
*/
ms = ajSeqcvtGetCodeK(cvt, seqcharptr[highindex][k]);
for(i=0;i<numseq;i++)
{
m1 = ajSeqcvtGetCodeK(cvt, seqcharptr[i][k]);
if(ms != m1 && colcheck[m1] == 0.0)
/* NOT in the current consensus */
for(j=0;j<numseq;j++)
{
m2 = ajSeqcvtGetCodeK(cvt, seqcharptr[j][k]);
if( matrix[ms][m2] < 0.1)
{
/* NOT in the current consensus */
if( matrix[m1][m2] > 0.1)
colcheck[m1] +=
ajSeqsetGetseqWeight(seqset,
j);
}
}
}
for(i=0;i<numseq;i++)
{
m1 = ajSeqcvtGetCodeK(cvt, seqcharptr[i][k]);
/* if any other matches then we have a collision */
if(colcheck[m1] >= fplural)
iscons = ajFalse;
}
/*ajDebug("after alt=2 iscons: %B", iscons);*/
}
else
{
for(i=0;i<numseq;i++)
{
m1 = ajSeqcvtGetCodeK(cvt, seqcharptr[i][k]);
if((matching[m1] >= matching[matchingmaxindex] &&
m1 != matchingmaxindex &&
matrix[m1][matchingmaxindex] < 0.1))
iscons = ajFalse;
if(identical[m1] >= identical[matchingmaxindex] &&
m1 != matchingmaxindex &&
matrix[m1][matchingmaxindex] > 0.1)
iscons = ajFalse;
}
if(!iscons)
{ /* matches failed try identicals */
if(identical[identicalmaxindex] >= fplural)
{
iscons = ajTrue;
/*
** if nothing has an equal or higher match that
** does not match highest then false
*/
for(i=0;i<numseq;i++)
{
m1 = ajSeqcvtGetCodeK(cvt, seqcharptr[i][k]);
if(identical[m1] >=
identical[identicalmaxindex] &&
m1 != identicalmaxindex)
iscons = ajFalse;
else if(matching[m1] >=
matching[identicalmaxindex] &&
matrix[m1][matchingmaxindex] <= 0.0)
iscons = ajFalse;
else if(m1 == identicalmaxindex)
j = i;
}
if(iscons)
highindex = j;
}
}
}
}
if(identity)
{
j = 0;
for(i=0;i<numseq;i++)
if(seqcharptr[highindex][k] == seqcharptr[i][k])
j++;
if(j<identity)
iscons = ajFalse;
}
}
/*
** Done a full line of residues
** Boxes have been defined up to this point
*/
if(count >= numres )
{
/* check y position for next set */
y=y-(yincr*((float)numseq+(float)2.0+((float)consensus*(float)2)));
if(y<yincr*((float)numseq+(float)2.0+((float)consensus*(float)2)))
{
/* full page - print it */
y=ystart-(float)6.0;
startseq = 0;
endseq = seqperpage;
newILstart = newILend;
newILend = k;
while(startseq < numseq)
{
/* AJB */
/*if(startseq != 0)
ajGraphNewpage(graph, AJFALSE);*/
/*ajDebug("Inner loop: startseq: %d numseq: %d endseq: %d\n",
startseq, numseq, endseq);*/
if(endseq>numseq)
endseq=numseq;
prettyplot_fillinboxes(numseq,ajSeqsetGetLen(seqset),
startseq,endseq,
newILstart,newILend,
numres,resbreak,
boxit,boxcol,consensus,
ystart,yincr,cvt);
startseq = endseq;
endseq += seqperpage;
ajGraphNewpage(graph, AJFALSE);
}
}
count = 0;
gapcount = 0;
}
count++;
countforgap++;
for(j=0;j<numseq;j++)
{
/* START OF BOXES */
if(boxit)
{
seqboxptr[j][k] = 0;
if(boxindex!=-1)
{
myindex = boxindex;
if(matrix[ajSeqcvtGetCodeK(cvt, seqcharptr[j][k])]
[ajSeqcvtGetCodeK(cvt, seqcharptr[myindex][k])] > 0)
part = 1.0;
else
{
if(identical[ajSeqcvtGetCodeK(cvt,
seqcharptr[j][k])] >=
fplural)
part = 1.0;
else
part = 0.0;
}
if(previous[j] != part)
/* draw vertical line */
seqboxptr[j][k] |= BOXLEF;
if(j==0)
{
/* special case for horizontal line */
if(part)
{
currentstate = 1;
/* draw hori line */
seqboxptr[j][k] |= BOXTOP;
}
else
currentstate = 0;
}
else
{
/* j != 0 Normal case for horizontal line */
if(part != currentstate)
{
/*draw hori line */
seqboxptr[j][k] |= BOXTOP;
currentstate = (ajint) part;
}
}
if(j== numseq-1 && currentstate)
/* draw horiline at bottom */
seqboxptr[j][k] |= BOXBOT;
previous[j] = (ajint) part;
}
else
{
part = 0;
if(previous[j])
{
/* draw vertical line */
seqboxptr[j][k] |= BOXLEF;
}
previous[j] = 0;
}
if(count == numres || k == kmax || countforgap >= resbreak )
{ /* last one on the row or a break*/
if(previous[j])
{
/* draw vertical line */
seqboxptr[j][k] |= BOXRIG;
}
previous[j] = 0;
}
} /* end box */
if(boxit && boxcol)
if(boxindex != -1)
{
myindex = boxindex;
if(matrix[ajSeqcvtGetCodeK(cvt, seqcharptr[j][k])]
[ajSeqcvtGetCodeK(cvt, seqcharptr[myindex][k])] > 0
|| identical[ajSeqcvtGetCodeK(cvt, seqcharptr[j][k])] >=
fplural )
seqboxptr[j][k] |= BOXCOLOURED;
}
/* END OF BOXES */
if(ajSeqcvtGetCodeK(cvt, seqcharptr[j][k]))
res[0] = seqcharptr[j][k];
else
res[0] = '-';
if(colourbyconsensus)
{
part = (float) matrix[ajSeqcvtGetCodeK(cvt, seqcharptr[j][k])]
[ajSeqcvtGetCodeK(cvt, seqcharptr[highindex][k])];
if(iscons && seqcharptr[highindex][k] == seqcharptr[j][k])
seqcolptr[j][k] = cidentity;
else if(part > 0.0)
seqcolptr[j][k] = csimilarity;
else
seqcolptr[j][k] = cother;
}
else if(colourbyresidues)
seqcolptr[j][k] = colmat[ajSeqcvtGetCodeK(cvt,
seqcharptr[j][k])];
else if(iscons && colourbyshade)
{
part = (float) matrix[ajSeqcvtGetCodeK(cvt, seqcharptr[j][k])]
[ajSeqcvtGetCodeK(cvt, seqcharptr[highindex][k])];
if(part >= 1.5)
seqcolptr[j][k] = shadecolour[0];
else if(part >= 1.0)
seqcolptr[j][k] = shadecolour[1];
else if(part >= 0.5)
seqcolptr[j][k] = shadecolour[2];
else
seqcolptr[j][k] = shadecolour[3];
}
else if(colourbyshade)
seqcolptr[j][k] = shadecolour[3];
else
seqcolptr[j][k] = BLACK;
}
if(consensus)
{
if(iscons)
res[0] = seqcharptr[highindex][k];
else
res[0] = '-';
strcat(constr,res);
}
if(countforgap >= resbreak)
{
gapcount++;
countforgap=0;
}
}
startseq = 0;
endseq=seqperpage;
newILstart = newILend;
newILend = k;
while(startseq < numseq)
{
if(startseq)
ajGraphNewpage(graph, AJFALSE);
/*ajDebug("Final loop: startseq: %d numseq: %d endseq: %d\n",
startseq, numseq, endseq);*/
if(endseq>numseq)
endseq = numseq;
prettyplot_fillinboxes(numseq,ajSeqsetGetLen(seqset),
startseq,endseq,
newILstart,newILend,
numres,resbreak,
boxit,boxcol,consensus,
ystart,yincr,cvt);
startseq = endseq;
endseq += seqperpage;
}
ajGraphicsGetCharsize(&defheight,¤tscale);
if(boxit && boxcol)
oldfg = ajGraphicsSetFgcolour(oldfg);
ajGraphicsCloseWin();
ajGraphxyDel(&graph);
ajStrDel(&sidentity);
ajStrDel(&ssimilarity);
ajStrDel(&sother);
ajStrDel(&options);
ajStrDel(&altstr);
ajStrDel(&matcodes);
for(i=0;i<numseq;i++)
{
ajStrDel(&seqnames[i]);
AJFREE(seqcolptr[i]);
if(seqboxptr)
AJFREE(seqboxptr[i]);
}
AJFREE(seqcolptr);
AJFREE(seqboxptr);
AJFREE(seqnames);
AJFREE(score);
AJFREE(previous);
AJFREE(seqcount);
AJFREE(colmat);
AJFREE(shadecolour);
freeptr = (void *) seqcharptr;
AJFREE(freeptr);
AJFREE(identical);
AJFREE(matching);
AJFREE(colcheck);
ajSeqsetDel(&seqset);
ajMatrixDel(&cmpmatrix);
ajStrDel(&shade);
ajStrDel(&sboxcolval);
ajStrDel(&sidentity);
ajStrDel(&ssimilarity);
ajStrDel(&sother);
ajFloatDel(&pair);
ajTimeDel(&ajtime);
AJFREE(constr);
embExit();
return 0;
}
int main(int argc, char **argv)
{
/* ACD data item variables */
AjPSeqset alignfile = NULL;
AjPFile prior = NULL;
AjPFile null = NULL;
AjPFile pam = NULL;
float pamwgt = 0.0;
AjPStr nhmm = NULL;
AjPStr strategy = NULL;
ajint pbswitch = 0;
float archpri = 0.0;
AjBool binary = ajFalse;
AjBool fast = ajFalse;
float gapmax = 0.0;
AjBool hand = ajFalse;
float idlevel = 0.0;
AjBool noeff = ajFalse;
float swentry = 0.0;
float swexit = 0.0;
AjBool verbosity = ajFalse;
AjPStr weighting = NULL;
AjPFile hmmfile = NULL;
AjPFile o = NULL;
AjPFile cfile = NULL;
/* Housekeeping variables */
AjPStr cmd = NULL;
AjPStr rnd1 = NULL;
AjPStr rnd2 = NULL;
AjPStr tmp = NULL;
AjPStr fmt = NULL;
char option;
AjBool fmtok = ajFalse;
AjPStr hmmfilename = NULL;
/* ACD file processing */
embInitPV("ehmmbuild",argc,argv,"HMMERNEW",VERSION);
alignfile = ajAcdGetSeqset("alignfile");
prior = ajAcdGetInfile("prior");
null = ajAcdGetInfile("null");
pam = ajAcdGetInfile("pam");
pamwgt = ajAcdGetFloat("pamwgt");
nhmm = ajAcdGetString("nhmm");
strategy = ajAcdGetListSingle("strategy");
pbswitch = ajAcdGetInt("pbswitch");
archpri = ajAcdGetFloat("archpri");
binary = ajAcdGetBoolean("binary");
fast = ajAcdGetBoolean("fast");
gapmax = ajAcdGetFloat("gapmax");
hand = ajAcdGetBoolean("hand");
idlevel = ajAcdGetFloat("sidlevel");
noeff = ajAcdGetBoolean("noeff");
swentry = ajAcdGetFloat("swentry");
swexit = ajAcdGetFloat("swexit");
verbosity = ajAcdGetBoolean("verbosity");
weighting = ajAcdGetListSingle("weighting");
hmmfile = ajAcdGetOutfile("hmmfile");
o = ajAcdGetOutfile("o");
cfile = ajAcdGetOutfile("cfile");
/* MAIN APPLICATION CODE */
/* 1. Housekeeping */
cmd = ajStrNew();
rnd1 = ajStrNew();
rnd2 = ajStrNew();
tmp = ajStrNew();
fmt = ajStrNew();
hmmfilename = ajStrNew();
ajStrAssignC(&hmmfilename, ajFileGetNameC(hmmfile));
/* 2. Ensure alignfile is in format HMMER can understand. These include
FASTA, GENBANK,EMBL, GCG, PIR, STOCKHOLM, SELEX, MSF,CLUSTAL and PHYLIP.
EMBOSS name definitions are taken from seqInFormatDef in ajseqread.c and
seqOutFormat in ajseqwrite.c */
fmtok=ajFalse;
ajStrAssignS(&fmt, ajSeqsetGetFormat(alignfile));
if(ajStrMatchC(fmt, "fasta") ||
ajStrMatchC(fmt, "genbank") ||
ajStrMatchC(fmt, "embl") ||
ajStrMatchC(fmt, "gcg") ||
ajStrMatchC(fmt, "pir") ||
ajStrMatchC(fmt, "stockholm")||
ajStrMatchC(fmt, "selex") ||
ajStrMatchC(fmt, "msf") ||
ajStrMatchC(fmt, "clustal") ||
ajStrMatchC(fmt, "phylip"))
fmtok = ajTrue;
/* This could be replaced with code to reformat the file. */
if(!fmtok)
ajFatal("Input alignment ('alignfile' ACD option) is not in format "
"HMMER understands. Please use a a file in FASTA, GENBANK, "
"EMBL, GCG, PIR, STOCKHOLM, SELEX, MSF,CLUSTAL or PHYLIP format.");
/* 3. Build hmmbuild 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("hmmbuild"));
if(prior)
ajFmtPrintAppS(&cmd, " --prior %s ", ajFileGetNameC(prior));
if(null)
ajFmtPrintS(&cmd, " --null %s ", ajFileGetNameC(null));
if(pam)
ajFmtPrintAppS(&cmd, " --pam %s --pamwgt %f ", ajFileGetNameC(pam), pamwgt);
ajFmtPrintAppS(&cmd, " -n %S ", nhmm);
/* ACD option only allows one selection */
option = ajStrGetCharFirst(strategy);
if(option == 'F')
ajStrAppendC(&cmd, " -f ");
else if(option == 'G')
ajStrAppendC(&cmd, " -g ");
else if(option == 'S')
ajStrAppendC(&cmd, " -s ");
/* else go with default ('D' option in ACD file) */
ajFmtPrintAppS(&cmd, " --pbswitch %d ", pbswitch);
ajFmtPrintAppS(&cmd, " --archpri %f ", archpri);
if(binary)
ajStrAppendC(&cmd, " --binary ");
if(fast)
ajFmtPrintAppS(&cmd, " --fast --gapmax %f ", gapmax);
if(hand)
ajStrAppendC(&cmd, " --hand ");
ajFmtPrintAppS(&cmd, " --idlevel %f ", idlevel);
if(noeff)
ajStrAppendC(&cmd, " --noeff ");
ajFmtPrintAppS(&cmd, " --swentry %f ", swentry);
ajFmtPrintAppS(&cmd, " --swexit %f ", swexit);
if(verbosity)
ajStrAppendC(&cmd, " --verbose ");
/* ACD option only allows one selection */
option = ajStrGetCharFirst(weighting);
if(option == 'B')
ajStrAppendC(&cmd, " --wblosum ");
else if(option == 'G')
ajStrAppendC(&cmd, " --wgsc ");
else if(option == 'K')
ajStrAppendC(&cmd, " --wme ");
else if(option == 'W')
ajStrAppendC(&cmd, " --wpb ");
else if(option == 'V')
ajStrAppendC(&cmd, " --wvoronoi ");
else if(option == 'N')
ajStrAppendC(&cmd, " --wnone ");
if(o)
ajFmtPrintAppS(&cmd, " -o %s ", ajFileGetNameC(o));
if(cfile)
ajFmtPrintAppS(&cmd, " --cfile %s ", ajFileGetNameC(cfile));
/* -A (append) always set but file will be wiped by EMBOSS first unless
append: "Y" is set for "hmmfile" in the ACD file. */
ajStrAppendC(&cmd, " -A -F ");
ajFmtPrintAppS(&cmd, " %S %S", hmmfilename, ajSeqsetGetFilename(alignfile));
/* 4. Close ACD files */
ajSeqsetDel(&alignfile);
ajFileClose(&prior);
ajFileClose(&null);
ajFileClose(&pam);
ajFileClose(&hmmfile);
ajFileClose(&o);
ajFileClose(&cfile);
/* 5. Call hmmbuild */
ajFmtPrint("\n%S\n", cmd);
system(ajStrGetPtr(cmd));
/* 6. Exit cleanly */
ajStrDel(&nhmm);
ajStrDel(&cmd);
ajStrDel(&rnd1);
ajStrDel(&rnd2);
ajStrDel(&tmp);
ajStrDel(&fmt);
ajStrDel(&hmmfilename);
ajStrDel(&strategy);
ajStrDel(&weighting);
embExit();
return 0;
}
int main(int argc, char *argv[])
{
char *string/*, *line*/;
char *structure=NULL, *cstruc=NULL;
/*char fname[53], ffname[60]; */
/*char *ParamFile=NULL; */
char *ns_bases=NULL, *c;
char *Concfile;
int i, length, l, sym/*, r*/;
double min_en;
double kT, sfact=1.07;
int pf=0, istty;
int noconv=0;
int doT=0; /*compute dimere free energies etc.*/
int doC=0; /*toggle to compute concentrations*/
int doQ=0; /*toggle to compute prob of base being paired*/
int cofi=0; /*toggle concentrations stdin / file*/
struct plist *prAB;
struct plist *prAA; /*pair probabilities of AA dimer*/
struct plist *prBB;
struct plist *prA;
struct plist *prB;
struct plist *mfAB;
struct plist *mfAA; /*pair mfobabilities of AA dimer*/
struct plist *mfBB;
struct plist *mfA;
struct plist *mfB;
double *ConcAandB;
AjPSeq seq1 = NULL;
AjPFile confile1 = NULL;
AjPSeq seq2 = NULL;
AjPFile confile2 = NULL;
AjPFile concfile = NULL;
AjPFile paramfile = NULL;
AjPFile outf = NULL;
AjPFile essfile = NULL;
AjPFile dotfile = NULL;
AjPFile aoutf = NULL;
AjPFile aaoutf = NULL;
AjPFile boutf = NULL;
AjPFile bboutf = NULL;
AjPFile aboutf = NULL;
AjPStr seqstring1 = NULL;
AjPStr constring1 = NULL;
AjPStr constring2 = NULL;
float eT = 0.;
AjBool eGU;
AjBool eclose;
AjBool lonely;
AjBool convert;
AjPStr ensbases = NULL;
AjBool etloop;
AjPStr eenergy = NULL;
char ewt = '\0';
float escale = 0.;
AjPStr edangles = NULL;
char edangle = '\0';
/* AjBool dimers; */
/* AjBool paired; */
embInitPV("vrnacofold",argc,argv,"VIENNA",VERSION);
seqstring1 = ajStrNew();
constring1 = ajStrNew();
constring2 = ajStrNew();
seq1 = ajAcdGetSeq("asequence");
confile1 = ajAcdGetInfile("aconstraintfile");
seq2 = ajAcdGetSeq("bsequence");
confile2 = ajAcdGetInfile("bconstraintfile");
paramfile = ajAcdGetInfile("paramfile");
eT = ajAcdGetFloat("temperature");
eGU = ajAcdGetBoolean("gu");
eclose = ajAcdGetBoolean("closegu");
lonely = ajAcdGetBoolean("lp");
convert = ajAcdGetBoolean("convert");
ensbases = ajAcdGetString("nsbases");
etloop = ajAcdGetBoolean("tetraloop");
eenergy = ajAcdGetListSingle("energy");
escale = ajAcdGetFloat("scale");
edangles = ajAcdGetListSingle("dangles");
/* dimers = ajAcdGetBoolean("dimers"); */
/* paired = ajAcdGetBoolean("paired"); */
outf = ajAcdGetOutfile("outfile");
essfile = ajAcdGetOutfile("ssoutfile");
/* concfile = ajAcdGetInfile("concentrationfile"); */
/* dotfile = ajAcdGetOutfile("dotoutfile"); */
/*
aoutf = ajAcdGetOutfile("aoutfile");
aaoutf = ajAcdGetOutfile("aaoutfile");
boutf = ajAcdGetOutfile("boutfile");
bboutf = ajAcdGetOutfile("bboutfile");
aboutf = ajAcdGetOutfile("aboutfile");
*/
do_backtrack = 1;
pf = 0;
doT = 0;
doC = 0;
cofi = 0;
doQ = 0;
string = NULL;
Concfile = NULL;
istty = 0;
temperature = (double) eT;
noGU = (eGU) ? 0 : 1;
no_closingGU = (eclose) ? 0 : 1;
noLonelyPairs = (lonely) ? 0 : 1;
noconv = (convert) ? 0 : 1;
ns_bases = (ajStrGetLen(ensbases)) ? MAJSTRGETPTR(ensbases) : NULL;
tetra_loop = !!etloop;
ewt = *ajStrGetPtr(eenergy);
if(ewt == '0')
energy_set = 0;
else if(ewt == '1')
energy_set = 1;
else if(ewt == '2')
energy_set = 2;
sfact = (double) escale;
edangle = *ajStrGetPtr(edangles);
if(edangle == '0')
dangles = 0;
else if(edangle == '1')
dangles = 1;
else if(edangle == '2')
dangles = 2;
else if(edangle == '3')
dangles = 3;
if(paramfile)
read_parameter_file(paramfile);
if (ns_bases != NULL)
{
nonstandards = space(33);
c=ns_bases;
i=sym=0;
if (*c=='-')
{
sym=1; c++;
}
while (*c!='\0')
{
if (*c!=',')
{
nonstandards[i++]=*c++;
nonstandards[i++]=*c;
if ((sym)&&(*c!=*(c-1)))
{
nonstandards[i++]=*c;
nonstandards[i++]=*(c-1);
}
}
c++;
}
}
cut_point = -1;
ajFmtPrintS(&seqstring1,"%s&%s",ajSeqGetSeqC(seq1),ajSeqGetSeqC(seq2));
string = tokenize(MAJSTRGETPTR(seqstring1)); /* frees line */
length = (int) strlen(string);
if (doC)
{
ConcAandB = read_concentrations(concfile);
}
structure = (char *) space((unsigned) length+1);
if(confile1)
{
vienna_GetConstraints(confile1,&constring1);
vienna_GetConstraints(confile2,&constring2);
ajStrAppendK(&constring1,'&');
ajStrAppendS(&constring1,constring2);
cstruc = tokenize(MAJSTRGETPTR(constring1));
if (cstruc!=NULL)
strncpy(structure, cstruc, length);
else
ajFatal("Constraints missing\n");
}
for (l = 0; l < length; l++)
{
string[l] = toupper(string[l]);
if (!noconv && string[l] == 'T') string[l] = 'U';
}
/*compute mfe of AB dimer*/
min_en = cofold(string, structure);
mfAB=(struct plist *) space(sizeof(struct plist) * (length+1));
mfAB=get_mfe_plist(mfAB);
if (cut_point == -1)
ajFmtPrintF(outf,"%s\n%s", string, structure); /*no cofold*/
else
{
char *pstring, *pstruct;
pstring = costring(string);
pstruct = costring(structure);
ajFmtPrintF(outf,"%s\n%s", pstring, pstruct);
free(pstring);
free(pstruct);
}
ajFmtPrintF(outf," (%6.2f)\n", min_en);
if (length<2000)
(void) PS_rna_plot(string, structure, essfile);
else
{
ajWarn("Structure too long, not doing xy_plot\n");
free_co_arrays();
}
/*compute partition function*/
if (pf)
{
cofoldF AB, AA, BB;
if (dangles==1)
{
dangles=2; /* recompute with dangles as in pf_fold() */
min_en = energy_of_struct(string, structure);
dangles=1;
}
kT = (temperature+273.15)*1.98717/1000.; /* in Kcal */
pf_scale = exp(-(sfact*min_en)/kT/length);
if (length>2000)
ajWarn("scaling factor %f\n", pf_scale);
init_co_pf_fold(length);
if (cstruc!=NULL)
strncpy(structure, cstruc, length+1);
AB = co_pf_fold(string, structure);
if (do_backtrack)
{
char *costruc;
costruc = (char *) space(sizeof(char)*(strlen(structure)+2));
if (cut_point<0)
ajFmtPrintF(outf,"%s", structure);
else
{
strncpy(costruc, structure, cut_point-1);
strcat(costruc, "&");
strcat(costruc, structure+cut_point-1);
ajFmtPrintF(outf,"%s", costruc);
}
ajFmtPrintF(outf," [%6.2f]\n", AB.FAB);
}
if ((istty)||(!do_backtrack))
ajFmtPrintF(outf," free energy of ensemble = %6.2f kcal/mol\n",
AB.FAB);
ajFmtPrintF(outf," frequency of mfe structure in ensemble %g",
exp((AB.FAB-min_en)/kT));
ajFmtPrintF(outf," , delta G binding=%6.2f\n", AB.FcAB - AB.FA - AB.FB);
prAB=(struct plist *) space(sizeof(struct plist) * (2*length));
prAB=get_plist(prAB, length,0.00001);
/* if (doQ) make_probsum(length,fname); */ /*compute prob of base paired*/
/* free_co_arrays(); */
if (doT)
{ /* cofold of all dimers, monomers */
int Blength, Alength;
char *Astring, *Bstring;
char *Newstring;
/*char Newname[30];*/
char comment[80];
if (cut_point<0)
{
free(mfAB);
free(prAB);
ajFatal("Sorry, I cannot do that with only one molecule, "
"please give me two\n");
}
if (dangles==1)
dangles=2;
Alength=cut_point-1; /*length of first molecule*/
Blength=length-cut_point+1; /*length of 2nd molecule*/
/*Sequence of first molecule*/
Astring=(char *)space(sizeof(char)*(Alength+1));
/*Sequence of second molecule*/
Bstring=(char *)space(sizeof(char)*(Blength+1));
strncat(Astring,string,Alength);
strncat(Bstring,string+Alength,Blength);
/* compute AA dimer */
prAA=(struct plist *) space(sizeof(struct plist) * (4*Alength));
mfAA=(struct plist *) space(sizeof(struct plist) * (Alength+1));
AA=do_partfunc(Astring, Alength, 2, &prAA, &mfAA);
/* compute BB dimer */
prBB=(struct plist *) space(sizeof(struct plist) * (4*Blength));
mfBB=(struct plist *) space(sizeof(struct plist) * (Blength+1));
BB=do_partfunc(Bstring, Blength, 2, &prBB, &mfBB);
/*free_co_pf_arrays();*/
/* compute A monomer */
prA=(struct plist *) space(sizeof(struct plist) * (2*Alength));
mfA=(struct plist *) space(sizeof(struct plist) * (Alength+1));
do_partfunc(Astring, Alength, 1, &prA, &mfA);
/* compute B monomer */
prB=(struct plist *) space(sizeof(struct plist) * (2*Blength));
mfB=(struct plist *) space(sizeof(struct plist) * (Blength+1));
do_partfunc(Bstring, Blength, 1, &prB, &mfB);
compute_probabilities(AB.F0AB, AB.FA, AB.FB, prAB, prA, prB,
Alength);
compute_probabilities(AA.F0AB, AA.FA, AA.FA, prAA, prA, prA,
Alength);
compute_probabilities(BB.F0AB, BB.FA, BB.FA, prBB, prA, prB,
Blength);
ajFmtPrintF(outf,"Free Energies:\nAB\t\tAA\t\tBB\t\tA\t\tB\n%.6f"
"\t%6f\t%6f\t%6f\t%6f\n",
AB.FcAB, AA.FcAB, BB.FcAB, AB.FA, AB.FB);
if (doC)
{
do_concentrations(AB.FcAB, AA.FcAB, BB.FcAB, AB.FA, AB.FB,
ConcAandB, outf);
free(ConcAandB);/*freeen*/
}
/*AB dot_plot*/
/*write Free Energy into comment*/
sprintf(comment,"\n%%Heterodimer AB FreeEnergy= %.9f\n", AB.FcAB);
/*reset cut_point*/
cut_point=Alength+1;
(void)PS_dot_plot_list(string, aboutf, prAB, mfAB, comment);
/*AA dot_plot*/
sprintf(comment,"\n%%Homodimer AA FreeEnergy= %.9f\n",AA.FcAB);
/*write AA sequence*/
Newstring=(char*)space((2*Alength+1)*sizeof(char));
strcpy(Newstring,Astring);
strcat(Newstring,Astring);
(void)PS_dot_plot_list(Newstring, aaoutf, prAA, mfAA, comment);
free(Newstring);
/*BB dot_plot*/
sprintf(comment,"\n%%Homodimer BB FreeEnergy= %.9f\n",BB.FcAB);
/*write BB sequence*/
Newstring=(char*)space((2*Blength+1)*sizeof(char));
strcpy(Newstring,Bstring);
strcat(Newstring,Bstring);
/*reset cut_point*/
cut_point=Blength+1;
(void)PS_dot_plot_list(Newstring, bboutf, prBB, mfBB, comment);
free(Newstring);
/*A dot plot*/
/*reset cut_point*/
cut_point=-1;
sprintf(comment,"\n%%Monomer A FreeEnergy= %.9f\n",AB.FA);
/*write A sequence*/
(void)PS_dot_plot_list(Astring, aoutf, prA, mfA, comment);
/*B monomer dot plot*/
sprintf(comment,"\n%%Monomer B FreeEnergy= %.9f\n",AB.FB);
/*write B sequence*/
(void)PS_dot_plot_list(Bstring, boutf, prB, mfB, comment);
free(Astring);
free(Bstring);
free(prAB);
free(prAA);
free(prBB);
free(prA);
free(prB);
free(mfAB);
free(mfAA);
free(mfBB);
free(mfA);
free(mfB);
} /*end if(doT)*/
}/*end if(pf)*/
if (do_backtrack)
{
if (!doT)
{
if (pf)
{
(void) PS_dot_plot_list(string, dotfile, prAB, mfAB, "doof");
free(prAB);
}
free(mfAB);
}
}
if (!doT)
free_co_pf_arrays();
if (cstruc!=NULL)
free(cstruc);
free(string);
free(structure);
ajStrDel(&seqstring1);
ajStrDel(&constring1);
ajStrDel(&constring2);
ajSeqDel(&seq1);
ajSeqDel(&seq2);
ajStrDel(&ensbases);
ajStrDel(&eenergy);
ajStrDel(&edangles);
ajFileClose(&confile1);
ajFileClose(&confile2);
ajFileClose(¶mfile);
ajFileClose(&outf);
ajFileClose(&essfile);
if (length<2000)
free_co_arrays();
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPList sigin = NULL; /* Signature input file names. */
AjPStr signame = NULL; /* Name of signature file. */
AjPFile sigf = NULL; /* Signature input file. */
EmbPSignature sig = NULL; /* Signature. */
AjPList siglist = NULL; /* List of signatures. */
AjIList sigiter = NULL; /* Iterator for siglist. */
AjBool sigok = ajFalse; /* True if signature processed ok. */
EmbPHit hit = NULL; /* Hit to store signature-sequence match. */
AjPList hits = NULL; /* List of hits */
AjPList ligands = NULL; /* List of top-scoring ligands. */
AjPSeqall database=NULL; /* Protein sequences to match signature
against. */
AjPSeq seq = NULL; /* Current sequence. */
AjPMatrixf sub =NULL; /* Residue substitution matrix. */
float gapo =0.0; /* Gap insertion penalty. */
float gape =0.0; /* Gap extension penalty. */
AjPStr nterm=NULL; /* Holds N-terminal matching options from
acd. */
ajint ntermi=0; /* N-terminal option as int. */
AjPFile hitsf =NULL; /* Hits output file.
sequence matches. */
AjPDirout hitsdir=NULL; /* Directory of hits files (output). */
AjPFile alignf =NULL; /* Alignment output file. */
AjPDirout aligndir=NULL; /* Directory of alignment files (output). */
AjPFile resultsf =NULL; /* Results file (output). */
AjPDirout resultsdir=NULL; /* Directory of results files (output). */
AjPStr mode = NULL; /* Mode, 1: Patch score mode, 2:
Site score mode. */
ajint modei = 0; /* Selected mode as integer. */
SigPLighit lighit = NULL;
embInitPV("sigscanlig", argc, argv, "SIGNATURE",VERSION);
/* GET VALUES FROM ACD */
sigin = ajAcdGetDirlist("siginfilesdir");
database = ajAcdGetSeqall("dbseqall");
sub = ajAcdGetMatrixf("sub");
gapo = ajAcdGetFloat("gapo");
gape = ajAcdGetFloat("gape");
nterm = ajAcdGetListSingle("nterm");
hitsdir = ajAcdGetOutdir("hitsoutdir");
aligndir = ajAcdGetOutdir("alignoutdir");
resultsdir = ajAcdGetOutdir("resultsoutdir");
mode = ajAcdGetListSingle("mode");
/*Assign N-terminal matching option etc. */
ajFmtScanS(nterm, "%d", &ntermi);
modei = (ajint) ajStrGetCharFirst(mode)-48;
/* READ & PROCESS SIGNATURES */
siglist = ajListNew();
while(ajListPop(sigin, (void **) &signame))
{
/* Read signature files, compile signatures and populate list. */
sigok = ajFalse;
if((sigf = ajFileNewInNameS(signame)))
if((sig = embSignatureReadNew(sigf)))
if(embSignatureCompile(&sig, gapo, gape, sub))
{
sigok=ajTrue;
ajListPushAppend(siglist, sig);
/*
ajFmtPrint("Id: %S\nDomid: %S\nLigid: %S\nns: %d\n"
"sn: %d\nnp: %d\npn: %d\nminpatch: %d\n"
"maxgap: %d\n",
sig->Id, sig->Domid, sig->Ligid, sig->ns,
sig->sn, sig->np, sig->pn, sig->minpatch,
sig->maxgap); */
}
if(!sigok)
{
ajWarn("Could not process %S", signame);
embSignatureDel(&sig);
ajFileClose(&sigf);
ajStrDel(&signame);
continue;
}
ajFileClose(&sigf);
ajStrDel(&signame);
}
ajListFree(&sigin);
/* ALIGN EACH QUERY SEQUENCE TO LIST OF SIGNATURE */
while(ajSeqallNext(database, &seq))
{
/* Do sequence-signature alignment and save results */
hits = ajListNew();
sigiter = ajListIterNew(siglist);
while((sig = (EmbPSignature) ajListIterGet(sigiter)))
{
if(embSignatureAlignSeq(sig, seq, &hit, ntermi))
{
hit->Sig = sig;
ajListPushAppend(hits, hit);
hit=NULL; /* To force reallocation by embSignatureAlignSeq */
}
/* There has to be a hit for each signature for correct
generation of the LHF by sigscanlig_WriteFasta. So push
an empty hit if necessary. 'hit'=NULL forces
reallocation by embSignatureAlignSeq. */
/*
else
{
hit = embHitNew();
ajListPushAppend(hits, hit);
hit=NULL;
}
*/
}
ajListIterDel(&sigiter);
/* Rank-order the list of hits by score */
ajListSort(hits, embMatchinvScore);
/* Write ligand hits & alignment files (output) */
hitsf = ajFileNewOutNameDirS(ajSeqGetNameS(seq), hitsdir);
alignf = ajFileNewOutNameDirS(ajSeqGetNameS(seq), aligndir);
resultsf = ajFileNewOutNameDirS(ajSeqGetNameS(seq), resultsdir);
/* if((!sigscanlig_WriteFasta(hitsf, siglist, hits)))
ajFatal("Bad args to sigscanlig_WriteFasta"); */
if((!sigscanlig_WriteFasta(hitsf, hits)))
ajFatal("Bad args to sigscanlig_WriteFasta");
if((!sigscanlig_SignatureAlignWriteBlock(alignf, hits)))
ajFatal("Bad args to sigscanlig_SignatureAlignWriteBlock");
/* if((!sigscanlig_SignatureAlignWriteBlock(alignf, siglist, hits)))
ajFatal("Bad args to sigscanlig_SignatureAlignWriteBlock"); */
/* Sort list of hits by ligand type and site number.
Process list of ligands and print out. */
ajListSortTwo(hits, embMatchLigid, embMatchSN);
if(modei==1)
ligands = sigscanlig_score_ligands_patch(hits);
else if(modei==2)
ligands = sigscanlig_score_ligands_site(hits);
else
ajFatal("Unrecognised mode");
sigscanlig_WriteResults(ligands, resultsf);
ajFileClose(&hitsf);
ajFileClose(&alignf);
ajFileClose(&resultsf);
/* Memory management */
while(ajListPop(hits, (void **) &hit))
embHitDel(&hit);
ajListFree(&hits);
while(ajListPop(ligands, (void **) &lighit))
sigscanlig_LigHitDel(&lighit);
ajListFree(&ligands);
}
/* MEMORY MANAGEMENT */
while(ajListPop(siglist, (void **) &sig))
embSignatureDel(&sig);
ajListFree(&siglist);
ajSeqallDel(&database);
ajMatrixfDel(&sub);
ajStrDel(&nterm);
ajDiroutDel(&hitsdir);
ajDiroutDel(&aligndir);
ajDiroutDel(&resultsdir);
ajStrDel(&mode);
embExit();
return 0;
}
int main(int argc, char *argv[])
{
char *sequence;
char *structure = NULL;
char *ns_bases = NULL, *c;
int i, length, l, sym;
int istty;
double deltap=0.;
int delta=100;
int n_back = 0;
int noconv=0;
int circ=0;
int dos=0;
AjPSeq seq = NULL;
AjPFile confile = NULL;
AjPFile paramfile = NULL;
AjPFile outf = NULL;
AjPStr constring = NULL;
float eT = 0.;
AjBool eGU;
AjBool eclose;
AjBool lonely;
AjBool convert;
AjPStr ensbases = NULL;
AjBool etloop;
AjPStr edangles = NULL;
char edangle = '\0';
ajint len;
float erange;
float prange;
embInitPV("vrnasubopt",argc,argv,"VIENNA",VERSION);
constring = ajStrNew();
seq = ajAcdGetSeq("sequence");
confile = ajAcdGetInfile("constraintfile");
paramfile = ajAcdGetInfile("paramfile");
eT = ajAcdGetFloat("temperature");
circ = !!ajAcdGetBoolean("circular");
dos = !!ajAcdGetBoolean("dos");
eGU = ajAcdGetBoolean("gu");
eclose = ajAcdGetBoolean("closegu");
lonely = ajAcdGetBoolean("lp");
convert = ajAcdGetBoolean("convert");
ensbases = ajAcdGetString("nsbases");
etloop = ajAcdGetBoolean("tetraloop");
erange = ajAcdGetFloat("erange");
prange = ajAcdGetFloat("prange");
subopt_sorted = !!ajAcdGetBoolean("sort");
logML = !!ajAcdGetBoolean("logml");
n_back = ajAcdGetInt("nrandom");
edangles = ajAcdGetListSingle("dangles");
outf = ajAcdGetOutfile("outfile");
if(dos)
print_energy = -999999;
do_backtrack = 1;
istty = 0;
temperature = (double) eT;
noGU = (eGU) ? 0 : 1;
no_closingGU = (eclose) ? 0 : 1;
noLonelyPairs = (lonely) ? 0 : 1;
noconv = (convert) ? 0 : 1;
ns_bases = (ajStrGetLen(ensbases)) ? MAJSTRGETPTR(ensbases) : NULL;
tetra_loop = !!etloop;
delta = (int) (0.1 + erange * 100);
deltap = prange;
edangle = *ajStrGetPtr(edangles);
if(edangle == '0')
dangles = 0;
else if(edangle == '1')
dangles = 1;
else if(edangle == '2')
dangles = 2;
else if(edangle == '3')
dangles = 3;
if(paramfile)
read_parameter_file(paramfile);
if (ns_bases != NULL)
{
nonstandards = space(33);
c=ns_bases;
i=sym=0;
if (*c=='-')
{
sym=1;
c++;
}
while (*c)
{
if (*c!=',')
{
nonstandards[i++]=*c++;
nonstandards[i++]=*c;
if ((sym)&&(*c!=*(c-1)))
{
nonstandards[i++]=*c;
nonstandards[i++]=*(c-1);
}
}
c++;
}
}
if(confile)
vienna_GetConstraints(confile,&constring);
if(n_back)
init_rand();
sequence = NULL;
structure = NULL;
length = ajSeqGetLen(seq);
sequence = (char *) space(length+1);
strcpy(sequence,ajSeqGetSeqC(seq));
len = ajStrGetLen(constring);
structure = (char *) space(length+1);
if(len)
{
fold_constrained = 1;
strcpy(structure,ajStrGetPtr(constring));
}
istty = 0;
if (fold_constrained)
{
for (i=0; i<length; i++)
if (structure[i]=='|')
ajFatal("Constraints of type '|' are not allowed\n");
}
for (l = 0; l < length; l++)
{
sequence[l] = toupper(sequence[l]);
if (!noconv && sequence[l] == 'T')
sequence[l] = 'U';
}
if ((logML!=0 || dangles==1 || dangles==3) && dos==0)
if (deltap<=0) deltap=delta/100. +0.001;
if (deltap>0)
print_energy = deltap;
/* first lines of output (suitable for sort +1n) */
ajFmtPrintF(outf,"> %s [%d]\n", ajSeqGetNameC(seq), delta);
if(n_back>0)
{
int i;
double mfe, kT;
char *ss;
st_back=1;
ss = (char *) space(strlen(sequence)+1);
strncpy(ss, structure, length);
mfe = (circ) ? circfold(sequence, ss) : fold(sequence, ss);
kT = (temperature+273.15)*1.98717/1000.; /* in Kcal */
pf_scale = exp(-(1.03*mfe)/kT/length);
strncpy(ss, structure, length);
/*
** we are not interested in the free energy but in the bppm, so we
** drop free energy into the void
*/
(circ) ? (void) pf_circ_fold(sequence, ss) :
(void) pf_fold(sequence, ss);
free(ss);
for (i=0; i<n_back; i++)
{
char *s;
s = (circ) ? pbacktrack_circ(sequence) : pbacktrack(sequence);
ajFmtPrintF(outf,"%s\n", s);
free(s);
}
free_pf_arrays();
}
else
{
(circ) ? subopt_circ(sequence, structure, delta, ajFileGetFileptr(outf)) :
subopt(sequence, structure, delta, ajFileGetFileptr(outf));
}
free(sequence);
free(structure);
ajSeqDel(&seq);
ajStrDel(&ensbases);
ajStrDel(&edangles);
ajFileClose(&confile);
ajFileClose(&outf);
ajFileClose(¶mfile);
embExit();
return 0;
}
void emboss_getoptions(char *pgm, int argc, char *argv[])
{
AjPStr test = NULL;
AjPStr outputformat = NULL;
AjPStr typeofseq = NULL;
AjPStr justweights = NULL;
AjBool rewrite = false;
long inseed, inseed0;
data = genefreqs;
seq = dna;
bootstrap = false;
jackknife = false;
permute = false;
ild = false;
lockhart = false;
blocksize = 1;
regular = true;
fracsample = 1.0;
all = true;
reps = 100;
weights = false;
mixture = false;
ancvar = false;
categories = false;
justwts = false;
printdata = false;
dotdiff = true;
progress = true;
interleaved = true;
xml = false;
nexus = false;
factors = false;
enzymes = false;
embInitPV(pgm, argc, argv, "PHYLIPNEW",VERSION);
phylofreqs = ajAcdGetFrequencies("infile");
test = ajAcdGetListSingle("test");
if(ajStrMatchC(test, "b")) {
bootstrap = true;
regular = ajAcdGetToggle("regular");
if(regular) fracsample = 1.0;
else {
fracsample = ajAcdGetFloat("fracsample");
fracsample = fracsample/100.0;
}
blocksize = ajAcdGetInt("blocksize");
}
else if(ajStrMatchC(test, "j")) {
jackknife = true;
regular = ajAcdGetToggle("regular");
if(regular) fracsample = 0.5;
else {
fracsample = ajAcdGetFloat("fracsample");
fracsample = fracsample/100.0;
}
}
else if(ajStrMatchC(test, "c")) permute = true;
else if(ajStrMatchC(test, "o")) ild = true;
else if(ajStrMatchC(test, "s")) lockhart = true;
else if(ajStrMatchC(test, "r")) rewrite = true;
if(rewrite) {
if (data == seqs) {
outputformat = ajAcdGetListSingle("rewriteformat");
if(ajStrMatchC(outputformat, "n")) nexus = true;
else if(ajStrMatchC(outputformat, "x")) xml = true;
if( (nexus) || (xml) ) {
typeofseq = ajAcdGetListSingle("seqtype");
if(ajStrMatchC(typeofseq, "d")) seq = dna;
else if(ajStrMatchC(typeofseq, "r")) seq = rna;
else if(ajStrMatchC(typeofseq, "p")) seq = protein;
}
}
}
else{
reps = ajAcdGetInt("reps");
inseed = ajAcdGetInt("seed");
emboss_initseed(inseed, &inseed0, seed);
if(jackknife || bootstrap || permute) {
phyloweights = ajAcdGetProperties("weights");
if(phyloweights) weights = true;
}
if(!permute) {
justweights = ajAcdGetListSingle("justweights");
if(ajStrMatchC(justweights, "j")) justwts = true;
}
}
printdata = ajAcdGetBoolean("printdata");
if(printdata) dotdiff = ajAcdGetBoolean("dotdiff");
progress = ajAcdGetBoolean("progress");
embossoutfile = ajAcdGetOutfile("outfile");
emboss_openfile(embossoutfile, &outfile, &outfilename);
printf("\n bootstrap: %s",(bootstrap ? "true" : "false"));
printf("\njackknife: %s",(jackknife ? "true" : "false"));
printf("\n permute: %s",(permute ? "true" : "false"));
printf("\n lockhart: %s",(lockhart ? "true" : "false"));
printf("\n ild: %s",(ild ? "true" : "false"));
printf("\n justwts: %s \n",(justwts ? "true" : "false"));
} /* emboss_getoptions */
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)
{
/* Variable Declarations */
AjPSeqset seqset = NULL;
AjPMatrixf fmat = NULL;
float thresh;
float threshlow;
float threshup;
float gapopen;
float gapextend;
AjPSeqout seqout = NULL;
AjPSeqout seqoutred = NULL;
AjPStr mode = NULL;
ajint moden;
ajuint i;
/* toggle "feature" from ACD not retrieved ... no need */
const AjPSeq seq = NULL;
AjPList list = NULL; /* List for redundancy removal. */
AjPUint keep = NULL; /* 1: Sequence in list was non-redundant,
0: redundant. */
ajuint nseq = 0; /* No. seqs. in list. */
ajint nseqnr = 0; /* No. non-redundant seqs. in list. */
/* ACD File Processing */
embInit("skipredundant", argc, argv);
seqset = ajAcdGetSeqset("sequences");
mode = ajAcdGetListSingle("mode");
fmat = ajAcdGetMatrixf("datafile");
thresh = ajAcdGetFloat("threshold");
threshlow = ajAcdGetFloat("minthreshold");
threshup = ajAcdGetFloat("maxthreshold");
gapopen = ajAcdGetFloat("gapopen");
gapextend = ajAcdGetFloat("gapextend");
seqout = ajAcdGetSeqoutall("outseq");
seqoutred = ajAcdGetSeqoutall("redundantoutseq");
/* Application logic */
list = ajListNew();
skipredundant_SeqsetToList(list, seqset);
keep = ajUintNew();
ajStrToInt(mode, &moden);
if(moden == 1)
/* Remove redundancy at a single threshold % sequence similarity */
{
if((!embDmxSeqNR(list, &keep, &nseqnr, fmat, gapopen,
gapextend, thresh, ajFalse)))
ajFatal("embDmxSeqNR unexpected failure!");
}
else if (moden == 2)
/* 2: Remove redundancy outside a range of acceptable threshold % similarity */
{
if((!embDmxSeqNRRange(list, &keep, &nseqnr, fmat, gapopen,
gapextend, threshlow, threshup, ajFalse)))
ajFatal("embDmxSeqNRRange unexpected failure!");
}
else
ajFatal("Invalid mode (not 1 or 2) which should never occur (check ACD file!)");
nseq = ajSeqsetGetSize(seqset);
for(i=0; i<nseq; i++)
{
seq = ajSeqsetGetseqSeq(seqset, i);
if(ajUintGet(keep, i))
ajSeqoutWriteSeq(seqout, seq);
else if(seqoutred)
ajSeqoutWriteSeq(seqoutred, seq);
}
/* Memory management and exit */
ajSeqsetDel(&seqset);
ajMatrixfDel(&fmat);
ajStrDel(&mode);
ajSeqoutClose(seqout);
ajSeqoutDel(&seqout);
if(seqoutred)
{
ajSeqoutClose(seqoutred);
ajSeqoutDel(&seqoutred);
}
skipredundant_ClearList(list);
ajListFree(&list);
ajUintDel(&keep);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPSeqall nucseq; /* input nucleic sequences */
AjPSeqset protseq; /* input aligned protein sequences */
AjPSeqout seqout;
AjPSeq nseq; /* next nucleic sequence to align */
const AjPSeq pseq; /* next protein sequence use in alignment */
AjPTrn trnTable;
AjPSeq pep; /* translation of nseq */
AjPStr tablelist;
ajint table;
AjPSeqset outseqset; /* set of aligned nucleic sequences */
ajint proteinseqcount = 0;
AjPStr degapstr = NULL;
/* used to check if it matches with START removed */
AjPStr degapstr2 = NULL;
AjPStr codon = NULL; /* holds temporary codon to check if is START */
char aa; /* translated putative START codon */
ajint type; /* returned type of the putative START codon */
/* start position of guide protein in translation */
ajlong pos = 0;
AjPSeq newseq = NULL; /* output aligned nucleic sequence */
ajint frame;
embInit("tranalign", argc, argv);
nucseq = ajAcdGetSeqall("asequence");
protseq = ajAcdGetSeqset("bsequence");
tablelist = ajAcdGetListSingle("table");
seqout = ajAcdGetSeqoutset("outseq");
outseqset = ajSeqsetNew();
degapstr = ajStrNew();
/* initialise the translation table */
ajStrToInt(tablelist, &table);
trnTable = ajTrnNewI(table);
ajSeqsetFill(protseq);
while(ajSeqallNext(nucseq, &nseq))
{
if((pseq = ajSeqsetGetseqSeq(protseq, proteinseqcount++)) == NULL)
ajErr("No guide protein sequence available for "
"nucleic sequence %S",
ajSeqGetNameS(nseq));
ajDebug("Aligning %S and %S\n",
ajSeqGetNameS(nseq), ajSeqGetNameS(pseq));
/* get copy of pseq string with no gaps */
ajStrAssignS(°apstr, ajSeqGetSeqS(pseq));
ajStrRemoveGap(°apstr);
/*
** for each translation frame look for subset of pep that
** matches pseq
*/
for(frame = 1; frame <4; frame++)
{
ajDebug("trying frame %d\n", frame);
pep = ajTrnSeqOrig(trnTable, nseq, frame);
degapstr2 = ajStrNew();
ajStrAssignRef(°apstr2, degapstr);
pos = ajStrFindCaseS(ajSeqGetSeqS(pep), degapstr);
/*
** we might have a START codon that should be translated as 'M'
** we need to check if there is a match after a possible START
** codon
*/
if(pos == -1 && ajStrGetLen(degapstr) > 1 &&
(ajStrGetPtr(degapstr)[0] == 'M' ||
ajStrGetPtr(degapstr)[0] == 'm'))
{
/* see if pep minus the first character is a match */
ajStrCutStart(°apstr2, 1);
pos = ajStrFindCaseS(ajSeqGetSeqS(pep), degapstr2);
/*
** pos is >= 1 if we have a match that is after the first
** residue
*/
if(pos >= 1)
{
/* point back at the putative START Methionine */
pos--;
/* test if first codon is a START */
codon = ajStrNew();
ajStrAssignSubS(&codon, ajSeqGetSeqS(nseq),
(pos*3)+frame-1, (pos*3)+frame+2);
type = ajTrnCodonstrTypeS(trnTable, codon, &aa);
if(type != 1)
{
/* first codon is not a valid START, force a mismatch */
pos = -1;
}
ajStrDel(&codon);
}
else
{
/* force 'pos == 0' to be treated as a mismatch */
pos = -1;
}
}
ajStrDel(°apstr2);
ajSeqDel(&pep);
if(pos != -1)
break;
}
if(pos == -1)
ajErr("Guide protein sequence %S not found in nucleic sequence %S",
ajSeqGetNameS(pseq), ajSeqGetNameS(nseq));
else
{
ajDebug("got a match with frame=%d\n", frame);
/* extract the coding region of nseq with gaps */
newseq = ajSeqNew();
ajSeqSetNuc(newseq);
ajSeqAssignNameS(newseq, ajSeqGetNameS(nseq));
ajSeqAssignDescS(newseq, ajSeqGetDescS(nseq));
tranalign_AddGaps(newseq, nseq, pseq, (pos*3)+frame-1);
/* output the gapped nucleic sequence */
ajSeqsetApp(outseqset, newseq);
ajSeqDel(&newseq);
}
ajStrRemoveWhiteExcess(°apstr);
}
ajSeqoutWriteSet(seqout, outseqset);
ajSeqoutClose(seqout);
ajTrnDel(&trnTable);
ajSeqsetDel(&outseqset);
ajStrDel(°apstr);
ajStrDel(°apstr2);
ajSeqallDel(&nucseq);
ajSeqDel(&nseq);
ajSeqoutDel(&seqout);
ajSeqsetDel(&protseq);
ajStrDel(&tablelist);
embExit();
return 0;
}
