int main(int argc, char **argv)
{
AjPSeqall seqall;
AjPSeq seq = NULL;
AjPFile primerFile; /* read the primer pairs from a file */
AjPFile outf;
AjPList primerList;
ajint mmp = 0;
embInit("primersearch", argc, argv);
seqall = ajAcdGetSeqall("seqall");
outf = ajAcdGetOutfile("outfile");
primerFile = ajAcdGetInfile("infile");
mmp = ajAcdGetInt("mismatchpercent");
/* build list of forward/reverse primer pairs as read from primerfile */
primerList = ajListNew();
/* read in primers from primerfile, classify and compile them */
primersearch_read_primers(&primerList,primerFile, mmp);
/* check there are primers to be searched */
if(!ajListGetLength(primerList))
{
ajErr("No suitable primers found - exiting");
embExitBad();
return 0;
}
/* query sequences one by one */
while(ajSeqallNext(seqall,&seq))
primersearch_primer_search(primerList, seq);
/* output the results */
primersearch_print_hits(primerList, outf);
/* delete all nodes of list, then the list itself */
ajListMap(primerList, primersearch_free_primer, NULL);
ajListFree(&primerList);
ajListFree(&primerList);
ajFileClose(&outf);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajFileClose(&primerFile);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPSeqall seqall;
AjPSeq seq;
AjPTable table = 0;
AjPFile outf;
ajint wordsize;
ajint mincount;
embInit("wordcount", argc, argv);
seqall = ajAcdGetSeqall("sequence1");
wordsize = ajAcdGetInt("wordsize");
outf = ajAcdGetOutfile("outfile");
mincount = ajAcdGetInt("mincount");
embWordLength(wordsize);
while (ajSeqallNext(seqall, &seq))
{
embWordGetTable(&table, seq); /* get table of words */
}
embWordPrintTableFI(table, mincount, outf); /* print table of words */
/*
** test if table can be added to
** if(getWordTable(&table, seq, wordcount)) ?? get table of words ??
** {
** printWordTable(table); ?? print table of words ??
** }
*/
embWordFreeTable(&table); /* free table of words */
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajFileClose(&outf);
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;
}
static void emira_dointegers(AjPStr *cl, AjPTable table)
{
ajuint i;
ajint iqual;
int dval = 0;
AjPStr prefix = NULL;
AjPStr key = NULL;
AjPStr value = NULL;
prefix = ajStrNew();
key = ajStrNew();
i = 0;
while(miraintegers[i].qname)
{
iqual = ajAcdGetInt(miraintegers[i].qname);
ajStrAssignC(&key,miraintegers[i].qname);
ajStrAssignC(&prefix,"");
value = ajTableFetch(table, key);
if(value)
ajStrAssignS(&prefix,value);
if(sscanf(miraintegers[i].def,"%d",&dval) != 1)
ajFatal("Dval conversion error in emira_dointegers()");
if(iqual != dval)
ajFmtPrintAppS(cl," -%S%s=%d",prefix,miraintegers[i].mname,iqual);
++i;
}
ajStrDel(&key);
ajStrDel(&prefix);
return;
}
int main(int argc, char **argv)
{
AjPSeqall seq1;
AjPSeqset seq2;
AjPSeq a;
const AjPSeq b;
AjPStr m = 0;
AjPStr n = 0;
AjPFile errorf;
AjBool show = ajFalse;
ajint lena = 0;
ajint lenb = 0;
const char *p;
const char *q;
AjPMatrixf matrix;
AjPSeqCvt cvt = 0;
float **sub;
ajint *compass = NULL;
float *path = NULL;
float gapopen;
float gapextend;
float score;
ajint begina;
ajint i;
ajuint k;
ajint beginb;
ajint start1 = 0;
ajint start2 = 0;
ajint end1 = 0;
ajint end2 = 0;
ajint width = 0;
AjPTable seq1MatchTable = 0;
ajint wordlen = 6;
ajint oldmax = 0;
AjPAlign align = NULL;
embInit("supermatcher", argc, argv);
matrix = ajAcdGetMatrixf("datafile");
seq1 = ajAcdGetSeqall("asequence");
seq2 = ajAcdGetSeqset("bsequence");
gapopen = ajAcdGetFloat("gapopen");
gapextend = ajAcdGetFloat("gapextend");
wordlen = ajAcdGetInt("wordlen");
align = ajAcdGetAlign("outfile");
errorf = ajAcdGetOutfile("errorfile");
width = ajAcdGetInt("width"); /* not the same as awidth */
gapopen = ajRoundFloat(gapopen, 8);
gapextend = ajRoundFloat(gapextend, 8);
sub = ajMatrixfGetMatrix(matrix);
cvt = ajMatrixfGetCvt(matrix);
embWordLength(wordlen);
ajSeqsetTrim(seq2);
while(ajSeqallNext(seq1,&a))
{
ajSeqTrim(a);
begina = 1 + ajSeqGetOffset(a);
m = ajStrNewRes(1+ajSeqGetLen(a));
lena = ajSeqGetLen(a);
ajDebug("Read '%S'\n", ajSeqGetNameS(a));
if(!embWordGetTable(&seq1MatchTable, a)) /* get table of words */
ajErr("Could not generate table for %s\n",
ajSeqGetNameC(a));
for(k=0;k<ajSeqsetGetSize(seq2);k++)
{
b = ajSeqsetGetseqSeq(seq2, k);
lenb = ajSeqGetLen(b);
beginb = 1 + ajSeqGetOffset(b);
ajDebug("Processing '%S'\n", ajSeqGetNameS(b));
p = ajSeqGetSeqC(a);
q = ajSeqGetSeqC(b);
if(!supermatcher_findstartpoints(seq1MatchTable,b,a,
&start1, &start2,
&end1, &end2))
{
ajFmtPrintF(errorf,
"No wordmatch start points for "
"%s vs %s. No alignment\n",
ajSeqGetNameC(a),ajSeqGetNameC(b));
continue;
}
n=ajStrNewRes(1+ajSeqGetLen(b));
ajStrAssignC(&m,"");
ajStrAssignC(&n,"");
ajDebug("++ %S v %S start:%d %d end:%d %d\n",
ajSeqGetNameS(a), ajSeqGetNameS(b),
start1, start2, end1, end2);
if(end1-start1+1 > oldmax)
{
oldmax = ((end1-start1)+1);
AJRESIZE(path,oldmax*width*sizeof(float));
AJRESIZE(compass,oldmax*width*sizeof(ajint));
ajDebug("++ resize to oldmax: %d\n", oldmax);
}
for(i=0;i<((end1-start1)+1)*width;i++)
path[i] = 0.0;
ajDebug("Calling embAlignPathCalcFast "
"%d..%d [%d/%d] %d..%d [%d/%d]\n",
start1, end1, (end1 - start1 + 1), lena,
start2, end2, (end2 - start2 + 1), lenb);
score = embAlignPathCalcSWFast(&p[start1],&q[start2],
end1-start1+1,end2-start2+1,
0,width,
gapopen,gapextend,
path,sub,cvt,
compass,show);
embAlignWalkSWMatrixFast(path,compass,gapopen,gapextend,a,b,
&m,&n,end1-start1+1,end2-start2+1,
0,width,
&start1,&start2);
if(!ajAlignFormatShowsSequences(align))
{
ajAlignDefineCC(align, ajStrGetPtr(m),
ajStrGetPtr(n), ajSeqGetNameC(a),
ajSeqGetNameC(b));
ajAlignSetScoreR(align, score);
}
else
{
embAlignReportLocal(align, a, b,
m,n,start1,start2,
gapopen, gapextend,
score,matrix, begina, beginb);
}
ajAlignWrite(align);
ajAlignReset(align);
ajStrDel(&n);
}
embWordFreeTable(&seq1MatchTable); /* free table of words */
seq1MatchTable=0;
ajStrDel(&m);
}
if(!ajAlignFormatShowsSequences(align))
{
ajMatrixfDel(&matrix);
}
AJFREE(path);
AJFREE(compass);
ajAlignClose(align);
ajAlignDel(&align);
ajSeqallDel(&seq1);
ajSeqDel(&a);
ajSeqsetDel(&seq2);
ajFileClose(&errorf);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPSeqall seqall;
AjPSeqout seqout;
AjPSeq seq;
ajint before;
ajint after;
AjBool join;
AjPFeattable featab;
AjBool featinname;
AjPStr describe;
/* feature filter criteria */
AjPStr source = NULL;
AjPStr feattype = NULL;
ajint sense;
float minscore;
float maxscore;
AjPStr tag = NULL;
AjPStr value = NULL;
AjBool testscore = AJFALSE;
embInit("extractfeat", argc, argv);
seqall = ajAcdGetSeqall("sequence");
seqout = ajAcdGetSeqout("outseq");
before = ajAcdGetInt("before");
after = ajAcdGetInt("after");
join = ajAcdGetBoolean("join");
featinname = ajAcdGetBoolean("featinname");
describe = ajAcdGetString("describe");
/* feature filter criteria */
source = ajAcdGetString("source");
feattype = ajAcdGetString("type");
sense = ajAcdGetInt("sense");
minscore = ajAcdGetFloat("minscore");
maxscore = ajAcdGetFloat("maxscore");
tag = ajAcdGetString("tag");
value = ajAcdGetString("value");
testscore = (minscore || maxscore);
if(minscore && !maxscore)
if(minscore > maxscore)
maxscore = minscore;
if(!minscore && maxscore)
if(minscore > maxscore)
minscore = maxscore;
while(ajSeqallNext(seqall, &seq))
{
/* get the feature table of the sequence */
featab = ajSeqGetFeatCopy(seq);
/* delete features in the table that don't match our criteria */
extractfeat_FeatureFilter(featab, source, feattype, sense,
testscore, minscore, maxscore, tag, value);
/* extract the features */
extractfeat_FeatSeqExtract(seq, seqout, featab, before,
after, join, featinname, describe);
ajFeattableDel(&featab);
}
ajSeqoutClose(seqout);
ajSeqoutDel(&seqout);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&describe);
ajStrDel(&source);
ajStrDel(&feattype);
ajStrDel(&tag);
ajStrDel(&value);
embExit();
return 0;
}
int main(int argc, char *argv[])
{
embInitPV("gbasezvalue", argc, argv, "GEMBASSY", "1.0.3");
AjPSeqall seqall;
AjPSeq seq;
AjPStr inseq = NULL;
AjPStr position = NULL;
ajint limit = 0;
ajint PatLen = 0;
ajint upstream = 0;
ajint downstream = 0;
AjBool accid = ajFalse;
AjPStr restid = NULL;
AjPStr seqid = NULL;
AjPStr base = NULL;
AjPStr url = NULL;
AjPFile tmpfile = NULL;
AjPStr tmpname = NULL;
AjPFile outf = NULL;
seqall = ajAcdGetSeqall("sequence");
position = ajAcdGetSelectSingle("position");
limit = ajAcdGetInt("limit");
PatLen = ajAcdGetInt("patlen");
upstream = ajAcdGetInt("upstream");
downstream = ajAcdGetInt("downstream");
accid = ajAcdGetBoolean("accid");
outf = ajAcdGetOutfile("outfile");
base = ajStrNewC("rest.g-language.org");
gAssignUniqueName(&tmpname);
while(ajSeqallNext(seqall, &seq))
{
inseq = NULL;
if(!accid)
{
if(gFormatGenbank(seq, &inseq))
{
tmpfile = ajFileNewOutNameS(tmpname);
if(!tmpfile)
{
ajDie("Output file (%S) open error\n", tmpname);
}
ajFmtPrintF(tmpfile, "%S", inseq);
ajFileClose(&tmpfile);
ajFmtPrintS(&url, "http://%S/upload/upl.pl", base);
gFilePostSS(url, tmpname, &restid);
ajStrDel(&url);
ajSysFileUnlinkS(tmpname);
}
else
{
ajWarn("Sequence does not have features\n"
"Proceeding with sequence accession ID\n");
accid = ajTrue;
}
}
ajStrAssignS(&seqid, ajSeqGetAccS(seq));
if(ajStrGetLen(seqid) == 0)
{
ajStrAssignS(&seqid, ajSeqGetNameS(seq));
}
if(ajStrGetLen(seqid) == 0)
{
ajWarn("No valid header information\n");
}
if(accid)
{
ajStrAssignS(&restid, seqid);
if(ajStrGetLen(seqid) == 0)
{
ajDie("Cannot proceed without header with -accid\n");
}
if(!gValID(seqid))
{
ajDie("Invalid accession ID:%S, exiting\n", seqid);
}
}
url = ajStrNew();
ajFmtPrintS(&url, "http://%S/%S/base_z_value/position=%S/PatLen=%d"
"upstream=%d/downstream=%d/limit=%d/output=f/tag=gene",
base, restid, position, PatLen, upstream, downstream, limit);
ajFmtPrintF(outf, "Sequence: %S\n", seqid);
if(!gFileOutURLS(url, &outf))
{
ajDie("Failed to download result from:\n%S\n", url);
}
ajStrDel(&url);
ajStrDel(&restid);
ajStrDel(&seqid);
ajStrDel(&inseq);
}
ajFileClose(&outf);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&base);
ajStrDel(&position);
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)
{
/* 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)
{
AjPSeqall seqall;
AjPSeq seq = NULL;
AjPFile outf = NULL;
AjPStr strand = NULL;
AjPStr substr = NULL;
AjPStr bases = NULL;
ajint begin;
ajint end;
ajint len;
ajint minlen;
float minobsexp;
float minpc;
ajint window;
ajint shift;
ajint plotstart;
ajint plotend;
float *xypc = NULL;
float *obsexp = NULL;
AjBool *thresh = NULL;
float obsexpmax;
ajint i;
ajint maxarr;
embInit("newcpgreport",argc,argv);
seqall = ajAcdGetSeqall("sequence");
window = ajAcdGetInt("window");
shift = ajAcdGetInt("shift");
outf = ajAcdGetOutfile("outfile");
minobsexp = ajAcdGetFloat("minoe");
minlen = ajAcdGetInt("minlen");
minpc = ajAcdGetFloat("minpc");
substr = ajStrNew();
bases = ajStrNewC("CG");
maxarr = 0;
while(ajSeqallNext(seqall, &seq))
{
begin = ajSeqallGetseqBegin(seqall);
end = ajSeqallGetseqEnd(seqall);
strand = ajSeqGetSeqCopyS(seq);
ajStrFmtUpper(&strand);
ajStrAssignSubC(&substr,ajStrGetPtr(strand),--begin,--end);
len=ajStrGetLen(substr);
if(len > maxarr)
{
AJCRESIZE(obsexp, len);
AJCRESIZE(thresh, len);
AJCRESIZE(xypc, len);
maxarr = len;
}
for(i=0;i<len;++i)
obsexp[i]=xypc[i]=0.0;
newcpgreport_findbases(substr, len, window, shift, obsexp,
xypc, bases, &obsexpmax, &plotstart, &plotend);
newcpgreport_identify(outf, obsexp, xypc, thresh, 0, len, shift,
ajStrGetPtr(bases), ajSeqGetNameC(seq), minlen,
minobsexp, minpc, ajStrGetPtr(strand));
ajStrDel(&strand);
}
ajStrDel(&bases);
ajSeqDel(&seq);
ajStrDel(&substr);
ajFileClose(&outf);
AJFREE(obsexp);
AJFREE(thresh);
AJFREE(xypc);
ajSeqallDel(&seqall);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPList list = NULL;
AjPSeq seq;
AjPSeq seq2;
AjPStr aa0str = 0;
AjPStr aa1str = 0;
const char *s1;
const char *s2;
char *strret = NULL;
ajuint i;
ajuint j;
ajuint k;
ajint l;
ajint abovethresh;
ajint total;
ajint starti = 0;
ajint startj = 0;
ajint windowsize;
float thresh;
AjPGraph graph = NULL;
AjPGraph xygraph = NULL;
float flen1;
float flen2;
ajuint len1;
ajuint len2;
AjPTime ajtime = NULL;
time_t tim;
AjBool boxit=AJTRUE;
/* Different ticks as they need to be different for x and y due to
length of string being important on x */
ajuint acceptableticksx[]=
{
1,10,50,100,500,1000,1500,10000,
500000,1000000,5000000
};
ajuint acceptableticks[]=
{
1,10,50,100,200,500,1000,2000,5000,10000,15000,
500000,1000000,5000000
};
ajint numbofticks = 10;
float xmargin;
float ymargin;
float ticklen;
float tickgap;
float onefifth;
float k2;
float max;
char ptr[10];
AjPMatrix matrix = NULL;
ajint** sub;
AjPSeqCvt cvt;
AjPStr subt = NULL;
ajint b1;
ajint b2;
ajint e1;
ajint e2;
AjPStr se1;
AjPStr se2;
ajint ithresh;
AjBool stretch;
PPoint ppt = NULL;
float xa[1];
float ya[1];
AjPGraphdata gdata=NULL;
AjPStr tit = NULL;
AjIList iter = NULL;
float x1 = 0.;
float x2 = 0.;
float y1 = 0.;
float y2 = 0.;
ajuint tui;
se1 = ajStrNew();
se2 = ajStrNew();
embInit("dotmatcher", argc, argv);
seq = ajAcdGetSeq("asequence");
seq2 = ajAcdGetSeq("bsequence");
stretch = ajAcdGetToggle("stretch");
graph = ajAcdGetGraph("graph");
xygraph = ajAcdGetGraphxy("xygraph");
windowsize = ajAcdGetInt("windowsize");
ithresh = ajAcdGetInt("threshold");
matrix = ajAcdGetMatrix("matrixfile");
sub = ajMatrixGetMatrix(matrix);
cvt = ajMatrixGetCvt(matrix);
thresh = (float)ithresh;
ajtime = ajTimeNew();
tim = time(0);
ajTimeSetLocal(ajtime, tim);
b1 = ajSeqGetBegin(seq);
b2 = ajSeqGetBegin(seq2);
e1 = ajSeqGetEnd(seq);
e2 = ajSeqGetEnd(seq2);
len1 = ajSeqGetLen(seq);
len2 = ajSeqGetLen(seq2);
tui = ajSeqGetLen(seq);
flen1 = (float) tui;
tui = ajSeqGetLen(seq2);
flen2 = (float) tui;
ajStrAssignSubC(&se1,ajSeqGetSeqC(seq),b1-1,e1-1);
ajStrAssignSubC(&se2,ajSeqGetSeqC(seq2),b2-1,e2-1);
ajSeqAssignSeqS(seq,se1);
ajSeqAssignSeqS(seq2,se2);
s1 = ajStrGetPtr(ajSeqGetSeqS(seq));
s2 = ajStrGetPtr(ajSeqGetSeqS(seq2));
aa0str = ajStrNewRes(1+len1); /* length plus trailing blank */
aa1str = ajStrNewRes(1+len2);
list = ajListNew();
for(i=0;i<len1;i++)
ajStrAppendK(&aa0str,(char)ajSeqcvtGetCodeK(cvt, *s1++));
for(i=0;i<len2;i++)
ajStrAppendK(&aa1str,(char)ajSeqcvtGetCodeK(cvt, *s2++));
max = (float)len1;
if(len2 > max)
max = (float) len2;
xmargin = ymargin = max *(float)0.15;
ticklen = xmargin*(float)0.1;
onefifth = xmargin*(float)0.2;
subt = ajStrNewC((strret=
ajFmtString("(windowsize = %d, threshold = %3.2f %D)",
windowsize,thresh,ajtime)));
if(!stretch)
{
if( ajStrGetLen(ajGraphGetSubtitleS(graph)) <=1)
ajGraphSetSubtitleS(graph,subt);
ajGraphOpenWin(graph, (float)0.0-ymargin,(max*(float)1.35)+ymargin,
(float)0.0-xmargin,(float)max+xmargin);
ajGraphicsDrawposTextAtmid(flen1*(float)0.5,
(float)0.0-(xmargin/(float)2.0),
ajGraphGetXlabelC(graph));
ajGraphicsDrawposTextAtlineJustify((float)0.0-(xmargin*(float)0.75),
flen2*(float)0.5,
(float)0.0-(xmargin*(float)0.75),flen1,
ajGraphGetYlabelC(graph),0.5);
ajGraphicsSetCharscale(0.5);
}
s1= ajStrGetPtr(aa0str);
s2 = ajStrGetPtr(aa1str);
for(j=0; (ajint)j < (ajint)len2-windowsize;j++)
{
i =0;
total = 0;
abovethresh =0;
k = j;
for(l=0;l<windowsize;l++)
total = total + sub[(ajint)s1[i++]][(ajint)s2[k++]];
if(total >= thresh)
{
abovethresh=1;
starti = i-windowsize;
startj = k-windowsize;
}
while(i < len1 && k < len2)
{
total = total - sub[(ajint)s1[i-windowsize]]
[(ajint)s2[k-windowsize]];
total = total + sub[(ajint)s1[i]][(ajint)s2[k]];
if(abovethresh)
{
if(total < thresh)
{
abovethresh = 0;
/* draw the line */
dotmatcher_pushpoint(&list,(float)starti,(float)startj,
(float)i-1,(float)k-1,stretch);
}
}
else if(total >= thresh)
{
starti = i-windowsize;
startj = k-windowsize;
abovethresh= 1;
}
i++;
k++;
}
if(abovethresh)
/* draw the line */
dotmatcher_pushpoint(&list,(float)starti,(float)startj,
(float)i-1,(float)k-1,
stretch);
}
for(i=0; (ajint)i < (ajint)len1-windowsize;i++)
{
j = 0;
total = 0;
abovethresh =0;
k = i;
for(l=0;l<windowsize;l++)
total = total + sub[(ajint)s1[k++]][(ajint)s2[j++]];
if(total >= thresh)
{
abovethresh=1;
starti = k-windowsize;
startj = j-windowsize;
}
while(k < len1 && j < len2)
{
total = total - sub[(ajint)s1[k-windowsize]]
[(ajint)s2[j-windowsize]];
total = total + sub[(ajint)s1[k]][(ajint)s2[j]];
if(abovethresh)
{
if(total < thresh)
{
abovethresh = 0;
/* draw the line */
dotmatcher_pushpoint(&list,(float)starti,(float)startj,
(float)k-1,(float)j-1,stretch);
}
}
else if(total >= thresh)
{
starti = k-windowsize;
startj = j-windowsize;
abovethresh= 1;
}
j++;
k++;
}
if(abovethresh)
/* draw the line */
dotmatcher_pushpoint(&list,(float)starti,(float)startj,
(float)k-1,(float)j-1,
stretch);
}
if(boxit && !stretch)
{
ajGraphicsDrawposRect(0.0,0.0,flen1, flen2);
i=0;
while(acceptableticksx[i]*numbofticks < len1)
i++;
if(i<=13)
tickgap = (float)acceptableticksx[i];
else
tickgap = (float)acceptableticksx[10];
ticklen = xmargin*(float)0.1;
onefifth = xmargin*(float)0.2;
if(len2/len1 > 10 )
{
/* if a lot smaller then just label start and end */
ajGraphicsDrawposLine((float)0.0,(float)0.0,(float)0.0,(float)0.0-ticklen);
sprintf(ptr,"%d",b1-1);
ajGraphicsDrawposTextAtmid((float)0.0,(float)0.0-(onefifth),ptr);
ajGraphicsDrawposLine(flen1,(float)0.0,
flen1,(float)0.0-ticklen);
sprintf(ptr,"%d",len1+b1-1);
ajGraphicsDrawposTextAtmid(flen1,(float)0.0-(onefifth),ptr);
}
else
for(k2=0.0;k2<len1;k2+=tickgap)
{
ajGraphicsDrawposLine(k2,(float)0.0,k2,(float)0.0-ticklen);
sprintf(ptr,"%d",(ajint)k2+b1-1);
ajGraphicsDrawposTextAtmid(k2,(float)0.0-(onefifth),ptr);
}
i = 0;
while(acceptableticks[i]*numbofticks < len2)
i++;
tickgap = (float)acceptableticks[i];
ticklen = ymargin*(float)0.01;
onefifth = ymargin*(float)0.02;
if(len1/len2 > 10 )
{
/* if a lot smaller then just label start and end */
ajGraphicsDrawposLine((float)0.0,(float)0.0,(float)0.0-ticklen,(float)0.0);
sprintf(ptr,"%d",b2-1);
ajGraphicsDrawposTextAtend((float)0.0-(onefifth),(float)0.0,ptr);
ajGraphicsDrawposLine((float)0.0,flen2,(float)0.0-ticklen,
flen2);
sprintf(ptr,"%d",len2+b2-1);
ajGraphicsDrawposTextAtend((float)0.0-(onefifth),flen2,ptr);
}
else
for(k2=0.0;k2<len2;k2+=tickgap)
{
ajGraphicsDrawposLine((float)0.0,k2,(float)0.0-ticklen,k2);
sprintf(ptr,"%d",(ajint)k2+b2-1);
ajGraphicsDrawposTextAtend((float)0.0-(onefifth),k2,ptr);
}
}
if(!stretch)
ajGraphicsClose();
else /* the xy graph for -stretch */
{
tit = ajStrNew();
ajFmtPrintS(&tit,"%S",ajGraphGetTitleS(xygraph));
gdata = ajGraphdataNewI(1);
xa[0] = (float)b1;
ya[0] = (float)b2;
ajGraphSetTitleC(xygraph,ajStrGetPtr(tit));
ajGraphSetXlabelC(xygraph,ajSeqGetNameC(seq));
ajGraphSetYlabelC(xygraph,ajSeqGetNameC(seq2));
ajGraphdataSetTypeC(gdata,"2D Plot Float");
ajGraphdataSetTitleS(gdata,subt);
ajGraphdataSetMinmax(gdata,(float)b1,(float)e1,(float)b2,
(float)e2);
ajGraphdataSetTruescale(gdata,(float)b1,(float)e1,(float)b2,
(float)e2);
ajGraphxySetXstartF(xygraph,(float)b1);
ajGraphxySetXendF(xygraph,(float)e1);
ajGraphxySetYstartF(xygraph,(float)b2);
ajGraphxySetYendF(xygraph,(float)e2);
ajGraphxySetXrangeII(xygraph,b1,e1);
ajGraphxySetYrangeII(xygraph,b2,e2);
if(list)
{
iter = ajListIterNewread(list);
while((ppt = ajListIterGet(iter)))
{
x1 = ppt->x1+b1-1;
y1 = ppt->y1+b2-1;
x2 = ppt->x2+b1-1;
y2 = ppt->y2+b2-1;
ajGraphAddLine(xygraph,x1,y1,x2,y2,0);
AJFREE(ppt);
}
ajListIterDel(&iter);
}
ajGraphdataAddXY(gdata,xa,ya);
ajGraphDataReplace(xygraph,gdata);
ajGraphxyDisplay(xygraph,ajFalse);
ajGraphicsClose();
ajStrDel(&tit);
}
ajListFree(&list);
ajSeqDel(&seq);
ajSeqDel(&seq2);
ajGraphxyDel(&graph);
ajGraphxyDel(&xygraph);
ajMatrixDel(&matrix);
ajTimeDel(&ajtime);
/* deallocate memory */
ajStrDel(&aa0str);
ajStrDel(&aa1str);
ajStrDel(&se1);
ajStrDel(&se2);
ajStrDel(&subt);
AJFREE(strret); /* created withing ajFmtString */
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPSeq seq1;
AjPSeq seq2;
ajint wordlen;
AjPTable seq1MatchTable = 0;
AjPList matchlist = NULL;
AjPGraph graph = NULL;
AjPGraph xygraph = NULL;
AjBool boxit;
/*
** Different ticks as they need to be different for x and y due to
** length of string being important on x
*/
ajuint acceptableticksx[]=
{
1,10,50,100,500,1000,1500,10000,
500000,1000000,5000000
};
ajuint acceptableticks[]=
{
1,10,50,100,200,500,1000,2000,5000,10000,15000,
500000,1000000,5000000
};
ajint numbofticks = 10;
float xmargin;
float ymargin;
float ticklen;
float tickgap;
float onefifth = 0.0;
ajint i;
float k;
float max;
char ptr[10];
ajint begin1;
ajint begin2;
ajint end1;
ajint end2;
ajuint len1;
ajuint len2;
float fbegin1;
float fbegin2;
float fend1;
float fend2;
float flen1;
float flen2;
AjBool stretch;
embInit("dottup", argc, argv);
wordlen = ajAcdGetInt("wordsize");
seq1 = ajAcdGetSeq("asequence");
seq2 = ajAcdGetSeq("bsequence");
graph = ajAcdGetGraph("graph");
boxit = ajAcdGetBoolean("boxit");
stretch = ajAcdGetToggle("stretch");
xygraph = ajAcdGetGraphxy("xygraph");
begin1 = ajSeqGetBegin(seq1);
begin2 = ajSeqGetBegin(seq2);
end1 = ajSeqGetEnd(seq1);
end2 = ajSeqGetEnd(seq2);
len1 = end1 - begin1 + 1;
len2 = end2 - begin2 + 1;
flen1 = (float) len1;
flen2 = (float) len2;
fbegin1 = (float) begin1;
fbegin2 = (float) begin2;
fend1 = (float) end1;
fend2 = (float) end2;
offset1 = fbegin1;
offset2 = fbegin2;
ajSeqTrim(seq1);
ajSeqTrim(seq2);
embWordLength(wordlen);
if(embWordGetTable(&seq1MatchTable, seq1))
matchlist = embWordBuildMatchTable(seq1MatchTable, seq2, ajTrue);
if(stretch)
{
dottup_stretchplot(xygraph,matchlist,seq1,seq2,begin1,begin2,end1,
end2);
if(matchlist)
embWordMatchListDelete(&matchlist); /* free the match structures */
}
else
{
/* only here if stretch is false */
max= flen1;
if(flen2 > max)
max = flen2;
xmargin = ymargin = max * (float)0.15;
ajGraphOpenWin(graph, fbegin1-ymargin,fend1+ymargin,
fbegin2-xmargin,(float)fend2+xmargin);
ajGraphicsSetCharscale(0.5);
if(matchlist)
dottup_plotMatches(matchlist);
if(boxit)
{
ajGraphicsDrawposRect(fbegin1, fbegin2, fend1, fend2);
i = 0;
while(acceptableticksx[i]*numbofticks < len1)
i++;
if(i<=13)
tickgap = (float) acceptableticksx[i];
else
tickgap = (float) acceptableticksx[10];
ticklen = xmargin * (float) 0.1;
onefifth = xmargin * (float)0.2;
ajGraphicsDrawposTextAtmid(fbegin1+flen1*(float)0.5,
fbegin1-(onefifth*(float)3.0),
ajGraphGetYlabelC(graph));
if(len2/len1 > 10 )
{
/* a lot smaller then just label start and end */
ajGraphicsDrawposLine(fbegin1,fbegin2,fbegin1,
fbegin2-ticklen);
sprintf(ptr,"%u",ajSeqGetOffset(seq1));
ajGraphicsDrawposTextAtmid(fbegin1,fbegin2-(onefifth),ptr);
ajGraphicsDrawposLine(fend1,fbegin2,
fend1,fbegin2-ticklen);
sprintf(ptr,"%d",end1);
ajGraphicsDrawposTextAtmid(fend1,fbegin2-(onefifth),ptr);
}
else
for(k=fbegin1;k<fend1;k+=tickgap)
{
ajGraphicsDrawposLine(k,fbegin2,k,fbegin2-ticklen);
sprintf(ptr,"%d",(ajint)k);
ajGraphicsDrawposTextAtmid( k,fbegin2-(onefifth),ptr);
}
i = 0;
while(acceptableticks[i]*numbofticks < len2)
i++;
tickgap = (float) acceptableticks[i];
ticklen = ymargin*(float)0.1;
onefifth = ymargin*(float)0.2;
ajGraphicsDrawposTextAtlineJustify(fbegin1-(onefifth*(float)4.),
fbegin2+flen2*(float)0.5,
fbegin2-(onefifth*(float)4.),
fbegin2+flen2,
ajGraphGetXlabelC(graph),
0.5);
if(len1/len2 > 10 )
{
/* a lot smaller then just label start and end */
ajGraphicsDrawposLine(fbegin1,fbegin2,fbegin1-ticklen,
fbegin2);
sprintf(ptr,"%u",ajSeqGetOffset(seq2));
ajGraphicsDrawposTextAtend(fbegin1-(onefifth),fbegin2,ptr);
ajGraphicsDrawposLine(fbegin1,fend2,fbegin1-ticklen,
fend2);
sprintf(ptr,"%d",end2);
ajGraphicsDrawposTextAtend(fbegin2-(onefifth),fend2,ptr);
}
else
for(k=fbegin2;k<fend2;k+=tickgap)
{
ajGraphicsDrawposLine(fbegin1,k,fbegin1-ticklen,k);
sprintf(ptr,"%d",(ajint)k);
ajGraphicsDrawposTextAtend(fbegin1-(onefifth),k,ptr);
}
}
}
ajGraphicsClose();
ajSeqDel(&seq1);
ajSeqDel(&seq2);
ajGraphxyDel(&graph);
ajGraphxyDel(&xygraph);
embWordFreeTable(&seq1MatchTable);
if(matchlist)
embWordMatchListDelete(&matchlist); /* free the match structures */
embExit();
return 0;
}
int main(int argc, char **argv)
{
/* ACD data item variables */
AjPFile hmmfile = NULL;
AjPSeqall seqfile = NULL;
AjBool nuc = 0;
ajint A = 0;
float E = 0.0;
float T = 0.0;
ajint Z = 0;
AjBool acc = ajFalse;
AjBool compat = ajFalse;
ajint cpu = 0;
AjBool cutga = ajFalse;
AjBool cuttc = ajFalse;
AjBool cutnc = ajFalse;
float dome = 0.0;
float domt = 0.0;
AjBool forward = ajFalse;
AjBool nulltwo = ajFalse;
AjBool pvm = ajFalse;
AjBool xnu = ajFalse;
AjPStr outname = NULL;
/* Housekeeping variables */
AjPStr cmd = NULL;
AjPStr rnd = NULL;
AjPSeqout rndo = NULL;
AjPSeq seq = NULL;
/* ACD file processing */
embInitPV("ehmmpfam",argc,argv,"HMMERNEW",VERSION);
hmmfile = ajAcdGetInfile("hmmfile");
seqfile = ajAcdGetSeqall("seqfile");
nuc = ajAcdGetBoolean("nuc");
A = ajAcdGetInt("A");
E = ajAcdGetFloat("E");
T = ajAcdGetFloat("T");
Z = ajAcdGetInt("Z");
acc = ajAcdGetBoolean("acc");
compat = ajAcdGetBoolean("compat");
cpu = ajAcdGetInt("cpu");
cutga = ajAcdGetBoolean("cutga");
cuttc = ajAcdGetBoolean("cuttc");
cutnc = ajAcdGetBoolean("cutnc");
dome = ajAcdGetFloat("dome");
domt = ajAcdGetFloat("domt");
forward = ajAcdGetBoolean("forward");
nulltwo = ajAcdGetBoolean("nulltwo");
pvm = ajAcdGetBoolean("pvm");
xnu = ajAcdGetBoolean("xnu");
outname = ajAcdGetOutfileName("outfile");
/* MAIN APPLICATION CODE */
/* 1. Housekeeping */
cmd = ajStrNew();
rnd = ajStrNew();
/* 2. Re-write seqfile to a temporary file in a format (fasta) HMMER can understand.
We cannot just pass the name of seqfile to HMMER as the name provided might be a
USA which HMMER would not understand. */
ajFilenameSetTempname(&rnd);
rndo = ajSeqoutNew();
if(!ajSeqoutOpenFilename(rndo, rnd))
ajFatal("Terminal ajSeqFileNewOut failure. Email EMBOSS helpdesk!\n");
ajSeqoutSetFormatC(rndo, "fasta");
while(ajSeqallNext(seqfile, &seq))
ajSeqoutWriteSeq(rndo, seq);
ajSeqoutClose(rndo);
ajSeqoutDel(&rndo);
/* 2. Build hmmpfam 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("hmmpfam"));
if(nuc)
ajStrAppendC(&cmd, " -n ");
ajFmtPrintAppS(&cmd, " -A %d -E %f -T %f -Z %d", A, E, T, Z);
if(acc)
ajStrAppendC(&cmd, " --acc ");
if(compat)
ajStrAppendC(&cmd, " --compat ");
if(cpu)
ajFmtPrintAppS(&cmd, " --cpu %d ", cpu);
if(cutga)
ajStrAppendC(&cmd, " --cutga ");
if(cuttc)
ajStrAppendC(&cmd, " --cuttc ");
if(cutnc)
ajStrAppendC(&cmd, " --cutnc ");
ajFmtPrintAppS(&cmd, " --domE %f --domT %f ", dome, domt);
if(forward)
ajStrAppendC(&cmd, " --forward ");
if(nulltwo)
ajStrAppendC(&cmd, " --null2 ");
if(pvm)
ajStrAppendC(&cmd, " --pvm ");
if(xnu)
ajStrAppendC(&cmd, " --xnu ");
/* Note output redirected to outname.
rnd is the name of the rewritten seqfile.
MUST specify FASTA format explicitly. */
ajFmtPrintAppS(&cmd, " --informat FASTA %s %S",
ajFileGetNameC(hmmfile),
rnd);
/* 3. Close ACD files. */
ajFileClose(&hmmfile);
ajSeqallDel(&seqfile);
/* 4. Call hmmpfam. Use C system call instead of ajSystem
so that redirect in cmd works ok. */
ajFmtPrint("\n%S\n\n", cmd);
ajSysExecOutnameAppendS(cmd,outname);
/* 5. Exit cleanly */
ajSysFileUnlinkS(rnd);
ajStrDel(&cmd);
ajStrDel(&rnd);
ajStrDel(&outname);
embExit();
return 0;
}
int main(int argc, char *argv[])
{
embInitPV("gpalindrome", argc, argv, "GEMBASSY", "1.0.3");
struct soap soap;
struct ns1__palindromeInputParams params;
AjPSeqall seqall;
AjPSeq seq;
AjPStr inseq = NULL;
AjPStr seqid = NULL;
ajint shortest = 0;
ajint loop = 0;
AjBool gtmatch = 0;
char *in0;
char *result;
AjPFile outf = NULL;
seqall = ajAcdGetSeqall("sequence");
shortest = ajAcdGetInt("shortest");
loop = ajAcdGetInt("loop");
gtmatch = ajAcdGetBoolean("gtmatch");
outf = ajAcdGetOutfile("outfile");
params.shortest = shortest;
params.loop = loop;
params.gtmatch = gtmatch;
params.output = "f";
while(ajSeqallNext(seqall, &seq))
{
soap_init(&soap);
inseq = NULL;
ajStrAppendC(&inseq, ">");
ajStrAppendS(&inseq, ajSeqGetNameS(seq));
ajStrAppendC(&inseq, "\n");
ajStrAppendS(&inseq, ajSeqGetSeqS(seq));
ajStrAssignS(&seqid, ajSeqGetAccS(seq));
in0 = ajCharNewS(inseq);
if(soap_call_ns1__palindrome(
&soap,
NULL,
NULL,
in0,
¶ms,
&result
) == SOAP_OK)
{
ajFmtPrintF(outf, "Sequence: %S\n", seqid);
if(!gFileOutURLC(result, &outf))
{
ajDie("File downloading error from:\n%s\n", result);
embExitBad();
}
}
else
{
soap_print_fault(&soap, stderr);
}
soap_destroy(&soap);
soap_end(&soap);
soap_done(&soap);
AJFREE(in0);
ajStrDel(&inseq);
}
ajFileClose(&outf);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&seqid);
embExit();
return 0;
}
int main(int argc, char *argv[])
{
embInitPV("ggenomemap3", argc, argv, "GEMBASSY", "1.0.3");
struct soap soap;
struct ns1__genome_USCOREmap3InputParams params;
AjPSeqall seqall;
AjPSeq seq;
AjPStr inseq = NULL;
AjPStr seqid = NULL;
ajint width;
ajint height;
AjBool accid = ajFalse;
AjPFile outf = NULL;
AjPStr filename = NULL;
AjPStr outfname = NULL;
AjPStr format = NULL;
ajint i;
char *in0;
char *result;
seqall = ajAcdGetSeqall("sequence");
width = ajAcdGetInt("width");
height = ajAcdGetInt("height");
filename = ajAcdGetString("goutfile");
accid = ajAcdGetBoolean("accid");
format = ajAcdGetString("format");
params.width = width;
params.height = height;
params.gmap = 0;
params.datafilename = "";
params.output = "g";
i = 0;
while(ajSeqallNext(seqall, &seq))
{
soap_init(&soap);
soap.send_timeout = 0;
soap.recv_timeout = 0;
inseq = NULL;
ajStrAssignS(&seqid, ajSeqGetAccS(seq));
if(!ajStrGetLen(seqid))
ajStrAssignS(&seqid, ajSeqGetNameS(seq));
if(!ajStrGetLen(seqid))
{
ajWarn("No valid header information\n");
}
if(accid || !gFormatGenbank(seq, &inseq))
{
if(!accid)
ajWarn("Sequence does not have features\n"
"Proceeding with sequence accession ID:%S\n", seqid);
if(!gValID(seqid))
{
ajDie("Invalid accession ID:%S, exiting\n", seqid);
}
ajStrAssignS(&inseq, seqid);
}
in0 = ajCharNewS(inseq);
if(soap_call_ns1__genome_USCOREmap3(
&soap,
NULL,
NULL,
in0,
¶ms,
&result
) == SOAP_OK)
{
++i;
outfname = ajStrNewS(ajFmtStr("%S.%d.%S",
filename,
i,
format));
outf = ajFileNewOutNameS(outfname);
if(!outf)
{
ajDie("File open error\n");
}
if(!ajStrMatchC(format, "png"))
{
if(!gHttpConvertC(result, &outf, ajStrNewC("png"), format))
{
ajDie("File downloading error from:\n%s\n", result);
}
else
{
ajFmtPrint("Created %S\n", outfname);
}
}
else
{
if(!gHttpGetBinC(result, &outf))
{
ajDie("File downloading error from:\n%s\n", result);
}
else
{
ajFmtPrint("Created %S\n", outfname);
}
}
ajStrDel(&outfname);
}
else
{
soap_print_fault(&soap, stderr);
}
soap_destroy(&soap);
soap_end(&soap);
soap_done(&soap);
AJFREE(in0);
ajStrDel(&seqid);
ajStrDel(&inseq);
}
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&filename);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPList idlist;
AjPList* fieldList = NULL;
AjBool systemsort;
AjBool cleanup;
ajint blastv = 0;
char dbtype = '\0';
ajuint maxindex;
ajuint maxidlen = 0;
ajuint maxlen;
AjPStr version = NULL;
AjPStr seqtype = NULL;
AjPFile elistfile = NULL;
AjPFile* alistfile = NULL;
AjPStr dbname = NULL;
AjPStr release = NULL;
AjPStr datestr = NULL;
AjPStr sortopt = NULL;
void **entryIds = NULL;
AjBool usesrc = AJTRUE;
AjPStr directory;
AjPStr indexdir;
AjPStr filename;
AjPStr exclude;
AjPStr curfilename = NULL;
AjPStr idformat = NULL;
EmbPEntry entry;
PBlastDb db = NULL;
ajuint idCount = 0;
ajuint idDone;
AjPList listTestFiles = NULL;
void ** testFiles = NULL;
ajuint nfiles;
ajuint ifile;
ajuint jfile;
ajuint filesize;
short recsize;
ajuint maxfilelen = 20;
char date[4] =
{
0,0,0,0
};
AjPStr tmpfname = NULL;
AjPStr* fields = NULL;
AjPFile entFile = NULL;
AjPStr* divfiles = NULL;
ajint* maxFieldLen = NULL;
ajuint ifield = 0;
ajuint nfields = 0;
AjPFile logfile = NULL;
ajuint* countField = NULL;
ajuint* fieldTot = NULL;
ajuint idCountFile = 0;
ajuint i = 0;
embInit("dbiblast", argc, argv);
idformat = ajStrNewC("NCBI");
fields = ajAcdGetList("fields");
directory = ajAcdGetDirectoryName("directory");
indexdir = ajAcdGetOutdirName("indexoutdir");
filename = ajAcdGetString("filenames");
exclude = ajAcdGetString("exclude");
dbname = ajAcdGetString("dbname");
release = ajAcdGetString("release");
datestr = ajAcdGetString("date");
systemsort = ajAcdGetBoolean("systemsort");
cleanup = ajAcdGetBoolean("cleanup");
sortopt = ajAcdGetString("sortoptions");
maxindex = ajAcdGetInt("maxindex");
version = ajAcdGetListSingle("blastversion");
seqtype = ajAcdGetListSingle("seqtype");
usesrc = ajAcdGetBoolean("sourcefile");
logfile = ajAcdGetOutfile("outfile");
while(fields[nfields]) /* array ends with a NULL */
nfields++;
if(nfields)
{
AJCNEW(maxFieldLen, nfields);
AJCNEW0(countField, nfields);
AJCNEW0(fieldTot, nfields);
for(ifield=0; ifield < nfields; ifield++)
maxFieldLen[ifield] = (ajint) maxindex * -1;
if(systemsort)
AJCNEW(alistfile, nfields);
else
{
AJCNEW(fieldList, nfields);
for(ifield=0; ifield < nfields; ifield++)
fieldList[ifield] = ajListNew();
}
}
if(ajStrMatchC(datestr, "00/00/00"))
ajFmtPrintS(&datestr, "%D", ajTimeRefTodayFmt("dbindex"));
ajStrRemoveWhite(&dbname); /* used for temp filenames */
embDbiDateSet(datestr, date);
idlist = ajListNew();
if(ajUtilGetBigendian())
readReverse = ajFalse;
else
readReverse = ajTrue;
ajStrToInt(version, &blastv);
dbtype = ajStrGetCharFirst(seqtype);
ajDebug("reading '%S/%S'\n", directory, filename);
ajDebug("writing '%S/'\n", indexdir);
listTestFiles = embDbiFileListExc(directory, filename, exclude);
ajListSort(listTestFiles, ajStrVcmp);
nfiles = ajListToarray(listTestFiles, &testFiles);
if(!nfiles)
ajDie("No input files in '%S' matched filename '%S'",
directory, filename);
embDbiLogHeader(logfile, dbname, release, datestr,
indexdir, maxindex);
embDbiLogFields(logfile, fields, nfields);
embDbiLogSource(logfile, directory, filename, exclude,
(AjPStr*) testFiles, nfiles);
embDbiLogCmdline(logfile);
AJCNEW0(divfiles, nfiles);
/*
** process each input file, one at a time
*/
jfile = 0;
for(ifile=0; ifile < nfiles; ifile++)
{
curfilename = (AjPStr) testFiles[ifile];
if(!dbiblast_blastopenlib(curfilename,
usesrc, blastv, dbtype, &db))
continue; /* could be the wrong file type with "*.*" */
ajDebug("processing filename '%S' ...\n", curfilename);
ajDebug("processing file '%S' ...\n", db->TFile->Name);
ajStrAssignS(&divfiles[jfile], db->TFile->Name);
ajFilenameTrimPath(&divfiles[jfile]);
if(ajStrGetLen(divfiles[jfile]) >= maxfilelen)
maxfilelen = ajStrGetLen(divfiles[jfile]) + 1;
if(systemsort) /* elistfile for entries, alist for fields */
elistfile = embDbiSortOpen(alistfile, jfile,
dbname, fields, nfields);
idCountFile = 0;
for(i=0;i<nfields;i++)
countField[i] = 0;
while((entry=dbiblast_nextblastentry(db, jfile,
idformat, systemsort,
fields,
maxFieldLen,
&maxidlen, countField,
elistfile, alistfile)))
{
idCountFile++;
if(!systemsort) /* save the entry data in lists */
{
embDbiMemEntry(idlist, fieldList, nfields, entry, jfile);
}
}
idCount += idCountFile;
if(systemsort)
{
embDbiSortClose(&elistfile, alistfile, nfields);
/* lost the entry, so can't free it :-) */
}
embDbiLogFile(logfile, curfilename, idCountFile, fields,
countField, nfields);
dbiblast_dbfree(&db);
jfile++;
}
nfiles = jfile;
/*
** write the division.lkp file
*/
embDbiWriteDivision(indexdir, dbname, release, date,
maxfilelen, nfiles, divfiles, NULL);
/*
** Write the entryname.idx index
*/
ajStrAssignC(&tmpfname, "entrynam.idx");
entFile = ajFileNewOutNamePathS(tmpfname, indexdir);
recsize = maxidlen+10;
filesize = 300 + (idCount*(ajint)recsize);
embDbiHeader(entFile, filesize, idCount, recsize, dbname, release, date);
if(systemsort)
idDone = embDbiSortWriteEntry(entFile, maxidlen,
dbname, nfiles, cleanup, sortopt);
else /* save entries in entryIds array */
{
idDone = embDbiMemWriteEntry(entFile, maxidlen,
idlist, &entryIds);
if(idDone != idCount)
ajFatal("Duplicates not allowed for in-memory processing");
}
embDbiHeaderSize(entFile, 300+(idDone*(ajint)recsize), idDone);
ajFileClose(&entFile);
/*
** Write the fields index files
*/
for(ifield=0; ifield < nfields; ifield++)
{
if(maxindex)
maxlen = maxindex;
else
{
if(maxFieldLen[ifield] >= 0)
maxlen = maxFieldLen[ifield];
else
maxlen = - maxFieldLen[ifield];
}
if(systemsort)
fieldTot[ifield] = embDbiSortWriteFields(dbname, release,
date, indexdir,
fields[ifield], maxlen,
nfiles, idCount,
cleanup, sortopt);
else
fieldTot[ifield] = embDbiMemWriteFields(dbname, release,
date, indexdir,
fields[ifield], maxlen,
fieldList[ifield],
entryIds);
}
embDbiLogFinal(logfile,maxindex, maxFieldLen, fields, fieldTot,
nfields, nfiles, idDone, idCount);
if(systemsort)
embDbiRmEntryFile(dbname, cleanup);
ajListMap(idlist, embDbiEntryDelMap, NULL);
ajListFree(&idlist);
AJFREE(entryIds);
ajStrDelarray(&fields);
for(i=0;i<nfields;i++)
{
if(systemsort)
{
ajFileClose(&alistfile[i]);
}
else
{
ajListMap(fieldList[i], embDbiFieldDelMap, NULL);
ajListFree(&fieldList[i]);
}
}
AJFREE(alistfile);
AJFREE(fieldList);
ajStrDel(&version);
ajStrDel(&seqtype);
ajFileClose(&elistfile);
for(i=0;i<nfiles;i++)
{
ajStrDel(&divfiles[i]);
}
AJFREE(countField);
AJFREE(fieldTot);
ajStrDel(&dbname);
ajStrDel(&release);
ajStrDel(&datestr);
ajStrDel(&sortopt);
ajStrDel(&directory);
ajStrDel(&indexdir);
ajStrDel(&filename);
ajStrDel(&exclude);
ajStrDel(&idformat);
ajStrDel(&tmpfname);
AJFREE(maxFieldLen);
ajFileClose(&logfile);
ajListstrFreeData(&listTestFiles);
ajStrDel(&t);
ajStrDel(&id);
ajStrDel(&acc);
ajStrDel(&hline);
ajStrDel(&tmpdes);
ajStrDel(&tmpfd);
ajStrDel(&tmpgi);
ajStrDel(&tmpdb);
ajStrDel(&tmpac);
ajStrDel(&tmpsv);
ajRegFree(&wrdexp);
embDbiEntryDel(&dbiblastEntry);
if(fdl)
{
for(i=0; i < nfields; i++)
ajListFree(&fdl[i]);
AJFREE(fdl);
}
for(i=0;i<nfiles;i++)
{
ajStrDel(&divfiles[i]);
}
AJFREE(divfiles);
AJFREE(testFiles);
embExit();
return 0;
}
int main(ajint argc, char **argv)
{
AjPList pdb_path =NULL; /* Path of pdb files */
AjPStr pdb_name =NULL; /* Name of pdb file */
AjPDirout ccf_path =NULL; /* Path of ccf files */
AjPStr ccf_name =NULL; /* Name of ccf file */
AjPStr pdbid =NULL; /* PDB code */
AjPStr pdbid_temp =NULL; /* PDB code */
AjBool ccfnaming =ajFalse;
/* True == use the pdbid code to name the output file,
False== use the name of the original pdb file*/
/* Mask non-amino acid groups in protein chains that do not
contain a C-alpha atom. The group will not appear in either
the CO or SQ records of the clean coordinate file */
AjBool camask =ajFalse;
/* Mask amino acids in protein chains that do not contain a
C-alpha atom. The amino acid will appear not appear in the
CO record but will still be present in the SQ record of the
clean coordinate file */
AjBool camask1 =ajFalse;
/* Mask residues or groups in protein chains with a single atom only */
AjBool atommask =ajFalse;
AjPStr temp =NULL; /* Temp string */
AjPStr msg =NULL; /* Error message */
AjPStr base_name =NULL; /* Name of pdb file w/o path or
extension */
AjPFile pdb_inf =NULL; /* pdb input file pointer */
AjPFile ccf_outf =NULL; /* ccf output file pointer */
AjPFile logf =NULL; /* log file pointer*/
AjPPdb pdb =NULL; /* Pdb structure (for parsed data) */
ajint min_chain_size=0; /* Minimum length of a SEQRES chain
for it to be parsed */
ajint max_mismatch=0; /* Max. no. residues to trim when checking
for missing C-terminal SEQRES residues. */
ajint max_trim=0; /* Maximum number of permissible
mismatches between the ATOM and
SEQRES sequences */
ajint pos =0; /* Location of the file extension in
the pdb file name */
/* THIS_DIAGNOSTIC
tempstr=ajStrNew();
ajStrAssignC(&tempstr, "diagnostics");
tempfile=ajFileNewOutNameS(tempstr);
ajStrDel(&tempstr);*/
/* Initialise strings */
ccf_name = ajStrNew();
pdb_name = ajStrNew();
temp = ajStrNew();
msg = ajStrNew();
base_name = ajStrNew();
pdbid = ajStrNew();
pdbid_temp = ajStrNew();
/* Read data from acd */
embInitPV("pdbparse",argc,argv,"STRUCTURE",VERSION);
pdb_path = ajAcdGetDirlist("pdbpath");
ccf_path = ajAcdGetOutdir("ccfoutdir");
logf = ajAcdGetOutfile("logfile");
min_chain_size=ajAcdGetInt("chnsiz");
max_mismatch =ajAcdGetInt("maxmis");
max_trim =ajAcdGetInt("maxtrim");
ccfnaming = ajAcdGetBoolean("ccfnaming");
camask = ajAcdGetBoolean("camask");
camask1 = ajAcdGetBoolean("camaska");
atommask = ajAcdGetBoolean("atommask");
/* Check directories*/
/*Start of main application loop*/
while(ajListPop(pdb_path,(void **)&temp))
{
ajFmtPrint("Processing %S\n", temp);
ajFmtPrintF(logf, "%S\n", temp);
/* Read pdb file*/
if((pdb_inf=ajFileNewInNameS(temp))==NULL)
{
ajFmtPrintS(&msg, "Could not open for reading %S ",
temp);
ajWarn(ajStrGetPtr(msg));
ajFmtPrintF(logf, "%-15s%S\n//\n", "FILE_OPEN", temp);
ajStrDel(&temp);
continue;
}
/* Assign pdb id code from file name */
ajStrAssignS(&pdbid, temp);
ajFilenameTrimPathExt(&pdbid);
if(MAJSTRGETLEN(pdbid)>4)
{
/* The file name is longer than expected (and probably contains a
prefix). Take the last four characters to be the pdbid code */
ajStrAssignSubS(&pdbid_temp, pdbid, pos-4, pos-1);
ajStrAssignS(&pdbid, pdbid_temp);
}
else if(MAJSTRGETLEN(pdbid)<4)
ajFatal("Could not determine pdbid code from file name (%S)", pdbid);
/* Parse pdb file and write pdb structure */
if(!(pdb=ajPdbReadRawNew(pdb_inf, pdbid, min_chain_size, max_mismatch,
max_trim, camask, camask1, atommask, logf)))
{
ajFmtPrintS(&msg, "Clean coordinate file not generated for %S", temp);
ajWarn(ajStrGetPtr(msg));
ajFmtPrintF(logf, "%-15s%S\n//\n", "NO_OUTPUT", temp);
ajFileClose(&pdb_inf);
ajStrDel(&temp);
continue;
}
/* Open clean coordinate file for writing*/
if(ccfnaming)
ajStrAssignS(&ccf_name, pdb->Pdb);
else
ajStrAssignS(&ccf_name, temp);
ajStrFmtLower(&ccf_name);
if(!(ccf_outf=ajFileNewOutNameDirS(ccf_name, ccf_path)))
{
ajFmtPrintS(&msg, "Could not open %S for writing",
ccf_name);
ajWarn(ajStrGetPtr(msg));
ajFmtPrintF(logf, "%-15s%S\n//\n", "FILE_OPEN", ccf_name);
ajFileClose(&pdb_inf);
ajPdbDel(&pdb);
ajStrDel(&temp);
continue;
}
/* Write pdb file */
if(!ajPdbWriteAll(ccf_outf, pdb))
{
ajFmtPrintS(&msg, "Could not write file %S", ccf_name);
ajWarn(ajStrGetPtr(msg));
ajFmtPrintF(logf, "%-15s%S\n//\n", "FILE_WRITE", ccf_name);
ajFmtPrintS(&temp, "rm %S", ccf_name);
ajFmtPrint("%S", temp);
ajSysSystem(temp);
ajFileClose(&pdb_inf);
ajFileClose(&ccf_outf);
ajPdbDel(&pdb);
ajStrDel(&temp);
continue;
}
/* Tidy up*/
ajFileClose(&pdb_inf);
ajFileClose(&ccf_outf);
ajPdbDel(&pdb);
ajStrDel(&temp);
ajFmtPrintF(logf, "//\n");
}
/*End of main application loop*/
/*Tidy up */
ajListFree(&pdb_path);
ajStrDel(&pdb_name);
ajDiroutDel(&ccf_path);
ajStrDel(&ccf_name);
ajStrDel(&base_name);
ajStrDel(&pdbid);
ajStrDel(&pdbid_temp);
ajStrDel(&msg);
ajFileClose(&logf);
/* DIAGNOSTIC
ajFileClose(&tempfile);
*/
/* Return */
ajExit();
return 0;
}
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)
{
AjPDasServer server = NULL;
AjPDasSource source = NULL;
AjPDasSegment segment = NULL;
AjPStr host = NULL;
AjPStr path = NULL;
AjPFile outf = NULL;
ajint port = 80;
AjBool sequencesourcesonly;
AjBool entrypoints;
AjBool showtestqueries;
AjBool runtestqueries = ajTrue;
AjBool quickexit = ajFalse;
ajint itest=0;
ajint j=0;
ajint maxtests=0;
ajint maxfeatures=0;
ajint maxsegments=0;
AjIList iter = NULL;
AjIList coordsi = NULL;
AjIList itereps = NULL;
AjPFilebuff buff = NULL;
AjPUrlref uo = NULL;
AjPList segments = NULL;
AjPStr ffname = NULL;
AjPStr url = NULL;
AjPStr dbhttpver = ajStrNew();
AjPStr dbname = ajStrNew();
AjPStr dbproxy = ajStrNew();
AjPStr servername = NULL;
AjPTable titlecount = NULL;
const ajuint* count;
int k=0;
embInit("dastest", argc, argv);
host = ajAcdGetString("host");
path = ajAcdGetString("path");
port = ajAcdGetInt("port");
sequencesourcesonly = ajAcdGetBoolean("sequencesourcesonly");
entrypoints = ajAcdGetBoolean("entrypoints");
showtestqueries = ajAcdGetBoolean("showtestqueries");
runtestqueries = ajAcdGetBoolean("runtestqueries");
servername = ajAcdGetString("servername");
outf = ajAcdGetOutfile("outfile");
maxtests = ajAcdGetInt("maxtests");
maxfeatures = ajAcdGetInt("maxfeatures");
maxsegments = ajAcdGetInt("maxsegments");
server = ajDasServerNew();
if(runtestqueries)
{
url = ajStrNew();
if(!ajNamServer(servername))
{
ajWarn("following das server is required to be defined "
"for test queries...");
ajWarn("\nSERVER %S [\n"
" type: \"sequence\"\n"
" method: \"das\"\n"
" url: \"http://%S%S\"\n"
"]\n",servername, host,path);
ajWarn("ignoring -runtestqueries option...");
runtestqueries = ajFalse;
}
else
{
ajNamSvrGetUrl(servername, &url);
ajHttpUrlDeconstruct(url, &port, &host, &path);
ajStrDel(&url);
}
}
ajDasServerSethostS(server,host);
ajDasServerSetport(server,port);
if(ajStrGetCharLast(path)!='/')
ajStrAppendK(&path,'/');
ajStrAppendC(&path,"sources");
ajDasServerSetpathS(server,path);
ajFmtPrintF(outf,"host = %S\npath = %S\nport = %d\n",
server->host, server->path, server->port);
/*
* TODO: stop using http-read but instead use
* ajNamSvrListListDatabases(svrname, dbnames);
*/
buff = ajHttpRead(dbhttpver, dbname, dbproxy, host, port, path);
if(!buff)
ajExitAbort();
ajFilebuffHtmlNoheader(buff);
ajDasParseRegistry(buff, server->sources);
ajFmtPrintF(outf,"DAS sources and descriptions\n\n");
titlecount = dastestGetTitleCount(server);
iter = ajListIterNew(server->sources);
while(!ajListIterDone(iter) && !quickexit)
{
source = ajListIterGet(iter);
if ((sequencesourcesonly && !source->sequence)
|| ajStrMatchC(source->title,"cath") || k++ <50)
continue;
ajFmtPrintF(outf,"%-30S %-50S\n%S\n",source->uri,source->title,
source->description);
if(entrypoints && source->entry_points)
{
uo = ajHttpUrlrefNew();
ajHttpUrlrefParseC(&uo, ajStrGetPtr(source->entry_points_uri));
if(ajStrGetLen(uo->Port))
ajStrToInt(uo->Port, &port);
else
port = 80;
ajFilebuffDel(&buff);
buff = ajHttpRead(dbhttpver, dbname, dbproxy,
uo->Host, port, uo->Absolute);
ajHttpUrlrefDel(&uo);
if(!buff)
continue;
ajFilebuffHtmlNoheader(buff);
segments = ajListNew();
ajDasParseEntrypoints(buff, segments);
itereps = ajListIterNew(segments);
ajFmtPrintF(outf, "Number of entry points %d\n",
ajListGetLength(segments));
j=0;
while(!ajListIterDone(itereps))
{
segment = ajListIterGet(itereps);
if (j++ < maxsegments)
ajFmtPrintF(outf,
"segment id:%S orientation:%S start:%d stop:%d\n",
segment->id,
segment->orientation,
segment->start, segment->stop);
ajDasSegmentDel(&segment);
}
ajListIterDel(&itereps);
ajListFree(&segments);
}
if(showtestqueries || runtestqueries)
{
AjPDasCoordinate coord;
coordsi = ajListIterNew(source->coordinates);
while(!ajListIterDone(coordsi) && !quickexit)
{
coord = ajListIterGet(coordsi);
ajDebug("coordinate uri:%S taxid:%S source:%S test_range:%S\n",
coord->uri,
coord->taxid,
coord->source,
coord->test_range);
if(showtestqueries)
{
if(source->sequence)
ajFmtPrintF(outf,
"example/test entry = '%S?segment=%S'\n",
source->sequence_query_uri,coord->test_range);
if(source->features)
ajFmtPrintF(outf,
"example/test entry = '%S?segment=%S'\n",
source->features_query_uri,coord->test_range);
}
if(runtestqueries)
{
AjPStr idqry = ajStrNew();
AjPStr entry = NULL;
AjPSeq seq = NULL;
ajint ibegin = 0;
ajint iend = 0;
AjPStr example = NULL;
example = ajDasTestrangeParse(coord->test_range,
&entry, &ibegin, &iend);
if(ajStrGetLen(entry))
{
count = ajTableFetchS(titlecount, source->title);
dbname = ajDasSourceGetDBname(source, *count>1);
if (source->features)
{
AjPStr qpath=NULL;
uo = ajHttpUrlrefNew();
ajFmtPrintS(&idqry,"dasgff::%S:%S:%S",
servername,
dbname,
entry);
ajFmtPrintF(outf,
"feature query: %S start:%d end:%d\n",
idqry,
ibegin, iend);
ajHttpUrlrefParseC(&uo,
ajStrGetPtr(source->features_query_uri));
ajHttpUrlrefSplitPort(uo);
ajFmtPrintS(&qpath,"%S?segment=%S",
uo->Absolute,entry);
if(iend>0)
ajFmtPrintAppS(&qpath,":%d,%d",ibegin, iend);
if(ajStrGetLen(uo->Port))
ajStrToInt(uo->Port, &port);
else
port = 80;
ajDebug("calling ajHttpRead to get the raw"
" output; host:%S port:%d path:%S\n",
uo->Host, port, qpath);
ajFilebuffDel(&buff);
buff = ajHttpRead(dbhttpver, dbname, dbproxy,
uo->Host, port, qpath);
if(buff)
{
AjPFeattable ft;
ajFmtPrintS(&ffname, "%S.%S", source->uri,
entry);
ajFilebuffHtmlNoheader(buff);
dastestSaveRawFeatures(buff, ffname);
ajDebug("now using EMBOSS feature queries\n");
ft = dastestFeatureQuery(idqry,
ibegin, iend);
dastestSaveMappedFeatures(ft, ffname,
outf, maxfeatures);
ajStrDel(&ffname);
ajFeattableDel(&ft);
}
ajHttpUrlrefDel(&uo);
ajStrDel(&qpath);
if(++itest>=maxtests)
quickexit = ajTrue;
}
else if(source->sequence)
{
seq = ajSeqNewRes(iend-ibegin+1);
ajFmtPrintS(&idqry,"%S:%S:%S",
servername, dbname, entry);
ajFmtPrintF(outf,
"sequence query: %S start:%d end:%d\n",
idqry,
ibegin, iend);
ajSeqGetFromUsaRange(idqry, ajFalse, ibegin, iend,
seq);
ajFmtPrintF(outf,
"length of sequence returned: %d\n",
ajSeqGetLen(seq));
if(ajSeqGetLen(seq)>0)
ajFmtPrintF(outf,
"sequence returned (first 100 bases):"
" %-100.100s\n",
ajSeqGetSeqC(seq));
ajSeqDel(&seq);
}
ajStrDel(&dbname);
}
ajStrDel(&entry);
ajStrDel(&idqry);
ajStrDel(&example);
}
}
ajListIterDel(&coordsi);
}
}
ajListIterDel(&iter);
ajDasServerDel(&server);
ajFilebuffDel(&buff);
ajStrDel(&host);
ajStrDel(&path);
ajStrDel(&servername);
ajStrDel(&dbhttpver);
ajStrDel(&dbname);
ajStrDel(&dbproxy);
ajFileClose(&outf);
ajTableDelValdel(&titlecount, ajMemFree);
embExit();
return 0;
}
int main(int argc, char **argv)
{
const char *hmmfile; /* file to read HMMs from */
FILE *fp; /* output file handle */
HMMFILE *hmmfp; /* opened hmmfile for reading */
struct plan7_s *hmm; /* HMM to generate from */
int L; /* length of a sequence */
int i; /* counter over sequences */
char *ofile; /* output sequence file */
int nseq; /* number of seqs to sample */
int seed; /* random number generator seed */
int be_quiet; /* TRUE to silence header/footer */
int do_alignment; /* TRUE to output in aligned format */
int do_consensus; /* TRUE to do a single consensus seq */
AjBool ajselex;
AjBool ajcons;
AjPFile inf=NULL;
AjPFile outf=NULL;
AjPStr instr=NULL;
AjPStr outstr=NULL;
#ifdef MEMDEBUG
unsigned long histid1, histid2, orig_size, current_size;
orig_size = malloc_inuse(&histid1);
fprintf(stderr, "[... memory debugging is ON ...]\n");
#endif
/***********************************************
* Parse command line
***********************************************/
nseq = 10;
be_quiet = FALSE;
do_alignment = FALSE;
do_consensus = FALSE;
ofile = NULL;
embInitPV("ohmmemit",argc,argv,"HMMER",VERSION);
ajselex = ajAcdGetBoolean("selex");
ajcons = ajAcdGetBoolean("consensus");
nseq = ajAcdGetInt("number");
seed = ajAcdGetInt("seed");
inf = ajAcdGetInfile("infile");
outf = ajAcdGetOutfile("outfile");
if(!seed)
seed = time ((time_t *) NULL);
if(ajselex)
do_alignment=TRUE;
else
do_alignment=FALSE;
if(ajcons)
do_consensus=TRUE;
else
do_consensus=FALSE;
instr = ajStrNewC((char *)ajFileGetNameC(inf));
outstr = ajStrNewC((char *)ajFileGetNameC(outf));
hmmfile = ajStrGetPtr(instr);
sre_srandom(seed);
if (do_alignment && do_consensus)
ajFatal("Sorry, -selex and -consensus are incompatible.\n");
if (nseq != 10 && do_consensus)
ajWarn("-consensus overrides -number (# of sampled seqs)");
/***********************************************
* Open HMM file (might be in HMMERDB or current directory).
* Read a single HMM from it.
***********************************************/
if ((hmmfp = HMMFileOpen(hmmfile, "HMMERDB")) == NULL)
ajFatal("Failed to open HMM file %s\n", hmmfile);
if (!HMMFileRead(hmmfp, &hmm))
ajFatal("Failed to read any HMMs from %s\n", hmmfile);
HMMFileClose(hmmfp);
if (hmm == NULL)
ajFatal("HMM file %s corrupt or in incorrect format? Parse failed",
hmmfile);
/* Configure the HMM to shut off N,J,C emission: so we
* do a simple single pass through the model.
*/
Plan7NakedConfig(hmm);
Plan7Renormalize(hmm);
/***********************************************
* Open the output file, or stdout
***********************************************/
fp = ajFileGetFileptr(outf);
/***********************************************
* Show the options banner
***********************************************/
be_quiet=TRUE;
if (! be_quiet)
{
printf("HMM file: %s\n", hmmfile);
if (! do_consensus)
{
printf("Number of seqs: %d\n", nseq);
printf("Random seed: %d\n", seed);
}
printf("- - - - - - - - - - - - - - - - - - - - - - - - - "
"- - - - - - -\n\n");
}
/***********************************************
* Do the work.
* If we're generating an alignment, we have to collect
* all our traces, then output. If we're generating unaligned
* sequences, we can emit one at a time.
***********************************************/
if (do_consensus)
{
char *seq;
SQINFO sqinfo; /* info about sequence (name/desc) */
EmitConsensusSequence(hmm, &seq, NULL, &L, NULL);
strcpy(sqinfo.name, "consensus");
sqinfo.len = L;
sqinfo.flags = SQINFO_NAME | SQINFO_LEN;
WriteSeq(fp, kPearson, seq, &sqinfo);
free(seq);
}
else if (do_alignment)
{
struct p7trace_s **tr;
char **dsq;
SQINFO *sqinfo;
char **aseq;
AINFO ainfo;
float *wgt;
dsq = MallocOrDie(sizeof(char *) * nseq);
tr = MallocOrDie(sizeof(struct p7trace_s *) * nseq);
sqinfo = MallocOrDie(sizeof(SQINFO) * nseq);
wgt = MallocOrDie(sizeof(float) * nseq);
FSet(wgt, nseq, 1.0);
for (i = 0; i < nseq; i++)
{
EmitSequence(hmm, &(dsq[i]), &L, &(tr[i]));
sprintf(sqinfo[i].name, "seq%d", i+1);
sqinfo[i].len = L;
sqinfo[i].flags = SQINFO_NAME | SQINFO_LEN;
}
P7Traces2Alignment(dsq, sqinfo, wgt, nseq, hmm->M, tr, FALSE,
&aseq, &ainfo);
/* Output the alignment */
WriteSELEX(fp, aseq, &ainfo, 50);
if (ofile != NULL && !be_quiet)
printf("Alignment saved in file %s\n", ofile);
/* Free memory
*/
for (i = 0; i < nseq; i++)
{
P7FreeTrace(tr[i]);
free(dsq[i]);
}
FreeAlignment(aseq, &ainfo);
free(sqinfo);
free(dsq);
free(wgt);
free(tr);
}
else /* unaligned sequence output */
{
struct p7trace_s *tr;
char *dsq;
char *seq;
SQINFO sqinfo;
for (i = 0; i < nseq; i++)
{
EmitSequence(hmm, &dsq, &L, &tr);
sprintf(sqinfo.name, "seq%d", i+1);
sqinfo.len = L;
sqinfo.flags = SQINFO_NAME | SQINFO_LEN;
seq = DedigitizeSequence(dsq, L);
WriteSeq(fp, kPearson, seq, &sqinfo);
P7FreeTrace(tr);
free(dsq);
free(seq);
}
}
ajFileClose(&outf);
FreePlan7(hmm);
SqdClean();
#ifdef MEMDEBUG
current_size = malloc_inuse(&histid2);
if (current_size != orig_size)
malloc_list(2, histid1, histid2);
else
fprintf(stderr, "[No memory leaks.]\n");
#endif
ajStrDel(&instr);
ajStrDel(&outstr);
ajFileClose(&inf);
ajFileClose(&outf);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPSeq seq;
AjPGraph graph = 0;
AjPFile outf = NULL;
AjPFile file = NULL;
AjPStr buffer = NULL;
float twist[4][4][4];
float roll[4][4][4];
float tilt[4][4][4];
float rbend;
float rcurve;
float bendscale;
float curvescale;
float twistsum = (float) 0.0;
float pi = (float) 3.14159;
float pifac = (pi/(float) 180.0);
float pi2 = pi/(float) 2.0;
ajint *iseq = NULL;
float *x;
float *y;
float *xave;
float *yave;
float *curve;
float *bend;
const char *ptr;
ajint i;
ajint ii;
ajint k;
ajint j;
char residue[2];
float maxbend;
float minbend;
float bendfactor;
float maxcurve;
float mincurve;
float curvefactor;
float fxp;
float fyp;
float yincr;
float yy1;
ajint ixlen;
ajint iylen;
ajint ixoff;
ajint iyoff;
float ystart;
float defheight;
float currentheight;
ajint count;
ajint portrait = 0;
ajint title = 0;
ajint numres;
ajint ibeg;
ajint iend;
ajint ilen;
AjPStr sstr = NULL;
ajint ipos;
float dx;
float dy;
float rxsum;
float rysum;
float yp1;
float yp2;
double td;
embInit("banana", argc, argv);
seq = ajAcdGetSeq("sequence");
file = ajAcdGetDatafile("anglesfile");
outf = ajAcdGetOutfile("outfile");
graph = ajAcdGetGraph("graph");
numres = ajAcdGetInt("residuesperline");
ibeg = ajSeqGetBegin(seq);
iend = ajSeqGetEnd(seq);
ajStrAssignSubS(&sstr, ajSeqGetSeqS(seq), ibeg-1, iend-1);
ilen = ajStrGetLen(sstr);
AJCNEW0(iseq,ilen+1);
AJCNEW0(x,ilen+1);
AJCNEW0(y,ilen+1);
AJCNEW0(xave,ilen+1);
AJCNEW0(yave,ilen+1);
AJCNEW0(curve,ilen+1);
AJCNEW0(bend,ilen+1);
ptr= ajStrGetPtr(sstr);
for(ii=0;ii<ilen;ii++)
{
if(*ptr=='A' || *ptr=='a')
iseq[ii+1] = 0;
else if(*ptr=='T' || *ptr=='t')
iseq[ii+1] = 1;
else if(*ptr=='G' || *ptr=='g')
iseq[ii+1] = 2;
else if(*ptr=='C' || *ptr=='c')
iseq[ii+1] = 3;
else
ajErr("%c is not an ATCG hence not valid",*ptr);
ptr++;
}
if(!file)
ajErr("Banana failed to open angle file");
ajReadline(file,&buffer); /* 3 junk lines */
ajReadline(file,&buffer);
ajReadline(file,&buffer);
for(k=0;k<4;k++)
for(ii=0;ii<4;ii++)
{
if(ajReadline(file,&buffer))
{
sscanf(ajStrGetPtr(buffer),"%f,%f,%f,%f",
&twist[ii][0][k],&twist[ii][1][k],&twist[ii][2][k],
&twist[ii][3][k]);
}
else
ajErr("Error reading angle file");
for(j=0;j<4;j++)
twist[ii][j][k] *= pifac;
}
for(k=0;k<4;k++)
for(ii=0;ii<4;ii++)
if(ajReadline(file,&buffer))
{
sscanf(ajStrGetPtr(buffer),"%f,%f,%f,%f",&roll[ii][0][k],
&roll[ii][1][k],&roll[ii][2][k],&roll[ii][3][k]);
}
else
ajErr("Error reading angle file");
for(k=0;k<4;k++)
for(ii=0;ii<4;ii++)
if(ajReadline(file,&buffer))
sscanf(ajStrGetPtr(buffer),"%f,%f,%f,%f",&tilt[ii][0][k],
&tilt[ii][1][k],&tilt[ii][2][k],&tilt[ii][3][k]);
else
ajErr("Error reading angle file");
if(ajReadline(file,&buffer))
sscanf(ajStrGetPtr(buffer),"%f,%f,%f,%f",&rbend,&rcurve,
&bendscale,&curvescale);
else
ajErr("Error reading angle file");
ajFileClose(&file);
ajStrDel(&buffer);
for(ii=1;ii<ilen-1;ii++)
{
twistsum += twist[iseq[ii]][iseq[ii+1]][iseq[ii+2]];
dx = (roll[iseq[ii]][iseq[ii+1]][iseq[ii+2]]*sinfban(twistsum)) +
(tilt[iseq[ii]][iseq[ii+1]][iseq[ii+2]]*sinfban(twistsum-pi2));
dy = roll[iseq[ii]][iseq[ii+1]][iseq[ii+2]]*cosfban(twistsum) +
tilt[iseq[ii]][iseq[ii+1]][iseq[ii+2]]*cosfban(twistsum-pi2);
x[ii+1] = x[ii]+dx;
y[ii+1] = y[ii]+dy;
}
for(ii=6;ii<ilen-6;ii++)
{
rxsum = 0.0;
rysum = 0.0;
for(k=-4;k<=4;k++)
{
rxsum+=x[ii+k];
rysum+=y[ii+k];
}
rxsum+=(x[ii+5]*(float)0.5);
rysum+=(y[ii+5]*(float)0.5);
rxsum+=(x[ii-5]*(float)0.5);
rysum+=(y[ii-5]*(float)0.5);
xave[ii] = rxsum*(float)0.1;
yave[ii] = rysum*(float)0.1;
}
for(i=(ajint)rbend+1;i<=ilen-(ajint)rbend-1;i++)
{
td = sqrt(((x[i+(ajint)rbend]-x[i-(ajint)rbend])*
(x[i+(ajint)rbend]-x[i-(ajint)rbend])) +
((y[i+(ajint)rbend]-y[i-(ajint)rbend])*
(y[i+(ajint)rbend]-y[i-(ajint)rbend])));
bend[i] = (float) td;
bend[i]*=bendscale;
}
for(i=(ajint)rcurve+6;i<=ilen-(ajint)rcurve-6;i++)
{
td = sqrt(((xave[i+(ajint)rcurve]-
xave[i-(ajint)rcurve])*(xave[i+(ajint)rcurve]-
xave[i-(ajint)rcurve]))+
((yave[i+(ajint)rcurve]-yave[i-(ajint)rcurve])*
(yave[i+(ajint)rcurve]-yave[i-(ajint)rcurve])));
curve[i] = (float) td;
}
if(outf)
{
ajFmtPrintF(outf,"Base Bend Curve\n");
ptr = ajStrGetPtr(sstr);
for(ii=1;ii<=ilen;ii++)
{
ajFmtPrintF(outf,"%c %6.1f %6.1f\n",
*ptr, bend[ii], curve[ii]);
ptr++;
}
ajFileClose(&outf);
}
if(graph)
{
maxbend = minbend = 0.0;
maxcurve = mincurve = 0.0;
for(ii=1;ii<=ilen;ii++)
{
if(bend[ii] > maxbend)
maxbend = bend[ii];
if(bend[ii] < minbend)
minbend = bend[ii];
if(curve[ii] > maxcurve)
maxcurve = curve[ii];
if(curve[ii] < mincurve)
mincurve = curve[ii];
}
ystart = 75.0;
ajGraphAppendTitleS(graph, ajSeqGetUsaS(seq));
ajGraphicsSetPagesize(960, 768);
ajGraphOpenWin(graph,(float)-1.0, (float)numres+(float)10.0,
(float)0.0, ystart+(float)5.0);
ajGraphicsGetParamsPage(&fxp,&fyp,&ixlen,&iylen,&ixoff,&iyoff);
if(portrait)
{
ixlen = 768;
iylen = 960;
}
else
{
ixlen = 960;
iylen = 768;
}
ajGraphicsGetCharsize(&defheight,¤theight);
if(!currentheight)
{
defheight = currentheight = (float) 4.440072;
currentheight = defheight *
((float)ixlen/ ((float)(numres)*(currentheight+(float)1.0)))
/currentheight;
}
ajGraphicsSetCharscale(((float)ixlen/((float)(numres)*
(currentheight+(float)1.0)))/
currentheight);
ajGraphicsGetCharsize(&defheight,¤theight);
yincr = (currentheight + (float)3.0)*(float)0.3;
if(!title)
yy1 = ystart;
else
yy1 = ystart-(float)5.0;
count = 1;
residue[1]='\0';
bendfactor = (3*yincr)/maxbend;
curvefactor = (3*yincr)/maxcurve;
ptr = ajStrGetPtr(sstr);
yy1 = yy1-(yincr*((float)5.0));
for(ii=1;ii<=ilen;ii++)
{
if(count > numres)
{
yy1 = yy1-(yincr*((float)5.0));
if(yy1<1.0)
{
if(!title)
yy1=ystart;
else
yy1 = ystart-(float)5.0;
yy1 = yy1-(yincr*((float)5.0));
ajGraphNewpage(graph,AJFALSE);
}
count = 1;
}
residue[0] = *ptr;
ajGraphicsDrawposTextAtend((float)(count)+(float)2.0,yy1,residue);
if(ii>1 && ii < ilen)
{
yp1 = yy1+yincr + (bend[ii]*bendfactor);
yp2 = yy1+yincr + (bend[ii+1]*bendfactor);
ajGraphicsDrawposLine((float)count+(float)1.5,yp1,
(float)(count)+(float)2.5,yp2);
}
ipos = ilen-(ajint)rcurve-7;
if(ipos < 0)
ipos = 0;
if(ii>rcurve+5 && ii<ipos)
{
yp1 = yy1+yincr + (curve[ii]*curvefactor);
yp2 = yy1+yincr + (curve[ii+1]*curvefactor);
ajGraphicsDrawposLine((float)count+(float)1.7,yp1,
(float)(count)+(float)2.3,yp2);
}
ajGraphicsDrawposLine((float)count+(float)1.5,yy1+yincr,
(float)(count)+(float)2.5,yy1+yincr);
count++;
ptr++;
}
ajGraphicsClose();
}
AJFREE(iseq);
AJFREE(x);
AJFREE(y);
AJFREE(xave);
AJFREE(yave);
AJFREE(curve);
AJFREE(bend);
ajStrDel(&sstr);
ajSeqDel(&seq);
ajFileClose(&file);
ajFileClose(&outf);
ajGraphxyDel(&graph);
embExit();
return 0;
}
int main(int argc, char *argv[])
{
embInitPV("ggeneskew", argc, argv, "GEMBASSY", "1.0.3");
AjPSeqall seqall;
AjPSeq seq;
AjPStr inseq = NULL;
ajint window = 0;
ajint slide = 0;
AjBool cumulative = ajFalse;
AjBool gc3 = ajFalse;
AjPStr basetype = NULL;
AjBool accid = ajFalse;
AjPStr restid = NULL;
AjPStr seqid = NULL;
AjPStr base = NULL;
AjPStr url = NULL;
AjPFile tmpfile = NULL;
AjPStr tmpname = NULL;
AjBool plot = 0;
AjPFile outf = NULL;
AjPFilebuff buff = NULL;
AjPGraph mult = NULL;
gPlotParams gpp;
AjPStr title = NULL;
seqall = ajAcdGetSeqall("sequence");
window = ajAcdGetInt("window");
slide = ajAcdGetInt("slide");
cumulative = ajAcdGetBoolean("cumulative");
gc3 = ajAcdGetBoolean("gctri");
basetype = ajAcdGetSelectSingle("base");
accid = ajAcdGetBoolean("accid");
plot = ajAcdGetToggle("plot");
outf = ajAcdGetOutfile("outfile");
mult = ajAcdGetGraphxy("graph");
if(ajStrMatchC(base, "none"))
basetype = ajStrNewC("");
base = ajStrNewC("rest.g-language.org");
gAssignUniqueName(&tmpname);
while(ajSeqallNext(seqall, &seq))
{
inseq = NULL;
if(!accid)
{
if(gFormatGenbank(seq, &inseq))
{
gAssignUniqueName(&tmpname);
tmpfile = ajFileNewOutNameS(tmpname);
if(!tmpfile)
{
ajFmtError("Output file (%S) open error\n", tmpname);
embExitBad();
}
ajFmtPrintF(tmpfile, "%S", inseq);
ajFileClose(&tmpfile);
ajFmtPrintS(&url, "http://%S/upload/upl.pl", base);
gFilePostSS(url, tmpname, &restid);
ajStrDel(&url);
ajSysFileUnlinkS(tmpname);
}
else
{
ajFmtError("Sequence does not have features\n"
"Proceeding with sequence accession ID\n");
accid = ajTrue;
}
}
ajStrAssignS(&seqid, ajSeqGetAccS(seq));
if(ajStrGetLen(seqid) == 0)
{
ajStrAssignS(&seqid, ajSeqGetNameS(seq));
}
if(ajStrGetLen(seqid) == 0)
{
ajWarn("No valid header information\n");
}
if(accid)
{
ajStrAssignS(&restid, seqid);
if(ajStrGetLen(seqid) == 0)
{
ajDie("Cannot proceed without header with -accid\n");
}
if(!gValID(seqid))
{
ajDie("Invalid accession ID:%S, exiting\n", seqid);
}
}
url = ajStrNew();
ajFmtPrintS(&url, "http://%S/%S/geneskew/window=%d/slide=%d/"
"cumulative=%d/gc3=%d/base=%S/output=f/tag=gene",
base, restid, window, slide, cumulative, gc3, basetype);
if(plot)
{
title = ajStrNew();
ajStrAppendC(&title, argv[0]);
ajStrAppendC(&title, " of ");
ajStrAppendS(&title, seqid);
gpp.title = ajStrNewS(title);
gpp.xlab = ajStrNewC("gene skew");
gpp.ylab = ajStrNewC("bp");
if(!gFilebuffURLS(url, &buff))
{
ajDie("File downloading error from:\n%S\n", url);
}
if(!gPlotFilebuff(buff, mult, &gpp))
{
ajDie("Error in plotting\n");
}
AJFREE(gpp.title);
AJFREE(gpp.xlab);
AJFREE(gpp.ylab);
ajStrDel(&title);
ajFilebuffDel(&buff);
}
else
{
ajFmtPrintF(outf, "Sequence: %S\n", seqid);
if(!gFileOutURLS(url, &outf))
{
ajDie("File downloading error from:\n%S\n", url);
}
}
ajStrDel(&url);
ajStrDel(&restid);
ajStrDel(&seqid);
ajStrDel(&inseq);
}
ajFileClose(&outf);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&base);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPSeqall seqall;
AjPSeqout seqout;
AjPSeq seq;
ajint size;
ajint overlap;
ajint len;
ajint pos;
AjBool addover;
AjBool feature;
AjPStr outseq_name = ajStrNew();
ajint start;
ajint end;
embInit("splitter", argc, argv);
seqout = ajAcdGetSeqoutall("outseq");
seqall = ajAcdGetSeqall("sequence");
size = ajAcdGetInt("size");
overlap = ajAcdGetInt("overlap");
addover = ajAcdGetBoolean("addoverlap");
feature = ajAcdGetBoolean("feature");
while(ajSeqallNext(seqall, &seq))
{
ajSeqTrim(seq);
len = ajSeqGetLen(seq);
pos = 0;
ajStrAssignC(&outseq_name, "");
if (!addover)
{
while(pos+size <= len-1)
{
start = pos;
end = pos+size-1;
splitter_MakeSubSeqName (&outseq_name, seq, start, end);
splitter_ProcessChunk (seqout, seq, start, end,
outseq_name, feature);
pos += size-overlap;
}
}
else
{
while(pos+size+overlap < len-1)
{
start = pos;
end = pos+size+overlap-1;
splitter_MakeSubSeqName (&outseq_name, seq, start, end);
splitter_ProcessChunk (seqout, seq, start, end,
outseq_name, feature);
pos += size;
}
}
splitter_MakeSubSeqName(&outseq_name, seq, pos, len-1);
splitter_ProcessChunk (seqout, seq, pos, len-1,
outseq_name, feature);
}
ajSeqoutClose(seqout);
ajSeqallDel(&seqall);
ajSeqoutDel(&seqout);
ajSeqDel(&seq);
ajStrDel(&outseq_name);
embExit();
return 0;
}
int main(int argc, char *argv[])
{
embInitPV("ggcsi", argc, argv, "GEMBASSY", "1.0.1");
struct soap soap;
struct ns1__gcsiInputParams params;
AjPSeqall seqall;
AjPSeq seq;
AjPStr inseq = NULL;
AjPStr seqid = NULL;
ajint window = 0;
AjBool at = 0;
AjBool purine = 0;
AjBool keto = 0;
AjBool pval = 0;
AjPStr version = NULL;
AjBool accid = ajFalse;
AjPStr tmp = NULL;
AjPStr parse = NULL;
AjPStr gcsi = NULL;
AjPStr sa = NULL;
AjPStr dist = NULL;
AjPStr z = NULL;
AjPStr p = NULL;
AjPStrTok handle = NULL;
char *in0;
char *result;
AjPFile outf = NULL;
seqall = ajAcdGetSeqall("sequence");
window = ajAcdGetInt("window");
at = ajAcdGetBoolean("at");
purine = ajAcdGetBoolean("purine");
keto = ajAcdGetBoolean("keto");
pval = ajAcdGetBoolean("pval");
version = ajAcdGetSelectSingle("gcsi");
accid = ajAcdGetBoolean("accid");
outf = ajAcdGetOutfile("outfile");
params.window = window;
params.at = 0;
params.purine = 0;
params.keto = 0;
params.p = 0;
ajStrToInt(version, &(params.version));
if(at)
params.at = 1;
if(purine)
params.purine = 1;
if(keto)
params.keto = 1;
if(pval)
params.p = 1;
while(ajSeqallNext(seqall, &seq))
{
soap_init(&soap);
inseq = NULL;
ajStrAppendC(&inseq, ">");
ajStrAppendS(&inseq, ajSeqGetNameS(seq));
ajStrAppendC(&inseq, "\n");
ajStrAppendS(&inseq, ajSeqGetSeqS(seq));
ajStrAssignS(&seqid, ajSeqGetAccS(seq));
in0 = ajCharNewS(inseq);
if (soap_call_ns1__gcsi(
&soap,
NULL,
NULL,
in0,
¶ms,
&result
) == SOAP_OK)
{
tmp = ajStrNew();
parse = ajStrNew();
gcsi = ajStrNew();
sa = ajStrNew();
dist = ajStrNew();
z = ajStrNew();
p = ajStrNew();
ajStrAssignC(&tmp, result);
ajStrExchangeCC(&tmp, "<", "\n");
ajStrExchangeCC(&tmp, ">", "\n");
handle = ajStrTokenNewC(tmp, "\n");
while (ajStrTokenNextParse(&handle, &parse))
{
if (ajStrIsFloat(parse))
{
if(!ajStrGetLen(gcsi))
ajStrAssignS(&gcsi, parse);
else if(!ajStrGetLen(sa))
ajStrAssignS(&sa, parse);
else if(!ajStrGetLen(dist))
ajStrAssignS(&dist, parse);
else if(!ajStrGetLen(z))
ajStrAssignS(&z, parse);
else if(!ajStrGetLen(p))
ajStrAssignS(&p, parse);
}
}
tmp = ajFmtStr("Sequence: %S GCSI: %S SA: %S DIST: %S",
seqid, gcsi, sa, dist);
if(pval)
tmp = ajFmtStr("%S Z: %S P: %S", tmp, z, p);
ajFmtPrintF(outf, "%S\n", tmp);
ajStrDel(&tmp);
ajStrDel(&parse);
ajStrDel(&gcsi);
ajStrDel(&sa);
ajStrDel(&dist);
ajStrDel(&z);
ajStrDel(&p);
}
else
{
soap_print_fault(&soap, stderr);
}
soap_destroy(&soap);
soap_end(&soap);
soap_done(&soap);
AJFREE(in0);
ajStrDel(&inseq);
}
ajFileClose(&outf);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&seqid);
embExit();
return 0;
}
int main(int argc, char *argv[])
{
embInitPV("ggcskew", argc, argv, "GEMBASSY", "1.0.3");
AjPSeqall seqall;
AjPSeq seq;
AjPStr inseq = NULL;
AjBool accid = ajFalse;
AjPStr restid = NULL;
AjPStr seqid = NULL;
AjPStr base = NULL;
AjPStr url = NULL;
AjPStr tmpname = NULL;
AjPSeqout tmpout = NULL;
ajint window = 0;
ajint slide = 0;
AjBool cumulative = 0;
AjBool at = 0;
AjBool purine = 0;
AjBool keto = 0;
AjBool plot = 0;
AjPFile outf = NULL;
AjPFilebuff buff = NULL;
AjPGraph mult = NULL;
gPlotParams gpp;
AjPStr title = NULL;
seqall = ajAcdGetSeqall("sequence");
window = ajAcdGetInt("window");
slide = ajAcdGetInt("slide");
cumulative = ajAcdGetBoolean("cumulative");
at = ajAcdGetBoolean("at");
purine = ajAcdGetBoolean("purine");
keto = ajAcdGetBoolean("keto");
plot = ajAcdGetToggle("plot");
outf = ajAcdGetOutfile("outfile");
mult = ajAcdGetGraphxy("graph");
base = ajStrNewC("rest.g-language.org");
gAssignUniqueName(&tmpname);
ajStrAppendC(&tmpname, ".fasta");
while(ajSeqallNext(seqall, &seq))
{
tmpout = ajSeqoutNew();
if(!ajSeqoutOpenFilename(tmpout, tmpname))
{
embExitBad();
}
ajSeqoutSetFormatS(tmpout,ajStrNewC("fasta"));
ajSeqoutWriteSeq(tmpout, seq);
ajSeqoutClose(tmpout);
ajSeqoutDel(&tmpout);
ajFmtPrintS(&url, "http://%S/upload/upl.pl", base);
gFilePostSS(url, tmpname, &restid);
ajStrDel(&url);
ajSysFileUnlinkS(tmpname);
ajStrAssignS(&seqid, ajSeqGetAccS(seq));
if(ajStrGetLen(seqid) == 0)
{
ajStrAssignS(&seqid, ajSeqGetNameS(seq));
}
if(ajStrGetLen(seqid) == 0)
{
ajWarn("No valid header information\n");
}
url = ajStrNew();
ajFmtPrintS(&url, "http://%S/%S/gcskew/window=%d/slide=%d/cumulative=%d/"
"at=%d/purine=%d/keto=%d/output=f/", base, restid, window,
slide, cumulative, at, purine, keto);
if(plot)
{
title = ajStrNew();
ajStrAppendC(&title, argv[0]);
ajStrAppendC(&title, " of ");
ajStrAppendS(&title, seqid);
gpp.title = ajStrNewS(title);
gpp.xlab = ajStrNewC("location");
gpp.ylab = ajStrNewC("GC skew");
if(!gFilebuffURLS(url, &buff))
{
ajDie("File downloading error from:\n%S\n", url);
}
if(!gPlotFilebuff(buff, mult, &gpp))
{
ajDie("Error in plotting\n");
}
AJFREE(gpp.title);
AJFREE(gpp.xlab);
AJFREE(gpp.ylab);
ajStrDel(&title);
ajFilebuffDel(&buff);
}
else
{
ajFmtPrintF(outf, "Sequence: %S\n", seqid);
if(!gFileOutURLS(url, &outf))
{
ajDie("File downloading error from:\n%S\n", url);
}
}
ajStrDel(&url);
ajStrDel(&restid);
ajStrDel(&seqid);
}
ajFileClose(&outf);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&base);
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;
}
int main(int argc, char *argv[])
{
embInitPV("gbaseinformationcontent", argc, argv, "GEMBASSY", "1.0.1");
AjPSeqall seqall;
AjPSeq seq;
AjPStr inseq = NULL;
AjPStr position = 0;
ajint PatLen = 0;
ajint upstream = 0;
ajint downstream = 0;
AjBool accid = ajFalse;
AjPStr restid = NULL;
AjPStr seqid = NULL;
AjPStr base = NULL;
AjPStr url = NULL;
AjPFile tmpfile = NULL;
AjPStr tmpname = NULL;
AjBool plot = 0;
AjPFile outf = NULL;
AjPFilebuff buff = NULL;
AjPGraph mult = NULL;
gPlotParams gpp;
AjPStr title = NULL;
seqall = ajAcdGetSeqall("sequence");
position = ajAcdGetSelectSingle("position");
PatLen = ajAcdGetInt("patlen");
upstream = ajAcdGetInt("upstream");
downstream = ajAcdGetInt("downstream");
accid = ajAcdGetBoolean("accid");
plot = ajAcdGetToggle("plot");
outf = ajAcdGetOutfile("outfile");
mult = ajAcdGetGraphxy("graph");
base = ajStrNewC("rest.g-language.org");
gAssignUniqueName(&tmpname);
while(ajSeqallNext(seqall, &seq))
{
inseq = NULL;
if(!accid)
{
if(gFormatGenbank(seq, &inseq))
{
gAssignUniqueName(&tmpname);
tmpfile = ajFileNewOutNameS(tmpname);
if(!tmpfile)
{
ajFmtError("Output file (%S) open error\n", tmpname);
embExitBad();
}
ajFmtPrintF(tmpfile, "%S", inseq);
ajFileClose(&tmpfile);
ajFmtPrintS(&url, "http://%S/upload/upl.pl", base);
gFilePostSS(url, tmpname, &restid);
ajStrDel(&url);
ajSysFileUnlinkS(tmpname);
}
else
{
ajFmtError("Sequence does not have features\n"
"Proceeding with sequence accession ID\n");
accid = ajTrue;
}
}
if(accid)
{
ajStrAssignS(&seqid, ajSeqGetAccS(seq));
if(!ajStrGetLen(seqid))
{
ajStrAssignS(&seqid, ajSeqGetNameS(seq));
}
if(!ajStrGetLen(seqid))
{
ajFmtError("No valid header information\n");
embExitBad();
}
ajStrAssignS(&restid, seqid);
}
ajStrAssignS(&seqid, ajSeqGetAccS(seq));
url = ajStrNew();
ajFmtPrintS(&url, "http://%S/%S/base_information_content/position=%S/"
"PatLen=%d/upstream=%d/downstream=%d/output=f/tag=gene",
base, restid, position, PatLen, upstream, downstream);
if(plot)
{
title = ajStrNew();
ajStrAppendC(&title, argv[0]);
ajStrAppendC(&title, " of ");
ajStrAppendS(&title, seqid);
gpp.title = ajStrNewS(title);
gpp.xlab = ajStrNewC("position");
gpp.ylab = ajStrNewC("information content");
if(!gFilebuffURLS(url, &buff))
{
ajDie("File downloading error from:\n%S\n", url);
}
if(!gPlotFilebuff(buff, mult, &gpp))
{
ajDie("Error in plotting\n");
}
AJFREE(gpp.title);
AJFREE(gpp.xlab);
AJFREE(gpp.ylab);
ajStrDel(&title);
ajFilebuffDel(&buff);
}
else
{
ajFmtPrintF(outf, "Sequence: %S\n", seqid);
if(!gFileOutURLS(url, &outf))
{
ajDie("File downloading error from:\n%S\n", url);
}
}
}
ajFileClose(&outf);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&seqid);
ajStrDel(&position);
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)
{
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;
}