static void emira_dolistsingles(AjPStr *cl, AjPTable table)
{
ajuint i;
AjPStr squal = NULL;
AjPStr prefix = NULL;
AjPStr key = NULL;
AjPStr value = NULL;
prefix = ajStrNew();
key = ajStrNew();
i = 0;
while(miralistsingles[i].qname)
{
squal = ajAcdGetListSingle(miralistsingles[i].qname);
ajStrAssignC(&key,miralistsingles[i].qname);
ajStrAssignC(&prefix,"");
value = ajTableFetch(table, key);
if(value)
ajStrAssignS(&prefix,value);
if(!ajStrMatchC(squal,miralistsingles[i].def))
ajFmtPrintAppS(cl," -%S%s=%S",prefix,miralistsingles[i].mname,
squal);
ajStrDel(&squal);
++i;
}
ajStrDel(&key);
ajStrDel(&prefix);
return;
}
static void emira_dobools(AjPStr *cl, AjPTable table)
{
ajuint i;
AjBool bqual = ajFalse;
AjBool def = ajFalse;
AjPStr prefix = NULL;
AjPStr key = NULL;
AjPStr value = NULL;
prefix = ajStrNew();
key = ajStrNew();
i = 0;
while(mirabools[i].qname)
{
bqual = ajAcdGetBoolean(mirabools[i].qname);
ajStrAssignC(&key,mirabools[i].qname);
ajStrAssignC(&prefix,"");
value = ajTableFetch(table, key);
if(value)
ajStrAssignS(&prefix,value);
def = ajCharMatchC(mirabools[i].def,"N") ? ajFalse : ajTrue;
if(bqual != def)
{
ajFmtPrintAppS(cl," -%S%s=",prefix,mirabools[i].mname);
if(bqual)
ajFmtPrintAppS(cl,"yes");
else
ajFmtPrintAppS(cl,"no");
}
++i;
}
ajStrDel(&key);
ajStrDel(&prefix);
return;
}
static void silent_fmt_sequence(const char* title,
const AjPStr seq, AjPStr* tailstr, ajint start,
AjBool num)
{
const char *p;
ajint m;
ajint i;
ajint tlen;
ajFmtPrintAppS(tailstr,"%s:\n",title);
if(num)
{
p = ajStrGetPtr(seq);
ajFmtPrintAppS(tailstr,"%-7d",start);
tlen = ajStrGetLen(seq);
for(i=0; i<tlen ; i++)
{
ajFmtPrintAppS(tailstr,"%c",p[i]);
m=i+1;
if(m%10==0)
ajFmtPrintAppS(tailstr," ");
if(m%60==0 && m<tlen)
ajFmtPrintAppS(tailstr,"\n%-7d",(start+m+1));
}
}
else
{
p = ajStrGetPtr(seq);
tlen = ajStrGetLen(seq);
for(i=0; i<tlen ; i++)
{
ajFmtPrintAppS(tailstr,"%c",p[i]);
m=i+1;
if(m%10==0)
ajFmtPrintAppS(tailstr," ");
if(m%60==0 && m<tlen)
ajFmtPrintAppS(tailstr,"\n");
}
}
ajFmtPrintAppS(tailstr,"\n\n");
return;
}
ajuint ajPatlistRegexDoc (AjPPatlistRegex plist, AjPStr* Pdoc)
{
AjPPatternRegex pat = NULL;
ajFmtPrintS(Pdoc, "%-12S %S\n", "Pattern_name", "Pattern");
while (ajPatlistRegexGetNext(plist, &pat))
ajFmtPrintAppS(Pdoc, "%-12S %S\n",
ajPatternRegexGetName(pat),
ajPatternRegexGetPattern(pat));
return ajListGetLength(plist->Patlist);
}
ajuint ajPatlistSeqDoc (AjPPatlistSeq plist, AjPStr* Pdoc)
{
AjPPatternSeq pat = NULL;
ajFmtPrintS(Pdoc, "%-12s %8s %s\n",
"Pattern_name", "Mismatch", "Pattern");
while (ajPatlistSeqGetNext(plist, &pat))
{
ajFmtPrintAppS(Pdoc, "%-12S %8d %S\n",
ajPatternSeqGetName(pat),
ajPatternSeqGetMismatch(pat),
ajPatternSeqGetPattern(pat));
}
return ajListGetLength(plist->Patlist);
}
static void emira_doinfiles(AjPStr *cl, AjPTable table)
{
ajuint i;
AjPStr squal = NULL;
AjPStr prefix = NULL;
AjPStr key = NULL;
AjPStr value = NULL;
AjPFile infile = NULL;
prefix = ajStrNew();
key = ajStrNew();
i = 0;
while(mirainfiles[i].qname)
{
infile = ajAcdGetInfile(mirainfiles[i].qname);
if(infile)
squal = ajStrNewS(ajFileGetName(infile));
else
squal = ajStrNewS(ajAcdGetValueDefault(mirainfiles[i].qname));
ajStrAssignC(&key,mirainfiles[i].mname);
ajStrAssignC(&prefix,"");
value = ajTableFetch(table, key);
if(value)
ajStrAssignS(&prefix,value);
if(!ajStrMatchC(squal,mirainfiles[i].def))
ajFmtPrintAppS(cl," -%S%s=%S",prefix,mirainfiles[i].mname,
squal);
ajStrDel(&squal);
ajFileClose(&infile);
++i;
}
ajStrDel(&key);
ajStrDel(&prefix);
return;
}
void ajAssemoutprintWiki(AjPFile outf)
{
ajint i = 0;
ajint j = 0;
AjPStr namestr = NULL;
ajFmtPrintF(outf, "{| class=\"wikitable sortable\" border=\"2\"\n");
ajFmtPrintF(outf, "|-\n");
ajFmtPrintF(outf, "!Format!!"
"class=\"unsortable\"|Description\n");
for(i=0; assemoutFormatDef[i].Name; i++)
{
ajFmtPrintF(outf, "|-\n");
ajStrAssignC(&namestr, assemoutFormatDef[i].Name);
for(j=i+1; assemoutFormatDef[j].Name; j++)
{
if(assemoutFormatDef[j].Write == assemoutFormatDef[i].Write)
{
ajFmtPrintAppS(&namestr, "<br>%s",
assemoutFormatDef[j].Name);
ajWarn("Assembly output format '%s' same as '%s' "
"but not alias",
assemoutFormatDef[j].Name,
assemoutFormatDef[i].Name);
}
}
ajFmtPrintF(outf, "|%S||%s\n",
namestr,
assemoutFormatDef[i].Desc);
}
ajFmtPrintF(outf, "|}\n");
ajStrDel(&namestr);
return;
}
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;
}
static const AjPStr assemSAMGetReadgroupHeaderlines(const AjPAssem assem)
{
AjPStr* rgids = NULL;
const AjPAssemReadgroup rg = NULL;
ajint i =0;
ajTableToarrayKeys(assem->Readgroups, (void***)&rgids);
ajStrAssignC(&assemoutSamLinetxt, "");
while (rgids[i]) /* read groups */
{
rg = ajTableFetchS(assem->Readgroups, rgids[i++]);
ajFmtPrintAppS(&assemoutSamLinetxt, "@RG\tID:%S", rg->ID);
if(rg->CN)
ajFmtPrintAppS(&assemoutSamLinetxt, "\tCN:%S", rg->CN);
if(rg->Desc)
ajFmtPrintAppS(&assemoutSamLinetxt, "\tDS:%S", rg->Desc);
if(rg->Date)
ajFmtPrintAppS(&assemoutSamLinetxt, "\tDT:%S", rg->Date);
if(rg->FlowOrder)
ajFmtPrintAppS(&assemoutSamLinetxt, "\tFO:%S", rg->FlowOrder);
if(rg->KeySeq)
ajFmtPrintAppS(&assemoutSamLinetxt, "\tKS:%S", rg->KeySeq);
if(rg->Library)
ajFmtPrintAppS(&assemoutSamLinetxt, "\tLB:%S", rg->Library);
if(rg->Programs)
ajFmtPrintAppS(&assemoutSamLinetxt, "\tPG:%S", rg->Programs);
if(rg->Isize)
ajFmtPrintAppS(&assemoutSamLinetxt, "\tPI:%d", rg->Isize);
if(rg->Platform)
ajFmtPrintAppS(&assemoutSamLinetxt, "\tPL:%s",
ajAssemreadgroupGetPlatformname(rg));
if(rg->Unit)
ajFmtPrintAppS(&assemoutSamLinetxt, "\tPU:%S", rg->Unit);
if(rg->Sample)
ajFmtPrintAppS(&assemoutSamLinetxt, "\tSM:%S", rg->Sample);
ajStrAppendC(&assemoutSamLinetxt, "\n");
}
AJFREE(rgids);
return assemoutSamLinetxt;
}
static void merger_Merge(AjPAlign align, AjPStr *ms,
const char *a, const char *b,
const AjPStr m, const AjPStr n, ajint start1,
ajint start2,
const char *namea, const char *nameb)
{
ajint apos;
ajint bpos;
ajint i;
AjPStr mm = NULL;
AjPStr nn = NULL;
char *p;
char *q;
ajint olen; /* length of walk alignment */
size_t tt;
/* lengths of the sequences after the aligned region */
ajint alen;
ajint blen;
AjPStr tmpstr = NULL;
mm = ajStrNewS(m);
nn = ajStrNewS(n);
p = ajStrGetuniquePtr(&mm);
q = ajStrGetuniquePtr(&nn);
olen = ajStrGetLen(mm);
/* output the left hand side */
if(start1 > start2)
{
for(i=0; i<start1; i++)
ajStrAppendK(ms, a[i]);
if(start2)
{
ajFmtPrintAppS(&tmpstr, "WARNING: *************************"
"********\n");
ajFmtPrintAppS(&tmpstr, "The region of alignment only starts at "
"position %d of sequence %s\n", start2+1, nameb);
ajFmtPrintAppS(&tmpstr, "Only the sequence of %s is being used "
"before this point\n\n", namea);
ajAlignSetTailApp(align, tmpstr);
ajStrDel(&tmpstr);
}
}
else if(start2 > start1)
{
for(i=0; i<start2; i++)
ajStrAppendK(ms, b[i]);
if(start1)
{
ajFmtPrintAppS(&tmpstr, "WARNING: **************************"
"*******\n");
ajFmtPrintAppS(&tmpstr, "The region of alignment only starts at "
"position %d of sequence %s\n", start1+1, namea);
ajFmtPrintAppS(&tmpstr, "Only the sequence of %s is being used "
"before this point\n\n", nameb);
ajAlignSetTailApp(align, tmpstr);
ajStrDel(&tmpstr);
}
}
else if(start1 && start2)
{
/* both the same length and > 1 before the aligned region */
ajFmtPrintAppS(&tmpstr,
"WARNING: *********************************\n");
ajFmtPrintAppS(&tmpstr, "There is an equal amount of unaligned "
"sequence (%d) at the start of the sequences.\n",
start1);
ajFmtPrintAppS(&tmpstr, "Sequence %s is being arbitrarily chosen "
"for the merged sequence\n\n", namea);
ajAlignSetTailApp(align, tmpstr);
ajStrDel(&tmpstr);
for(i=0; i<start1; i++)
ajStrAppendK(ms, a[i]);
}
/* header */
ajFmtPrintS(&tmpstr, "Conflicts: %15.15s %15.15s\n", namea, nameb);
ajFmtPrintAppS(&tmpstr,
" position base position base Using\n");
ajAlignSetTailApp(align, tmpstr);
/* make the merged sequence
**
** point to the start of the alignment in the complete unaligned
** sequences
*/
apos = start1;
bpos = start2;
for(i=0; i<olen; i++)
{
if(p[i]=='.' || p[i]==' ' || p[i]=='-' ||
q[i]=='.' || q[i]==' ' || q[i]=='-')
{ /* gap! */
if(merger_bestquality(a, b, apos, bpos))
{
p[i] = toupper((ajint)p[i]);
if(p[i] != '.' && p[i] != ' ' && p[i] != '-')
ajStrAppendK(ms, p[i]);
ajFmtPrintS(&tmpstr,
" %8d '%c' %8d '%c' '%c'\n",
apos+1, p[i], bpos+1, q[i], p[i]);
ajAlignSetTailApp(align, tmpstr);
}
else
{
q[i] = toupper((ajint)q[i]);
if(q[i] != '.' && q[i] != ' ' && q[i] != '-')
ajStrAppendK(ms, q[i]);
ajFmtPrintS(&tmpstr,
" %8d '%c' %8d '%c' '%c'\n",
apos+1, p[i], bpos+1, q[i], q[i]);
ajAlignSetTailApp(align, tmpstr);
}
}
else if(p[i]=='n' || p[i]=='N')
{
q[i] = toupper((ajint)q[i]);
ajStrAppendK(ms, q[i]);
}
else if(q[i]=='n' || q[i]=='N')
{
p[i] = toupper((ajint)p[i]);
ajStrAppendK(ms, p[i]);
}
else if(p[i] != q[i])
{
/*
** get the sequence with the best quality and use the base
** from that one
*/
if(merger_bestquality(a, b, apos, bpos))
{
p[i] = toupper((ajint)p[i]);
ajStrAppendK(ms, p[i]);
ajFmtPrintS(&tmpstr,
" %8d '%c' %8d '%c' '%c'\n",
apos+1, p[i], bpos+1, q[i], p[i]);
ajAlignSetTailApp(align, tmpstr);
}
else
{
q[i] = toupper((ajint)q[i]);
ajStrAppendK(ms, q[i]);
ajFmtPrintS(&tmpstr,
" %8d '%c' %8d '%c' '%c'\n",
apos+1, p[i], bpos+1, q[i], q[i]);
ajAlignSetTailApp(align, tmpstr);
}
}
else
ajStrAppendK(ms, p[i]);
/* update the positions in the unaligned complete sequences */
if(p[i] != '.' && p[i] != ' ' && p[i] != '-') apos++;
if(q[i] != '.' && q[i] != ' ' && q[i] != '-') bpos++;
}
/* output the right hand side */
tt = strlen(&a[apos]);
alen = (ajint) tt;
tt = strlen(&b[bpos]);
blen = (ajint) tt;
if(alen > blen)
{
ajStrAppendC(ms, &a[apos]);
if(blen)
{
ajFmtPrintAppS(&tmpstr, "WARNING: ***************************"
"******\n");
ajFmtPrintAppS(&tmpstr, "The region of alignment ends at "
"position %d of sequence %s\n",
bpos+1, nameb);
ajFmtPrintAppS(&tmpstr, "Only the sequence of %s is being used "
"after this point\n\n", namea);
ajAlignSetTailApp(align, tmpstr);
ajStrDel(&tmpstr);
}
}
if(blen > alen)
{
ajStrAppendC(ms, &b[bpos]);
if(alen)
{
ajFmtPrintAppS(&tmpstr, "WARNING: ***************************"
"******\n");
ajFmtPrintAppS(&tmpstr, "The region of alignment ends at "
"position %d of sequence %s\n",
apos+1, namea);
ajFmtPrintAppS(&tmpstr, "Only the sequence of %s is being used "
"after this point\n\n", nameb);
ajAlignSetTailApp(align, tmpstr);
ajStrDel(&tmpstr);
}
}
else if(alen && blen)
{ /* both the same length and > 1 */
ajFmtPrintAppS(&tmpstr, "WARNING: ************************"
"*********\n");
ajFmtPrintAppS(&tmpstr, "There is an equal amount of unaligned "
"sequence (%d) at the end of the sequences.\n",
alen);
ajFmtPrintAppS(&tmpstr, "Sequence %s is being arbitrarily chosen "
"for the merged sequence\n\n", namea);
ajStrAppendC(ms, &a[apos]);
ajAlignSetTailApp(align, tmpstr);
ajStrDel(&tmpstr);
}
ajStrDel(&mm);
ajStrDel(&nn);
ajStrDel(&tmpstr);
return;
}
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)
{
ajint i;
ajint numseq;
ajint j = 0;
ajint numres;
ajint count;
ajint k;
ajint kmax;
float defheight;
float currentscale;
AjPStr shade = NULL;
AjPFloat pair = NULL;
AjPGraph graph = NULL;
AjPMatrix cmpmatrix = NULL;
AjPSeqCvt cvt = NULL;
AjPStr matcodes = NULL;
AjBool consensus;
AjBool colourbyconsensus;
AjBool colourbyresidues;
AjBool colourbyshade = AJFALSE;
AjBool boxit;
AjBool boxcol;
AjBool portrait;
AjBool collision;
ajint identity;
AjBool listoptions;
ajint alternative;
AjPStr altstr = NULL;
AjPStr sidentity = NULL;
AjPStr ssimilarity = NULL;
AjPStr sother = NULL;
AjPStr sboxcolval = NULL;
AjPStr options = NULL;
/* ajint showscore = 0; */
ajint iboxcolval = 0;
ajint cidentity = RED;
ajint csimilarity = GREEN;
ajint cother = BLACK;
float fxp;
float fyp;
float yincr;
float y;
ajint ixlen;
ajint iylen;
ajint ixoff;
ajint iyoff;
char res[2] = " ";
float *score = 0;
float scoremax = 0;
float *identical = NULL;
ajint identicalmaxindex;
float *matching = NULL;
ajint matchingmaxindex;
float *colcheck = NULL;
ajint **matrix;
ajint m1 = 0;
ajint m2 = 0;
ajint ms = 0;
ajint highindex = 0;
ajint myindex;
ajint *previous = 0;
AjBool iscons = ajFalse;
ajint currentstate = 0;
ajint oldfg = 0;
float fold = 0.0;
ajint *colmat = 0;
ajint *shadecolour = 0;
/* float identthresh = 1.5; */
/* float simthresh = 1.0; */
/* float relthresh = 0.5; */
float part = 0.0;
const char *cptr;
ajint resbreak;
float fplural;
float ystart;
float xmin;
float xmax;
float xmid;
AjPTime ajtime;
ajint gapcount = 0;
ajint countforgap = 0;
ajint boxindex;
float max;
ajint matsize;
ajint seqperpage = 0;
ajint startseq;
ajint endseq;
ajint newILend = 0;
ajint newILstart;
void *freeptr;
ajint itmp;
embInit("prettyplot", argc, argv);
seqset = ajAcdGetSeqset("sequences");
numres = ajAcdGetInt("residuesperline");
resbreak = ajAcdGetInt("resbreak");
ajSeqsetFill(seqset); /* Pads sequence set with gap characters */
numseq = ajSeqsetGetSize(seqset);
graph = ajAcdGetGraph("graph");
colourbyconsensus = ajAcdGetBoolean("ccolours");
colourbyresidues = ajAcdGetBoolean("docolour");
shade = ajAcdGetString("shade");
pair = ajAcdGetArray("pair");
identity = ajAcdGetInt("identity");
boxit = ajAcdGetBoolean("box");
ajtime = ajTimeNewTodayFmt("daytime");
ajSeqsetTrim(seqset);
/* offset = ajSeqsetGetOffset(seqset); Unused */
ajGraphAppendTitleS(graph, ajSeqsetGetUsa(seqset));
if(boxit)
{
AJCNEW(seqboxptr, numseq);
for(i=0;i<numseq;i++)
AJCNEW(seqboxptr[i], ajSeqsetGetLen(seqset));
}
boxcol = ajAcdGetBoolean("boxcol");
sboxcolval = ajAcdGetString("boxuse");
if(boxcol)
{
iboxcolval = ajGraphicsCheckColourS(sboxcolval);
if(iboxcolval == -1)
iboxcolval = GREY;
}
consensus = ajAcdGetBoolean("consensus");
if(consensus)
{
AJCNEW(constr, ajSeqsetGetLen(seqset)+1);
constr[0] = '\0';
}
shownames = ajAcdGetBoolean("name");
shownumbers = ajAcdGetBoolean("number");
charlen = ajAcdGetInt("maxnamelen");
fplural = ajAcdGetFloat("plurality");
portrait = ajAcdGetBoolean("portrait");
collision = ajAcdGetBoolean("collision");
listoptions = ajAcdGetBoolean("listoptions");
altstr = ajAcdGetListSingle("alternative");
cmpmatrix = ajAcdGetMatrix("matrixfile");
ajStrToInt(altstr, &alternative);
matrix = ajMatrixGetMatrix(cmpmatrix);
cvt = ajMatrixGetCvt(cmpmatrix);
matsize = ajMatrixGetSize(cmpmatrix);
AJCNEW(identical,matsize);
AJCNEW(matching,matsize);
AJCNEW(colcheck,matsize);
numgaps = numres/resbreak;
numgaps--;
if(portrait)
{
ajGraphicsSetPortrait(1);
ystart = (float) 75.0;
}
else
ystart = (float) 75.0;
/* pair is an array of three non-negative floats */
/* identthresh = ajFloatGet(pair,0); Unused */
/* simthresh = ajFloatGet(pair,1); Unused */
/* relthresh = ajFloatGet(pair,2); Unused */
/*
** shade is a formatted 4-character string. Characters BLPW only.
** controlled by a pattern in ACD.
*/
if(ajStrGetLen(shade))
{
AJCNEW(shadecolour,4);
cptr = ajStrGetPtr(shade);
for(i=0;i<4;i++){
if(cptr[i]== 'B' || cptr[i]== 'b')
shadecolour[i] = BLACK;
else if(cptr[i]== 'L' || cptr[i]== 'l')
shadecolour[i] = BROWN;
else if(cptr[i]== 'P' || cptr[i]== 'p')
shadecolour[i] = WHEAT;
else if(cptr[i]== 'W' || cptr[i]== 'w')
shadecolour[i] = WHITE;
}
colourbyconsensus = colourbyresidues = ajFalse;
colourbyshade = ajTrue;
}
/*
** we can colour by consensus or residue but not both
** if we have to choose, use the consensus
*/
if(colourbyconsensus && colourbyresidues)
colourbyconsensus = AJFALSE;
sidentity = ajAcdGetString("cidentity");
ssimilarity = ajAcdGetString("csimilarity");
sother = ajAcdGetString("cother");
if(colourbyconsensus)
{
cidentity = ajGraphicsCheckColourS(sidentity);
if(cidentity == -1)
cidentity = RED;
csimilarity = ajGraphicsCheckColourS(ssimilarity);
if(csimilarity == -1)
csimilarity = GREEN;
cother = ajGraphicsCheckColourS(sother);
if(cother == -1)
cother = BLACK;
}
else if(colourbyresidues)
{
matcodes = ajMatrixGetCodes(cmpmatrix);
if(ajSeqsetIsProt(seqset))
colmat = ajGraphicsBasecolourNewProt(matcodes);
else
colmat = ajGraphicsBasecolourNewNuc(matcodes);
}
/* output the options used as the subtitle for the bottom of the graph */
if(listoptions)
{
ajStrAssignC(&options,"");
ajFmtPrintAppS(&options,"-plurality %.1f",fplural);
if(collision)
ajStrAppendC(&options," -collision");
else
ajStrAppendC(&options," -nocollision");
if(boxit)
ajStrAppendC(&options," -box");
else
ajStrAppendC(&options," -nobox");
if(boxcol)
ajStrAppendC(&options," -boxcol");
else
ajStrAppendC(&options," -noboxcol");
if(colourbyconsensus)
ajStrAppendC(&options," -colbyconsensus");
else if(colourbyresidues)
ajStrAppendC(&options," -colbyresidues");
else if(colourbyshade)
ajStrAppendC(&options," -colbyshade");
else
ajStrAppendC(&options," -nocolour");
if(alternative==2)
ajStrAppendC(&options," -alt 2");
else if(alternative==1)
ajStrAppendC(&options," -alt 1");
else if(alternative==3)
ajStrAppendC(&options," -alt 3");
}
AJCNEW(seqcolptr, numseq);
for(i=0;i<numseq;i++)
AJCNEW(seqcolptr[i], ajSeqsetGetLen(seqset));
AJCNEW(seqcharptr, numseq);
AJCNEW(seqnames, numseq);
AJCNEW(score, numseq);
AJCNEW(previous, numseq);
AJCNEW(seqcount, numseq);
for(i=0;i<numseq;i++)
{
ajSeqsetFmtUpper(seqset);
seqcharptr[i] = ajSeqsetGetseqSeqC(seqset, i);
seqnames[i] = 0;
ajStrAppendS(&seqnames[i],ajSeqsetGetseqNameS(seqset, i));
ajStrTruncateLen(&seqnames[i],charlen);
previous[i] = 0;
seqcount[i] = 0;
}
/*
** user will pass the number of residues to fit a page
** therefore we now need to calculate the size of the chars
** based on this and get the new char width.
** 'charlen' maximum characters for the name (truncated above)
*/
ajGraphicsGetCharsize(&defheight,¤tscale);
xmin = -charlen - (float)2.0;
xmax = (float)numres+(float)11.0+(float)(numres/resbreak);
xmid = (xmax + xmin)/(float)2.0;
ajGraphOpenWin(graph, xmin, xmax,
(float)0.0, ystart+(float)1.0);
ajGraphGetParamsPage(graph, &fxp,&fyp,&ixlen,&iylen,&ixoff,&iyoff);
if(portrait)
{
itmp = ixlen;
ixlen = iylen;
iylen = itmp;
}
ajGraphicsGetCharsize(&defheight,¤tscale);
ajGraphicsSetCharscale(((float)ixlen/((float)(numres+charlen+1)*
(currentscale * (float) 1.5)))/
currentscale);
/* ajGraphicsSetCharscale(((float)ixlen/((float)(numres+charlen)*
(currentscale+(float)1.0)))/
currentscale); */
ajGraphicsGetCharsize(&defheight,¤tscale);
yincr = (currentscale + (float)3.0)*(float)0.3;
/*
** If we have titles (now the standard graph title and subtitle and footer)
** leave 7 rows of space for them
*/
y=ystart-(float)7.0;
if(ajStrGetLen(options))
{
fold = ajGraphicsSetCharscale(1.0);
ajGraphicsDrawposTextAtmid(xmid,2.0,
ajStrGetPtr(options));
ajGraphicsSetCharscale(fold);
}
/* if sequences per page not set then calculate it */
if(!seqperpage)
{
seqperpage = prettyplot_calcseqperpage(yincr,y,consensus);
if(seqperpage>numseq)
seqperpage=numseq;
}
count = 0;
/*
** for boxes we need to set a foreground colour for the box lines
** and save the current foreground colour
*/
if(boxit && boxcol)
oldfg = ajGraphicsSetFgcolour(iboxcolval);
/*
** step through each residue position
*/
kmax = ajSeqsetGetLen(seqset) - 1;
for(k=0; k<= kmax; k++)
{
/* reset column score array */
for(i=0;i<numseq;i++)
score[i] = 0.0;
/* reset matrix character testing arrays */
for(i=0;i<matsize;i++)
{
identical[i] = 0.0;
matching[i] = 0.0;
colcheck[i] = 0.0;
}
/* generate a score for this residue in each sequence */
for(i=0;i<numseq;i++)
{
m1 = ajSeqcvtGetCodeK(cvt, seqcharptr[i][k]);
for(j=0;j<numseq;j++)
{
m2 = ajSeqcvtGetCodeK(cvt, seqcharptr[j][k]);
if(m1 && m2)
score[i] += (float)matrix[m1][m2]*
ajSeqsetGetseqWeight(seqset, j);
}
if(m1)
identical[m1] += ajSeqsetGetseqWeight(seqset, i);
}
/* find the highest score */
highindex = -1;
scoremax = INT_MIN;
/*ajDebug("Scores at position %d:\n", k);*/
for(i=0;i<numseq;i++)
{
/*ajDebug(" seq %d: '%c' %f\n",i,seqcharptr[i][k],score[i]);*/
if(score[i] > scoremax)
{
scoremax = score[i];
highindex = i;
}
}
for(i=0;i<numseq;i++)
{
m1 = ajSeqcvtGetCodeK(cvt, seqcharptr[i][k]);
if(!matching[m1])
{
for(j=0;j<numseq;j++)
{
m2 = ajSeqcvtGetCodeK(cvt, seqcharptr[j][k]);
if(m1 && m2 && matrix[m1][m2] > 0)
matching[m1] += ajSeqsetGetseqWeight(seqset, j);
}
}
}
/* find highs for matching and identical */
matchingmaxindex = 0;
identicalmaxindex = 0;
for(i=0;i<numseq;i++)
{
m1 = ajSeqcvtGetCodeK(cvt, seqcharptr[i][k]);
if(identical[m1] > identical[identicalmaxindex])
identicalmaxindex = m1;
}
for(i=0;i<numseq;i++)
{
m1 = ajSeqcvtGetCodeK(cvt, seqcharptr[i][k]);
if(matching[m1] > matching[matchingmaxindex])
matchingmaxindex = m1;
else if(matching[m1] == matching[matchingmaxindex])
{
if(identical[m1] > identical[matchingmaxindex])
matchingmaxindex= m1;
}
}
iscons = ajFalse;
boxindex = -1;
max = -3;
ajDebug("k:%2d highindex:%2d matching:%4.2f\n",
k, highindex,
matching[ajSeqcvtGetCodeK(cvt, seqcharptr[highindex][k])]);
if(highindex != -1 &&
matching[ajSeqcvtGetCodeK(cvt, seqcharptr[highindex][k])] >= fplural)
{
iscons = ajTrue;
boxindex = highindex;
}
else
{
for(i=0;i<numseq;i++)
{
m1 = ajSeqcvtGetCodeK(cvt, seqcharptr[i][k]);
if(matching[m1] > max)
{
max = matching[m1];
highindex = i;
}
else if(matching[m1] == max)
{
if(identical[m1] >
identical[ajSeqcvtGetCodeK(cvt,
seqcharptr[highindex][k])] )
{
max = matching[m1];
highindex = i;
}
}
}
if(matching[ajSeqcvtGetCodeK(cvt,
seqcharptr[highindex][k])] >= fplural)
{
iscons = ajTrue;
boxindex = highindex;
}
}
if(iscons)
{
if(!collision)
{
/* check for collisions */
if(alternative == 1)
{
/* check to see if this is unique for collisions */
for(i=0;i<numseq;i++)
{
m1 = ajSeqcvtGetCodeK(cvt, seqcharptr[i][k]);
if(identical[m1] >= identical[identicalmaxindex] &&
m1 != identicalmaxindex)
iscons = ajFalse;
}
/*ajDebug("after (alt=1) iscons: %B",iscons);*/
}
else if(alternative == 2)
{
for(i=0;i<numseq;i++)
{
m1 = ajSeqcvtGetCodeK(cvt, seqcharptr[i][k]);
if((matching[m1] >= matching[matchingmaxindex] &&
m1 != matchingmaxindex &&
matrix[m1][matchingmaxindex] < 0.1)||
(identical[m1] >= identical[matchingmaxindex]
&& m1 != matchingmaxindex))
iscons = ajFalse;
}
}
else if(alternative == 3)
{
/*
** to do this check one is NOT in consensus to see if
** another score of fplural has been found
*/
ms = ajSeqcvtGetCodeK(cvt, seqcharptr[highindex][k]);
for(i=0;i<numseq;i++)
{
m1 = ajSeqcvtGetCodeK(cvt, seqcharptr[i][k]);
if(ms != m1 && colcheck[m1] == 0.0)
/* NOT in the current consensus */
for(j=0;j<numseq;j++)
{
m2 = ajSeqcvtGetCodeK(cvt, seqcharptr[j][k]);
if( matrix[ms][m2] < 0.1)
{
/* NOT in the current consensus */
if( matrix[m1][m2] > 0.1)
colcheck[m1] +=
ajSeqsetGetseqWeight(seqset,
j);
}
}
}
for(i=0;i<numseq;i++)
{
m1 = ajSeqcvtGetCodeK(cvt, seqcharptr[i][k]);
/* if any other matches then we have a collision */
if(colcheck[m1] >= fplural)
iscons = ajFalse;
}
/*ajDebug("after alt=2 iscons: %B", iscons);*/
}
else
{
for(i=0;i<numseq;i++)
{
m1 = ajSeqcvtGetCodeK(cvt, seqcharptr[i][k]);
if((matching[m1] >= matching[matchingmaxindex] &&
m1 != matchingmaxindex &&
matrix[m1][matchingmaxindex] < 0.1))
iscons = ajFalse;
if(identical[m1] >= identical[matchingmaxindex] &&
m1 != matchingmaxindex &&
matrix[m1][matchingmaxindex] > 0.1)
iscons = ajFalse;
}
if(!iscons)
{ /* matches failed try identicals */
if(identical[identicalmaxindex] >= fplural)
{
iscons = ajTrue;
/*
** if nothing has an equal or higher match that
** does not match highest then false
*/
for(i=0;i<numseq;i++)
{
m1 = ajSeqcvtGetCodeK(cvt, seqcharptr[i][k]);
if(identical[m1] >=
identical[identicalmaxindex] &&
m1 != identicalmaxindex)
iscons = ajFalse;
else if(matching[m1] >=
matching[identicalmaxindex] &&
matrix[m1][matchingmaxindex] <= 0.0)
iscons = ajFalse;
else if(m1 == identicalmaxindex)
j = i;
}
if(iscons)
highindex = j;
}
}
}
}
if(identity)
{
j = 0;
for(i=0;i<numseq;i++)
if(seqcharptr[highindex][k] == seqcharptr[i][k])
j++;
if(j<identity)
iscons = ajFalse;
}
}
/*
** Done a full line of residues
** Boxes have been defined up to this point
*/
if(count >= numres )
{
/* check y position for next set */
y=y-(yincr*((float)numseq+(float)2.0+((float)consensus*(float)2)));
if(y<yincr*((float)numseq+(float)2.0+((float)consensus*(float)2)))
{
/* full page - print it */
y=ystart-(float)6.0;
startseq = 0;
endseq = seqperpage;
newILstart = newILend;
newILend = k;
while(startseq < numseq)
{
/* AJB */
/*if(startseq != 0)
ajGraphNewpage(graph, AJFALSE);*/
/*ajDebug("Inner loop: startseq: %d numseq: %d endseq: %d\n",
startseq, numseq, endseq);*/
if(endseq>numseq)
endseq=numseq;
prettyplot_fillinboxes(numseq,ajSeqsetGetLen(seqset),
startseq,endseq,
newILstart,newILend,
numres,resbreak,
boxit,boxcol,consensus,
ystart,yincr,cvt);
startseq = endseq;
endseq += seqperpage;
ajGraphNewpage(graph, AJFALSE);
}
}
count = 0;
gapcount = 0;
}
count++;
countforgap++;
for(j=0;j<numseq;j++)
{
/* START OF BOXES */
if(boxit)
{
seqboxptr[j][k] = 0;
if(boxindex!=-1)
{
myindex = boxindex;
if(matrix[ajSeqcvtGetCodeK(cvt, seqcharptr[j][k])]
[ajSeqcvtGetCodeK(cvt, seqcharptr[myindex][k])] > 0)
part = 1.0;
else
{
if(identical[ajSeqcvtGetCodeK(cvt,
seqcharptr[j][k])] >=
fplural)
part = 1.0;
else
part = 0.0;
}
if(previous[j] != part)
/* draw vertical line */
seqboxptr[j][k] |= BOXLEF;
if(j==0)
{
/* special case for horizontal line */
if(part)
{
currentstate = 1;
/* draw hori line */
seqboxptr[j][k] |= BOXTOP;
}
else
currentstate = 0;
}
else
{
/* j != 0 Normal case for horizontal line */
if(part != currentstate)
{
/*draw hori line */
seqboxptr[j][k] |= BOXTOP;
currentstate = (ajint) part;
}
}
if(j== numseq-1 && currentstate)
/* draw horiline at bottom */
seqboxptr[j][k] |= BOXBOT;
previous[j] = (ajint) part;
}
else
{
part = 0;
if(previous[j])
{
/* draw vertical line */
seqboxptr[j][k] |= BOXLEF;
}
previous[j] = 0;
}
if(count == numres || k == kmax || countforgap >= resbreak )
{ /* last one on the row or a break*/
if(previous[j])
{
/* draw vertical line */
seqboxptr[j][k] |= BOXRIG;
}
previous[j] = 0;
}
} /* end box */
if(boxit && boxcol)
if(boxindex != -1)
{
myindex = boxindex;
if(matrix[ajSeqcvtGetCodeK(cvt, seqcharptr[j][k])]
[ajSeqcvtGetCodeK(cvt, seqcharptr[myindex][k])] > 0
|| identical[ajSeqcvtGetCodeK(cvt, seqcharptr[j][k])] >=
fplural )
seqboxptr[j][k] |= BOXCOLOURED;
}
/* END OF BOXES */
if(ajSeqcvtGetCodeK(cvt, seqcharptr[j][k]))
res[0] = seqcharptr[j][k];
else
res[0] = '-';
if(colourbyconsensus)
{
part = (float) matrix[ajSeqcvtGetCodeK(cvt, seqcharptr[j][k])]
[ajSeqcvtGetCodeK(cvt, seqcharptr[highindex][k])];
if(iscons && seqcharptr[highindex][k] == seqcharptr[j][k])
seqcolptr[j][k] = cidentity;
else if(part > 0.0)
seqcolptr[j][k] = csimilarity;
else
seqcolptr[j][k] = cother;
}
else if(colourbyresidues)
seqcolptr[j][k] = colmat[ajSeqcvtGetCodeK(cvt,
seqcharptr[j][k])];
else if(iscons && colourbyshade)
{
part = (float) matrix[ajSeqcvtGetCodeK(cvt, seqcharptr[j][k])]
[ajSeqcvtGetCodeK(cvt, seqcharptr[highindex][k])];
if(part >= 1.5)
seqcolptr[j][k] = shadecolour[0];
else if(part >= 1.0)
seqcolptr[j][k] = shadecolour[1];
else if(part >= 0.5)
seqcolptr[j][k] = shadecolour[2];
else
seqcolptr[j][k] = shadecolour[3];
}
else if(colourbyshade)
seqcolptr[j][k] = shadecolour[3];
else
seqcolptr[j][k] = BLACK;
}
if(consensus)
{
if(iscons)
res[0] = seqcharptr[highindex][k];
else
res[0] = '-';
strcat(constr,res);
}
if(countforgap >= resbreak)
{
gapcount++;
countforgap=0;
}
}
startseq = 0;
endseq=seqperpage;
newILstart = newILend;
newILend = k;
while(startseq < numseq)
{
if(startseq)
ajGraphNewpage(graph, AJFALSE);
/*ajDebug("Final loop: startseq: %d numseq: %d endseq: %d\n",
startseq, numseq, endseq);*/
if(endseq>numseq)
endseq = numseq;
prettyplot_fillinboxes(numseq,ajSeqsetGetLen(seqset),
startseq,endseq,
newILstart,newILend,
numres,resbreak,
boxit,boxcol,consensus,
ystart,yincr,cvt);
startseq = endseq;
endseq += seqperpage;
}
ajGraphicsGetCharsize(&defheight,¤tscale);
if(boxit && boxcol)
oldfg = ajGraphicsSetFgcolour(oldfg);
ajGraphicsCloseWin();
ajGraphxyDel(&graph);
ajStrDel(&sidentity);
ajStrDel(&ssimilarity);
ajStrDel(&sother);
ajStrDel(&options);
ajStrDel(&altstr);
ajStrDel(&matcodes);
for(i=0;i<numseq;i++)
{
ajStrDel(&seqnames[i]);
AJFREE(seqcolptr[i]);
if(seqboxptr)
AJFREE(seqboxptr[i]);
}
AJFREE(seqcolptr);
AJFREE(seqboxptr);
AJFREE(seqnames);
AJFREE(score);
AJFREE(previous);
AJFREE(seqcount);
AJFREE(colmat);
AJFREE(shadecolour);
freeptr = (void *) seqcharptr;
AJFREE(freeptr);
AJFREE(identical);
AJFREE(matching);
AJFREE(colcheck);
ajSeqsetDel(&seqset);
ajMatrixDel(&cmpmatrix);
ajStrDel(&shade);
ajStrDel(&sboxcolval);
ajStrDel(&sidentity);
ajStrDel(&ssimilarity);
ajStrDel(&sother);
ajFloatDel(&pair);
ajTimeDel(&ajtime);
AJFREE(constr);
embExit();
return 0;
}
int main(int argc, char **argv)
{
/* ACD data item variables */
AjPSeqset dataset = NULL;
AjPFile bfile = NULL;
AjPFile plib = NULL;
AjPStr mod = NULL;
ajint nmotifs = 0;
AjBool text = ajFalse;
AjPStr prior = NULL;
float evt = 0.0;
ajint nsites = 0;
ajint minsites = 0;
ajint maxsites = 0;
float wnsites = 0.0;
ajint w = 0;
ajint minw = 0;
ajint maxw = 0;
AjBool nomatrim = ajFalse;
ajint wg = 0;
ajint ws = 0;
AjBool noendgaps = ajFalse;
AjBool revcomp = ajFalse;
AjBool pal = ajFalse;
AjBool nostatus = ajFalse;
ajint maxiter = 0;
float distance = 0.0;
float b = 0.0;
float spfuzz = 0.0;
AjPStr spmap = NULL;
AjPStr cons = NULL;
ajint maxsize = 0;
ajint p = 0;
ajint time = 0;
AjPStr sf = NULL;
ajint heapsize = 64;
AjBool xbranch = ajFalse;
AjBool wbranch = ajFalse;
ajint bfactor = 0;
AjPFile outtext = NULL;
/* Housekeeping variables */
AjPStr cmd = NULL;
AjPStr ssname = NULL;
AjPSeqout outseq = NULL;
AjPStr tmp = NULL;
char option;
/* ACD file processing */
embInitPV("ememetext",argc,argv,"MEME",VERSION);
dataset = ajAcdGetSeqset("dataset");
bfile = ajAcdGetInfile("bfile");
plib = ajAcdGetInfile("plibfile");
mod = ajAcdGetSelectSingle("mod");
nmotifs = ajAcdGetInt("nmotifs");
text = ajAcdGetBoolean("text");
prior = ajAcdGetSelectSingle("prior");
evt = ajAcdGetFloat("evt");
nsites = ajAcdGetInt("nsites");
minsites = ajAcdGetInt("minsites");
maxsites = ajAcdGetInt("maxsites");
wnsites = ajAcdGetFloat("wnsites");
w = ajAcdGetInt("w");
minw = ajAcdGetInt("minw");
maxw = ajAcdGetInt("maxw");
nomatrim = ajAcdGetBoolean("nomatrim");
wg = ajAcdGetInt("wg");
ws = ajAcdGetInt("ws");
noendgaps = ajAcdGetBoolean("noendgaps");
revcomp = ajAcdGetBoolean("revcomp");
pal = ajAcdGetBoolean("pal");
nostatus = ajAcdGetBoolean("nostatus");
maxiter = ajAcdGetInt("maxiter");
distance = ajAcdGetFloat("distance");
b = ajAcdGetFloat("b");
spfuzz = ajAcdGetFloat("spfuzz");
spmap = ajAcdGetSelectSingle("spmap");
cons = ajAcdGetString("cons");
maxsize = ajAcdGetInt("maxsize");
p = ajAcdGetInt("p");
time = ajAcdGetInt("time");
sf = ajAcdGetString("sf");
heapsize = ajAcdGetInt("heapsize");
xbranch = ajAcdGetBoolean("xbranch");
wbranch = ajAcdGetBoolean("wbranch");
bfactor = ajAcdGetInt("bfactor");
outtext = ajAcdGetOutfile("outtext");
outseq = ajAcdGetSeqoutset("outseq");
/* MAIN APPLICATION CODE */
/* 1. Housekeeping */
cmd = ajStrNew();
tmp = ajStrNew();
/* 2. Re-write dataset to a temporary file in a format (fasta) MEME
** can understand.
** Can't just pass the name of dataset to MEME as the name provided
** might be a USA which MEME would not understand.
*/
ssname = ajStrNewS(ajFileGetNameS(outseq->File));
ajSeqoutSetFormatC(outseq, "fasta");
ajSeqoutWriteSet(outseq, dataset);
ajSeqoutClose(outseq);
ajSeqoutDel(&outseq);
/* 3. Build ememe command line */
/* Command line is built in this order:
i. Application name.
ii. Original MEME options (in order they appear in ACD file)
iii.Original MEME options (that don't appear in ACD file)
iv. EMBASSY MEME new qualifiers and parameters.
*/
ajStrAssignS(&cmd, ajAcdGetpathC("meme"));
ajFmtPrintAppS(&cmd, " %S", ssname);
if(bfile)
ajFmtPrintAppS(&cmd, " -bfile %s ", ajFileGetNameC(bfile));
if(plib)
ajFmtPrintAppS(&cmd, " -plib %s ", ajFileGetNameC(plib));
option = ajStrGetCharFirst(mod);
if(option == 'o')
ajStrAppendC(&cmd, " -mod oops ");
else if(option == 'z')
ajStrAppendC(&cmd, " -mod zoops ");
else if(option == 'a')
ajStrAppendC(&cmd, " -mod anr ");
if(nmotifs != 1)
ajFmtPrintAppS(&cmd, " -nmotifs %d ", nmotifs);
if(text)
ajFmtPrintAppS(&cmd, " -text ");
ajFmtPrintAppS(&cmd, " -prior %S ", prior);
if(evt != -1)
ajFmtPrintAppS(&cmd, " -evt %f ", evt);
if(nsites != -1)
ajFmtPrintAppS(&cmd, " -nsites %d ", nsites);
else
{
if(minsites != -1)
ajFmtPrintAppS(&cmd, " -minsites %d ", minsites);
if(maxsites != -1)
ajFmtPrintAppS(&cmd, " -maxsites %d ", maxsites);
}
if(wnsites < 0.7999 || wnsites > .8001)
ajFmtPrintAppS(&cmd, " -wnsites %f ", wnsites);
if(w != -1)
ajFmtPrintAppS(&cmd, " -w %d ", w);
if(minw != 8)
ajFmtPrintAppS(&cmd, " -minw %d ", minw);
if(maxw != 50)
ajFmtPrintAppS(&cmd, " -maxw %d ", maxw);
if(nomatrim)
ajFmtPrintAppS(&cmd, " -nomatrim ");
if(wg != 11)
ajFmtPrintAppS(&cmd, " -wg %d ", wg);
if(ws != 1)
ajFmtPrintAppS(&cmd, " -ws %d ", ws);
if(noendgaps)
ajFmtPrintAppS(&cmd, " -noendgaps ");
if(revcomp)
ajFmtPrintAppS(&cmd, " -revcomp ");
if(pal && ajSeqsetIsNuc(dataset))
ajFmtPrintAppS(&cmd, " -pal ");
if(nostatus)
ajFmtPrintAppS(&cmd, " -nostatus ");
if(maxiter != 50)
ajFmtPrintAppS(&cmd, " -maxiter %d ", maxiter);
if(distance < 0.00099 || distance > 0.00101)
ajFmtPrintAppS(&cmd, " -distance %f ", distance);
if(b != -1)
ajFmtPrintAppS(&cmd, " -b %f ", b);
if(spfuzz != -1)
ajFmtPrintAppS(&cmd, " -spfuzz %f ", spfuzz);
if(!ajStrMatchC(spmap,"default"))
ajFmtPrintAppS(&cmd, " -spmap %S ", spmap);
if(MAJSTRGETLEN(cons))
ajFmtPrintAppS(&cmd, "-cons %S", cons);
if(maxsize != -1)
ajFmtPrintAppS(&cmd, " -maxsize %d ", maxsize);
if(p > 0)
ajFmtPrintAppS(&cmd, " -p %d ", p);
if(time > 0)
ajFmtPrintAppS(&cmd, " -time %d ", time);
if(MAJSTRGETLEN(sf))
ajFmtPrintAppS(&cmd, " -sf %S", sf);
if(heapsize != 64)
ajFmtPrintAppS(&cmd, " -heapsize %d ", heapsize);
if(xbranch)
ajFmtPrintAppS(&cmd, " -x_branch");
if(wbranch)
ajFmtPrintAppS(&cmd, " -w_branch");
if(bfactor != 3)
ajFmtPrintAppS(&cmd, " -bfactor %d ", bfactor);
if(ajSeqsetIsProt(dataset))
ajFmtPrintAppS(&cmd, "-protein ");
else
ajFmtPrintAppS(&cmd, "-dna ");
ajFmtPrintAppS(&cmd, " -text");
ajFmtPrintAppS(&cmd, " > %S ", ajFileGetNameS(outtext));
/* 4. Close files from ACD before calling meme */
ajFileClose(&bfile);
ajFileClose(&plib);
/* 5. Call meme */
/* ajFmtPrint("\n%S\n", cmd); */
system(ajStrGetPtr(cmd));
/* 6. Exit cleanly */
ajSeqsetDel(&dataset);
ajStrDel(&cons);
ajStrDel(&sf);
ajStrDel(&mod);
ajStrDel(&prior);
ajStrDel(&spmap);
ajStrDel(&cmd);
ajStrDel(&ssname);
ajStrDel(&tmp);
ajFileClose(&bfile);
ajFileClose(&plib);
ajFileClose(&outtext);
ajSeqoutDel(&outseq);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPStr cl = NULL;
AjPStr stmp = NULL;
AjPStr squal = NULL;
/* AjBool bqual = ajFalse; */
AjPTable preftab = NULL;
embInitPV("emira", argc, argv, "MIRA",VERSION);
cl = ajStrNewS(ajAcdGetpathC("mira"));
stmp = ajStrNew();
preftab = emira_makepreftab();
if(ajAcdIsUserdefinedC("genome"))
{
squal = ajAcdGetListSingle("genome");
ajFmtPrintAppS(&cl," -genome%S",squal);
ajStrDel(&squal);
}
if(ajAcdIsUserdefinedC("mapping"))
{
squal = ajAcdGetListSingle("mapping");
ajFmtPrintAppS(&cl," -mapping%S",squal);
ajStrDel(&squal);
}
if(ajAcdIsUserdefinedC("clipping"))
{
squal = ajAcdGetListSingle("clipping");
ajFmtPrintAppS(&cl," -clipping%S",squal);
ajStrDel(&squal);
}
if(ajAcdIsUserdefinedC("setparam"))
{
squal = ajAcdGetListSingle("setparam");
if(!ajStrMatchC(squal,"unspecified"))
ajFmtPrintAppS(&cl," -%S",squal);
ajStrDel(&squal);
}
emira_dostrings(&cl, preftab);
emira_doinfiles(&cl, preftab);
emira_dodirectories(&cl, preftab);
emira_dobools(&cl, preftab);
emira_dointegers(&cl, preftab);
emira_dolistsingles(&cl, preftab);
ajDebug("Constructed command line: %S\n",cl);
#if 0
ajFmtPrint("%S\n",cl);
#endif
#if 1
system(ajStrGetPtr(cl));
#endif
ajStrDel(&stmp);
ajStrDel(&cl);
ajTablestrFree(&preftab);
embExit();
return 0;
}
int main(int argc, char **argv)
{
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)
{
/* ACD data item variables */
AjPFile oldhmmfile = NULL;
AjPStr format = NULL;
AjPFile newhmmfile = NULL;
/* Housekeeping variables */
AjPStr cmd = NULL;
char option;
/* ACD file processing */
embInitPV("ehmmconvert",argc,argv,"HMMERNEW",VERSION);
oldhmmfile = ajAcdGetInfile("oldhmmfile");
format = ajAcdGetListSingle("format");
newhmmfile = ajAcdGetOutfile("newhmmfile");
/* MAIN APPLICATION CODE */
cmd = ajStrNew();
/* 1. Build hmmconvert command line */
/* Command line is built in this order:
i. Application name.
ii. HMMER 'options' (in order they appear in ACD file)
iii.HMMER 'options' (that don't appear in ACD file)
iv. HMMER & new parameters.
*/
ajStrAssignS(&cmd, ajAcdGetpathC("hmmconvert"));
/* ACD option only allows one selection */
option = ajStrGetCharFirst(format);
if(option == 'A')
ajStrAppendC(&cmd, " -a ");
else if(option == 'B')
ajStrAppendC(&cmd, " -b ");
else if(option == 'G')
ajStrAppendC(&cmd, " -p ");
else if(option == 'X')
ajStrAppendC(&cmd, " -P ");
/* -A (append) always set but file will be wiped by EMBOSS first unless
append: "Y" is set for "newhmmfile" in the ACD file. */
/* hmmer cannot append to empty file, so only set the -A (append) option
if file was opened for appending to (and therefore was not wiped by
EMBOSS) and is not zero size. */
if(ajFileIsAppend(newhmmfile) && (ajFilenameGetSize(ajFileGetNameS(newhmmfile))!=-1))
ajStrAppendC(&cmd, " -A ");
ajStrAppendC(&cmd, " -F ");
ajFmtPrintAppS(&cmd, " %s %s", ajFileGetNameC(oldhmmfile), ajFileGetNameC(newhmmfile));
/* 2. Close ACD files. */
ajFileClose(&oldhmmfile);
ajFileClose(&newhmmfile);
/* 3. Call hmmconvert */
ajFmtPrint("\n%S\n\n", cmd);
ajSysExecS(cmd);
/* 4. Exit cleanly */
ajStrDel(&cmd);
ajStrDel(&format);
embExit();
return 0;
}
static AjPStr assemoutMakeCigar(const char* contig, const char* readseq)
{
AjPStr cigar = NULL;
ajint count =0;
char mode = '\0';
char c;
char r;
c = contig[0];
r = readseq[0];
cigar = ajStrNewC("");
for(;c!=0; c=*++contig, r=*++readseq)
{
if(c=='*' && r=='*')
continue;
else if(c!='*' && r!='*')
{
/* alignment match/mismatch */
if (mode!='M')
{
if(count)
ajFmtPrintAppS(&cigar, "%d%c", count, mode);
mode = 'M';
count = 1;
}
else
count++;
}
else if(c=='*')
{
if (mode!='I')
{
if(count)
ajFmtPrintAppS(&cigar, "%d%c", count, mode);
mode = 'I';
count = 1;
}
else
count++;
}
else if(r=='*')
{
if (mode!='D')
{
if(count)
ajFmtPrintAppS(&cigar, "%d%c", count, mode);
mode = 'D';
count = 1;
}
else
count++;
}
else
ajErr("something wrong!!!");
}
if(count)
ajFmtPrintAppS(&cigar, "%d%c", count, mode);
return cigar;
}
int main(int argc, char **argv)
{
/* ACD data item variables */
AjPFile hmmfile = NULL;
AjPSeqset seqfile = NULL;
AjPFile mapali = NULL;
AjPFile withali = NULL;
AjPAlign o = NULL;
AjBool m = ajFalse;
AjBool q = ajFalse;
/* Housekeeping variables */
AjPStr cmd = NULL;
AjPStr fmt = NULL;
AjBool fmtok = ajFalse;
AjPStr rnd = NULL;
AjPSeqout rndo = NULL;
/* ACD file processing */
embInitPV("ehmmalign",argc,argv,"HMMERNEW",VERSION);
hmmfile = ajAcdGetInfile("hmmfile");
seqfile = ajAcdGetSeqset("seqfile");
mapali = ajAcdGetInfile("mapali");
withali = ajAcdGetInfile("withali");
o = ajAcdGetAlign("o");
m = ajAcdGetBoolean("m");
q = ajAcdGetBoolean("q");
/* MAIN APPLICATION CODE */
/* 1. Housekeeping */
cmd = ajStrNew();
fmt = 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");
ajSeqoutWriteSet(rndo, seqfile);
ajSeqoutClose(rndo);
ajSeqoutDel(&rndo);
/* 3. Build hmmalign 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.
*/
ajFmtPrintS(&cmd, "%S ", ajAcdGetpathC("hmmalign"));
if(mapali)
ajFmtPrintAppS(&cmd, " --mapali %s ", ajFileGetNameC(mapali));
if(withali)
ajFmtPrintAppS(&cmd, " --withali %s ", ajFileGetNameC(withali));
if(m)
ajStrAppendC(&cmd, " -m ");
if(q)
ajStrAppendC(&cmd, " -q ");
/* Ensure output alignment is in user-specified format. */
fmtok=ajTrue;
ajStrAssignS(&fmt, ajAlignGetFormat(o));
/* fasta and a2m are identical formats. */
if(ajStrMatchC(fmt, "fasta"))
ajStrAssignC(&fmt, "A2M");
else if(ajStrMatchC(fmt, "a2m"))
ajStrAssignC(&fmt, "A2M");
else if(ajStrMatchC(fmt, "msf"))
ajStrAssignC(&fmt, "MSF");
else if(ajStrMatchC(fmt, "phylip"))
ajStrAssignC(&fmt, "PHYLIP");
/* hmmer also supports stockholm, SELEX & Clustal output, EMBOSS does not.
EMBOSS supports unknown/multiple/simple and srs output, hmmer does not. */
else
fmtok = ajFalse;
if(!fmtok)
{
/* This could be replaced with code to reformat the file. */
ajWarn("Specified output alignment format ('o' ACD option) is "
"not understood by HMMER. Using stockholm format instead.");
ajStrAssignC(&fmt, "Stockholm");
}
/* rnd is the name of the rewritten seqfile. MUST specify FASTA format explicitly. */
ajFmtPrintAppS(&cmd, " --informat FASTA --outformat %S -o %s %s %S",
fmt,
ajAlignGetFilename(o),
ajFileGetNameC(hmmfile),
rnd);
/* 4. Close ACD files */
ajFileClose(&hmmfile);
ajSeqsetDel(&seqfile);
ajFileClose(&mapali);
ajFileClose(&withali);
ajAlignClose(o);
ajAlignDel(&o);
/* 5. Call hmmalign */
ajFmtPrint("\n%S\n\n", cmd);
ajSysExecS(cmd);
/* 6. Exit cleanly */
ajSysFileUnlinkS(rnd);
ajStrDel(&cmd);
ajStrDel(&fmt);
ajStrDel(&rnd);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPAlign align;
AjPSeqall seqall;
AjPSeq a;
AjPSeq b;
AjPStr alga;
AjPStr algb;
AjPStr ss;
ajuint lena;
ajuint lenb;
const char *p;
const char *q;
ajint start1 = 0;
ajint start2 = 0;
float *path;
ajint *compass;
float* ix;
float* iy;
float* m;
AjPMatrixf matrix;
AjPSeqCvt cvt = 0;
float **sub;
float gapopen;
float gapextend;
float endgapopen;
float endgapextend;
ajulong maxarr = 1000; /* arbitrary. realloc'd if needed */
ajulong len;
float score;
AjBool dobrief = ajTrue;
AjBool endweight = ajFalse; /* whether end gap penalties should be applied */
float id = 0.;
float sim = 0.;
float idx = 0.;
float simx = 0.;
AjPStr tmpstr = NULL;
size_t stlen;
embInit("needle", argc, argv);
matrix = ajAcdGetMatrixf("datafile");
a = ajAcdGetSeq("asequence");
ajSeqTrim(a);
seqall = ajAcdGetSeqall("bsequence");
gapopen = ajAcdGetFloat("gapopen");
gapextend = ajAcdGetFloat("gapextend");
endgapopen = ajAcdGetFloat("endopen");
endgapextend = ajAcdGetFloat("endextend");
dobrief = ajAcdGetBoolean("brief");
endweight = ajAcdGetBoolean("endweight");
align = ajAcdGetAlign("outfile");
gapopen = ajRoundFloat(gapopen, 8);
gapextend = ajRoundFloat(gapextend, 8);
AJCNEW(path, maxarr);
AJCNEW(compass, maxarr);
AJCNEW(m, maxarr);
AJCNEW(ix, maxarr);
AJCNEW(iy, maxarr);
alga = ajStrNew();
algb = ajStrNew();
ss = ajStrNew();
sub = ajMatrixfGetMatrix(matrix);
cvt = ajMatrixfGetCvt(matrix);
lena = ajSeqGetLen(a);
while(ajSeqallNext(seqall,&b))
{
ajSeqTrim(b);
lenb = ajSeqGetLen(b);
if(lenb > (ULONG_MAX/(ajulong)(lena+1)))
ajFatal("Sequences too big. Try 'stretcher' or 'supermatcher'");
len = lena*lenb;
if(len>maxarr)
{
stlen = (size_t) len;
AJCRESIZETRY(path,stlen);
if(!path)
ajDie("Sequences too big. Try 'stretcher'");
AJCRESIZETRY(compass,stlen);
if(!compass)
ajDie("Sequences too big. Try 'stretcher'");
AJCRESIZETRY(m,stlen);
if(!m)
ajDie("Sequences too big. Try 'stretcher'");
AJCRESIZETRY(ix,stlen);
if(!ix)
ajDie("Sequences too big. Try 'stretcher'");
AJCRESIZETRY(iy,stlen);
if(!iy)
ajDie("Sequences too big. Try 'stretcher'");
maxarr=len;
}
p = ajSeqGetSeqC(a);
q = ajSeqGetSeqC(b);
ajStrAssignC(&alga,"");
ajStrAssignC(&algb,"");
score = embAlignPathCalcWithEndGapPenalties(p, q, lena, lenb,
gapopen, gapextend, endgapopen, endgapextend,
&start1, &start2, path, sub, cvt,
m, ix, iy, compass, ajTrue, endweight);
embAlignWalkNWMatrixUsingCompass(p, q, &alga, &algb,
lena, lenb, &start1, &start2,
compass);
embAlignReportGlobal(align, a, b, alga, algb,
start1, start2,
gapopen, gapextend,
score, matrix,
ajSeqGetOffset(a), ajSeqGetOffset(b));
if(!dobrief)
{
embAlignCalcSimilarity(alga,algb,sub,cvt,lena,lenb,&id,&sim,&idx,
&simx);
ajFmtPrintS(&tmpstr,"Longest_Identity = %5.2f%%\n",
id);
ajFmtPrintAppS(&tmpstr,"Longest_Similarity = %5.2f%%\n",
sim);
ajFmtPrintAppS(&tmpstr,"Shortest_Identity = %5.2f%%\n",
idx);
ajFmtPrintAppS(&tmpstr,"Shortest_Similarity = %5.2f%%",
simx);
ajAlignSetSubHeaderApp(align, tmpstr);
}
ajAlignWrite(align);
ajAlignReset(align);
}
ajAlignClose(align);
ajAlignDel(&align);
ajSeqallDel(&seqall);
ajSeqDel(&a);
ajSeqDel(&b);
AJFREE(compass);
AJFREE(path);
AJFREE(ix);
AJFREE(iy);
AJFREE(m);
ajStrDel(&alga);
ajStrDel(&algb);
ajStrDel(&ss);
ajStrDel(&tmpstr);
embExit();
return 0;
}
static AjBool assemoutWriteSamAlignment(AjPFile outf, const AjPAssemRead r,
AjPAssemContig const * contigs,
ajint ncontigs)
{
AjPAssemTag t = NULL;
AjIList l = NULL;
AjPStr qualstr = NULL;
AjPStr tmp = NULL;
ajint POS = 0;
AjPStr CIGAR = NULL;
const char* RNEXT = NULL;
AjPStr SEQ = NULL;
AjPStr QUAL = NULL;
AjPStr SEQunpadded = NULL;
AjPStr QUALunpadded = NULL;
AjPStr consensus = NULL;
AjBool rc= ajFalse;
AjBool ret = ajTrue;
const char* refseq = NULL;
const AjPAssemContig contig = NULL;
ajuint k = 0;
if(r->Reference>=ncontigs)
ajDie("assemoutWriteSamAlignment: reference sequence number"
" '%d' is larger than or equal to known number of reference"
" sequences '%d'. Problem while processing read '%S'.",
r->Reference,
ncontigs,
r->Name);
contig = (r->Reference==-1 ? NULL : contigs[r->Reference]);
ajStrAssignRef(&SEQ, r->Seq);
consensus = contig==NULL? NULL : contig->Consensus;
if (r->Rnext==-1)
RNEXT= "*";
else if(r->Rnext==r->Reference)
RNEXT = "=";
else
RNEXT = ajStrGetPtr(contigs[r->Rnext]->Name);
if (r->Flag & BAM_FREVERSE)
{
rc = ajTrue;
qualstr = ajStrNewS(r->SeqQ);
if(!r->Reversed)
{
ajStrReverse(&qualstr);
ajSeqstrReverse(&SEQ);
}
QUAL = qualstr;
POS = r->y1;
ajStrAssignSubS(&tmp, SEQ,
ajStrGetLen(r->Seq) - r->y2,
ajStrGetLen(r->Seq) - r->x2
);
}
else
{
rc= ajFalse;
POS = r->x1;
QUAL = r->SeqQ;
ajStrAssignSubS(&tmp, SEQ,
r->x2-1,
r->y2-1
);
}
if(r->Cigar==NULL && consensus)
{
refseq = ajStrGetPtr(consensus) + (rc ? r->y1-1 : r->x1-1);
CIGAR = assemoutMakeCigar(refseq, ajStrGetPtr(tmp));
SEQunpadded = ajStrNewRes(ajStrGetLen(SEQ));
QUALunpadded = ajStrNewRes(ajStrGetLen(SEQ));
for(k=0; k< ajStrGetLen(SEQ); k++)
{
if (ajStrGetCharPos(SEQ, k) == '*')
continue;
ajStrAppendK(&SEQunpadded, ajStrGetCharPos(SEQ, k));
ajStrAppendK(&QUALunpadded, ajStrGetCharPos(QUAL, k));
}
ajDebug("cigar: %S\n", CIGAR);
ajStrAssignS(&tmp, CIGAR);
if(rc)
{
if(r->y2 < (ajint)ajStrGetLen(SEQ))
ajFmtPrintS(&CIGAR, "%dS%S",
ajStrGetLen(SEQ) - r->y2, tmp);
if(r->x2 > 1)
ajFmtPrintAppS(&CIGAR, "%dS", r->x2 - 1);
}
else
{
if(r->x2 > 1)
ajFmtPrintS(&CIGAR, "%dS%S", r->x2 - 1, tmp);
if(r->y2 < (ajint)ajStrGetLen(SEQ))
ajFmtPrintAppS(&CIGAR, "%dS",
ajStrGetLen(SEQ) - r->y2);
}
ajStrDel(&tmp);
}
else if(r->Cigar==NULL)
{
ajErr("both CIGAR string and consensus sequence not available");
ret = ajFalse;
ajStrAssignK(&CIGAR, '*');
}
else if(!ajStrGetLen(r->Cigar))
ajStrAssignK(&CIGAR, '*');
else if(ajStrGetLen(r->Cigar))
{
if(!ajStrGetLen(SEQ))
ajStrAssignK(&SEQ, '*');
if(!ajStrGetLen(QUAL))
ajStrAssignK(&QUAL, '*');
}
ajStrDel(&tmp);
ajFmtPrintF(outf, "%S\t%d\t%s\t%d\t%d\t%S\t%s\t%Ld\t%d\t%S\t%S",
r->Name,
r->Flag,
(contig==NULL ? "*" : ajStrGetPtr(contig->Name)),
POS,
r->MapQ,
(CIGAR ? CIGAR : r->Cigar),
RNEXT,
r->Pnext,
r->Tlen,
(r->Cigar ? SEQ : SEQunpadded),
(r->Cigar ? QUAL : QUALunpadded));
l = ajListIterNewread(r->Tags);
while (!ajListIterDone(l))
{
t = ajListIterGet(l);
/* TODO: array type, 'B' */
/* In SAM, all single integer types are mapped to int32_t [SAM spec] */
ajFmtPrintF(outf, "\t%S:%c:",
t->Name,
(t->type == 'c' || t->type == 'C' ||
t->type == 's' || t->type == 'S'
|| t->type == 'I') ? 'i' : t->type
);
if(t->x1 || t->y1)
ajFmtPrintF(outf, " %u %u", t->x1, t->y1);
if(t->Comment && ajStrGetLen(t->Comment)>0)
ajFmtPrintF(outf, "%S", t->Comment);
}
ajListIterDel(&l);
ajFmtPrintF(outf, "\n");
if(qualstr)
ajStrDel(&qualstr);
ajStrDel(&SEQ);
ajStrDel(&CIGAR);
ajStrDel(&SEQunpadded);
ajStrDel(&QUALunpadded);
return ret;
}
int main(int argc, char **argv)
{
AjPFile inf = NULL;
AjPFile inf2 = NULL;
AjPFeattable tab = NULL;
AjPReport report = NULL;
AjPSeq sequence = NULL;
AjPStr redatanew = NULL;
AjPStr str = NULL;
AjPStr regexp = NULL;
AjPStr temp = NULL;
AjPStr text = NULL;
AjPStr docdata = NULL;
AjPStr data = NULL;
AjPStr accession = NULL;
AjPStr name = NULL;
EmbPPatMatch match = NULL;
AjPStr savereg = NULL;
AjPStr fthit = NULL;
AjBool full;
AjBool prune;
ajint i;
ajint number;
ajint start;
ajint end;
ajint length;
ajint zstart;
ajint zend;
const char *p;
ajint seqlength;
AjPStr tmpstr = NULL;
AjPStr tailstr = NULL;
AjPFeature gf;
embInit("patmatmotifs", argc, argv);
ajStrAssignC(&fthit, "SO:0001067");
savereg = ajStrNew();
str = ajStrNew();
regexp = ajStrNew();
temp = ajStrNew();
data = ajStrNew();
accession = ajStrNew();
text = ajStrNew();
name = ajStrNew();
sequence = ajAcdGetSeq("sequence");
report = ajAcdGetReport("outfile");
full = ajAcdGetBoolean("full");
prune = ajAcdGetBoolean("prune");
ajSeqFmtUpper(sequence); /* prosite regexs are all upper case */
tab = ajFeattableNewSeq(sequence);
ajStrAssignC(&tailstr, "");
seqlength = ajStrGetLen(str);
str = ajSeqGetSeqCopyS(sequence);
redatanew = ajStrNewC("PROSITE/prosite.lines");
docdata = ajStrNewC("PROSITE/");
inf = ajDatafileNewInNameS(redatanew);
if(!inf)
ajFatal("Either EMBOSS_DATA undefined or PROSEXTRACT needs running");
ajFmtPrintAppS(&tmpstr, "Full: %B\n", full);
ajFmtPrintAppS(&tmpstr, "Prune: %B\n", prune);
ajFmtPrintAppS(&tmpstr, "Data_file: %F\n", inf);
ajReportSetHeaderS(report, tmpstr);
while(ajReadlineTrim(inf, ®exp))
{
p=ajStrGetPtr(regexp);
if(*p && *p!=' ' && *p!='^')
{
p=ajSysFuncStrtok(p," ");
ajStrAssignC(&name,p);
if(prune)
if(ajStrMatchCaseC(name,"myristyl") ||
ajStrMatchCaseC(name,"asn_glycosylation") ||
ajStrMatchCaseC(name,"camp_phospho_site") ||
ajStrMatchCaseC(name,"pkc_phospho_site") ||
ajStrMatchCaseC(name,"ck2_phospho_site") ||
ajStrMatchCaseC(name,"tyr_phospho_site"))
{
for(i=0;i<4;++i)
ajReadlineTrim(inf, ®exp);
continue;
}
p=ajSysFuncStrtok(NULL," ");
ajStrAssignC(&accession,p);
}
if(ajStrPrefixC(regexp, "^"))
{
p = ajStrGetPtr(regexp);
ajStrAssignC(&temp,p+1);
ajStrAssignC(&savereg,p+1);
match = embPatMatchFind(temp, str, ajFalse, ajFalse);
number = embPatMatchGetNumber(match);
for(i=0; i<number; i++)
{
seqlength = ajStrGetLen(str);
start = 1+embPatMatchGetStart(match, i);
end = 1+embPatMatchGetEnd(match, i);
length = embPatMatchGetLen(match, i);
gf = ajFeatNew(tab, NULL, fthit, start, end,
(float) length, ' ', 0);
ajFmtPrintS(&tmpstr, "*motif %S", name);
ajFeatTagAddSS(gf, NULL, tmpstr);
if(start-5<0)
zstart = 0;
else
zstart = start-5;
if(end+5> seqlength)
zend = end;
else
zend = end+5;
ajStrAssignSubS(&temp, str, zstart, zend);
}
if(full && number)
{
ajStrAssignC(&redatanew,ajStrGetPtr(docdata));
ajStrAppendC(&redatanew,ajStrGetPtr(accession));
inf2 = ajDatafileNewInNameS(redatanew);
if(!inf2)
continue;
/*
** Insert Prosite documentation from files made by
** prosextract.c
*/
ajFmtPrintAppS(&tailstr, "Motif: %S\n", name);
ajFmtPrintAppS(&tailstr, "Count: %d\n\n", number);
while(ajReadlineTrim(inf2, &text))
ajFmtPrintAppS(&tailstr, "%S\n", text);
ajFmtPrintAppS(&tailstr, "\n***************\n\n");
ajFileClose(&inf2);
}
embPatMatchDel(&match);
}
}
ajReportSetTailS(report,tailstr);
ajReportWrite(report, tab, sequence);
ajReportDel(&report);
ajFeattableDel(&tab);
ajStrDel(&temp);
ajStrDel(®exp);
ajStrDel(&savereg);
ajStrDel(&str);
ajStrDel(&data);
ajStrDel(&docdata);
ajStrDel(&text);
ajStrDel(&redatanew);
ajStrDel(&accession);
ajSeqDel(&sequence);
ajStrDel(&tailstr);
ajStrDel(&fthit);
ajStrDel(&name);
ajStrDel(&tmpstr);
ajFeattableDel(&tab);
ajFileClose(&inf);
embExit();
return 0;
}
static AjBool assemoutWriteNextBam(AjPOutfile outfile, const AjPAssem assem)
{
AjPFile outf = ajOutfileGetFile(outfile);
AjPSeqBamHeader header = NULL;
AjPAssemContig c = NULL;
AjPSeqBam bam;
AjPAssemRead r = NULL;
AjPAssemContig* contigs = NULL;
AjPAssemTag t = NULL;
AjIList j = NULL;
AjPSeqBamBgzf gzfile = NULL;
AjPStr headertext=NULL;
const AjPStr rgheadertext=NULL;
AjBool ret = ajTrue;
ajint i=0;
ajulong ncontigs=0UL;
if(!outf) return ajFalse;
if(!assem) return ajFalse;
if(!assem->Hasdata)
{
if(ajListGetLength(assem->ContigsOrder))
ncontigs = ajListToarray(assem->ContigsOrder, (void***)&contigs);
else
ncontigs = ajTableToarrayValues(assem->Contigs, (void***)&contigs);
ajFmtPrintS(&headertext, "@HD\tVN:1.3\tSO:%s\n",
ajAssemGetSortorderC(assem));
header = ajSeqBamHeaderNewN((ajuint) ncontigs);
gzfile = ajSeqBamBgzfNew(ajFileGetFileptr(outf), "w");
outfile->OutData = gzfile;
while (contigs[i]) /* contigs */
{
c = contigs[i];
if(ajStrMatchC(c->Name, "*"))
{
i++;
continue;
}
header->target_name[i] = strdup(ajStrGetPtr(c->Name));
header->target_len[i++] = c->Length;
ajFmtPrintAppS(&headertext, "@SQ\tSN:%S\tLN:%d",
c->Name, c->Length);
if(c->URI)
ajFmtPrintAppS(&headertext, "\tUR:%S", c->URI);
if(c->MD5)
ajFmtPrintAppS(&headertext, "\tM5:%S", c->MD5);
if(c->Species)
ajFmtPrintAppS(&headertext, "\tSP:%S", c->Species);
ajFmtPrintAppS(&headertext, "\n");
j = ajListIterNewread(c->Tags);
while (!ajListIterDone(j))
{
t = ajListIterGet(j);
ajFmtPrintAppS(&headertext,
"@CO\t%S %u %u %S\n", t->Name, t->x1, t->y1,
t->Comment);
}
ajListIterDel(&j);
}
rgheadertext = assemSAMGetReadgroupHeaderlines(assem);
if(rgheadertext)
ajStrAppendS(&headertext, rgheadertext);
ajSeqBamHeaderSetTextC(header, ajStrGetPtr(headertext));
ajSeqBamHeaderWrite(gzfile, header);
ajSeqBamHeaderDel(&header);
ajStrDel(&headertext);
AJFREE(contigs);
if(!assem->BamHeader)
return ajTrue;
}
/* data */
gzfile = outfile->OutData;
AJNEW0(bam);
bam->m_data=10;
AJCNEW0(bam->data, bam->m_data);
j = ajListIterNewread(assem->Reads);
while (!ajListIterDone(j)) /* reads */
{
r = ajListIterGet(j);
assemoutWriteBamAlignment(gzfile, r, bam);
}
ajListIterDel(&j);
AJFREE(bam->data);
AJFREE(bam);
/* ajSeqBamBgzfClose(gzfile);*/
return ret;
}
int main(int argc, char **argv)
{
/* 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 a;
AjPStr substr;
AjPStr rname;
ajint be;
ajint en;
ajint len;
AjBool unfavoured;
AjBool overlap;
AjBool allpartials;
AjPStr menu;
AjPStr rag;
ajint n = 0;
ajint r = 0;
AjPFile outf = NULL;
AjPReport report = NULL;
AjPFeattable TabRpt = NULL;
AjPStr tmpStr = NULL;
AjPList l;
AjPList pa;
AjPFile mfptr = NULL;
AjBool nterm = ajFalse;
AjBool cterm = ajFalse;
AjBool dorag = ajFalse;
ajint ncomp;
ajint npart;
EmbPPropMolwt *mwdata = NULL;
AjBool mono;
embInit("digest", argc, argv);
seqall = ajAcdGetSeqall("seqall");
menu = ajAcdGetListSingle("menu");
dorag = ajAcdGetBoolean("ragging");
rag = ajAcdGetListSingle("termini");
unfavoured = ajAcdGetBoolean("unfavoured");
overlap = ajAcdGetBoolean("overlap");
allpartials = ajAcdGetBoolean("allpartials");
report = ajAcdGetReport("outfile");
mfptr = ajAcdGetDatafile("mwdata");
mono = ajAcdGetBoolean("mono");
/* obsolete. Can be uncommented in acd file and here to reuse */
/* outf = ajAcdGetOutfile("originalfile"); */
ajStrToInt(menu, &n);
--n;
ajStrToInt(rag, &r);
if(r==2 || r==4)
nterm = ajTrue;
if(r==3 || r==4)
cterm = ajTrue;
mwdata = embPropEmolwtRead(mfptr);
while(ajSeqallNext(seqall, &a))
{
substr = ajStrNew();
be = ajSeqGetBegin(a);
en = ajSeqGetEnd(a);
ajStrAssignSubC(&substr,ajSeqGetSeqC(a),be-1,en-1);
ajStrFmtUpper(&substr);
len = en-be+1;
l = ajListNew();
pa = ajListNew();
rname = ajStrNew();
TabRpt = ajFeattableNewSeq(a);
embPropCalcFragments(ajStrGetPtr(substr),n,&l,&pa,
unfavoured,overlap,
allpartials,&ncomp,&npart,&rname,
nterm, cterm, dorag, mwdata, mono);
if(outf)
ajFmtPrintF(outf,"DIGEST of %s from %d to %d Molwt=%10.3f\n\n",
ajSeqGetNameC(a),be,en,
embPropCalcMolwt(ajSeqGetSeqC(a),0,len-1,mwdata,mono));
if(!ncomp)
{
if(outf)
ajFmtPrintF(outf,
"Is not proteolytically digested using %s\n",
ajStrGetPtr(rname));
}
else
{
if(outf)
{
ajFmtPrintF(outf,"Complete digestion with %s "
"yields %d fragments:\n",
ajStrGetPtr(rname),ncomp);
digest_print_hits(l,outf,be,ajStrGetPtr(substr));
}
ajFmtPrintS(&tmpStr,
"Complete digestion with %S yields %d fragments",
rname,ncomp);
ajReportSetHeaderS(report, tmpStr);
digest_report_hits(TabRpt,l,be, ajStrGetPtr(substr));
ajReportWrite(report, TabRpt, a);
ajFeattableClear(TabRpt);
}
if(overlap && !allpartials && npart)
{
if(outf)
{
ajFmtPrintF(outf,
"\n\nPartial digest with %s yields %d extras.\n",
ajStrGetPtr(rname),npart);
ajFmtPrintF(outf,"Only overlapping partials shown:\n");
digest_print_hits(pa,outf,be,ajStrGetPtr(substr));
}
ajFmtPrintS(&tmpStr,
"\n\nPartial digest with %S yields %d extras.\n",
rname,npart);
ajFmtPrintAppS(&tmpStr,"Only overlapping partials shown:\n");
ajReportSetHeaderS(report, tmpStr);
digest_report_hits(TabRpt, pa,be,ajStrGetPtr(substr));
ajReportWrite(report, TabRpt, a);
ajFeattableClear(TabRpt);
}
if(allpartials && npart)
{
if(outf)
{
ajFmtPrintF(outf,
"\n\nPartial digest with %s yields %d extras.\n",
ajStrGetPtr(rname),npart);
ajFmtPrintF(outf,"All partials shown:\n");
digest_print_hits(pa,outf,be,ajStrGetPtr(substr));
}
ajFmtPrintS(&tmpStr,
"\n\nPartial digest with %S yields %d extras.\n",
rname,npart);
ajFmtPrintAppS(&tmpStr,"All partials shown:\n");
ajReportSetHeaderS(report, tmpStr);
digest_report_hits(TabRpt, pa,be, ajStrGetPtr(substr));
ajReportWrite(report, TabRpt, a);
ajFeattableClear(TabRpt);
}
}
embPropMolwtDel(&mwdata);
ajReportDel(&report);
ajFeattableDel(&TabRpt);
ajSeqDel(&a);
ajSeqallDel(&seqall);
ajStrDel(&rname);
ajStrDel(&substr);
ajListFree(&pa);
ajListFree(&l);
ajStrDel(&menu);
ajStrDel(&rag);
if(outf)
ajFileClose(&outf);
ajFileClose(&mfptr);
ajStrDel(&tmpStr);
embExit();
return 0;
}