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)
{
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;
}
int main(int argc, char **argv)
{
AjPAlign align;
AjPSeq a;
AjPSeq b;
AjPSeqout seqout;
AjPStr m;
AjPStr n;
AjPStr merged = NULL;
ajuint lena;
ajuint lenb;
const char *p;
const char *q;
ajint start1 = 0;
ajint start2 = 0;
float *path;
ajint *compass;
AjPMatrixf matrix;
AjPSeqCvt cvt = 0;
float **sub;
float gapopen;
float gapextend;
ajulong maxarr = 1000;
ajulong len; /* arbitrary. realloc'd if needed */
size_t stlen;
float score;
ajint begina;
ajint beginb;
embInit("merger", argc, argv);
a = ajAcdGetSeq("asequence");
b = ajAcdGetSeq("bsequence");
seqout = ajAcdGetSeqout("outseq");
matrix = ajAcdGetMatrixf("datafile");
gapopen = ajAcdGetFloat("gapopen");
gapextend = ajAcdGetFloat("gapextend");
align = ajAcdGetAlign("outfile");
gapopen = ajRoundFloat(gapopen, 8);
gapextend = ajRoundFloat(gapextend, 8);
AJCNEW(path, maxarr);
AJCNEW(compass, maxarr);
/*
** make the two sequences lowercase so we can show which one we are
** using in the merge by uppercasing it
*/
ajSeqFmtLower(a);
ajSeqFmtLower(b);
m = ajStrNew();
n = ajStrNew();
sub = ajMatrixfGetMatrix(matrix);
cvt = ajMatrixfGetCvt(matrix);
begina = ajSeqGetBegin(a);
beginb = ajSeqGetBegin(b);
lena = ajSeqGetLen(a);
lenb = ajSeqGetLen(b);
if(lenb > (ULONG_MAX/(ajulong)(lena+1)))
ajFatal("Sequences too big. Try 'supermatcher'");
len = lena*lenb;
if(len>maxarr)
{
ajDebug("merger: resize path, len to %d (%d * $d)\n",
len, lena, lenb);
stlen = (size_t) len;
AJCRESIZE(path,stlen);
AJCRESIZE(compass,stlen);
maxarr=len;
}
p = ajSeqGetSeqC(a);
q = ajSeqGetSeqC(b);
ajStrAssignC(&m,"");
ajStrAssignC(&n,"");
score = embAlignPathCalc(p,q,lena,lenb,gapopen,gapextend,path,sub,cvt,
compass, ajFalse);
/*score = embAlignScoreNWMatrix(path,compass,gapopen,gapextend,
a,b,lena,lenb,sub,cvt,
&start1,&start2);*/
embAlignWalkNWMatrix(path,a,b,&m,&n,lena,lenb, &start1,&start2,gapopen,
gapextend,compass);
/*
** now construct the merged sequence, uppercase the bits of the two
** input sequences which are used in the merger
*/
merger_Merge(align, &merged,p,q,m,n,start1,start2,
ajSeqGetNameC(a),ajSeqGetNameC(b));
embAlignReportGlobal(align, a, b, m, n,
start1, start2, gapopen, gapextend,
score, matrix, begina, beginb);
ajAlignWrite(align);
ajAlignReset(align);
/* write the merged sequence */
ajSeqAssignSeqS(a, merged);
ajSeqoutWriteSeq(seqout, a);
ajSeqoutClose(seqout);
ajSeqoutDel(&seqout);
ajSeqDel(&a);
ajSeqDel(&b);
ajAlignClose(align);
ajAlignDel(&align);
ajStrDel(&merged);
AJFREE(compass);
AJFREE(path);
ajStrDel(&n);
ajStrDel(&m);
embExit();
return 0;
}
static AjBool ssematch_NWScore(AjPScop temp_scop,
AjPSeq pseq,
ajint mode,
AjPMatrixf matrix,
float gapopen,
float gapextend)
{
ajint start1 =0; /* Start of seq 1, passed as arg but not used.*/
ajint start2 =0; /* Start of seq 2, passed as arg but not used.*/
ajint maxarr =300; /* Initial size for matrix. */
ajint len;
ajint *compass;
const char *p; /* Query sequence. */
const char *q; /* Subject sequence from scop object. */
float **sub;
float id =0.; /* Passed as arg but not used here. */
float sim =0.;
float idx =0.; /* Passed as arg but not used here. */
float simx =0.; /* Passed as arg but not used here. */
float *path;
AjPStr pstr = NULL; /* m walk alignment for first sequence
Passed as arg but not used here. */
AjPStr qstr = NULL; /* n walk alignment for second sequence
Passed as arg but not used here. */
AjPSeq qseq = NULL; /* Subject sequence. */
ajint lenp; /* Length of query sequence. */
ajint lenq; /* Length of subject sequence. */
AjPSeqCvt cvt = 0;
AjBool show = ajFalse; /*Passed as arg but not used here. */
AJCNEW(path, maxarr);
AJCNEW(compass, maxarr);
pstr = ajStrNew();
qstr = ajStrNew();
gapopen = ajRoundFloat(gapopen,8);
gapextend = ajRoundFloat(gapextend,8);
sub = ajMatrixfGetMatrix(matrix);
cvt = ajMatrixfGetCvt(matrix);
/* Extract subject sequence from scop object, convert to 3 letter code. */
if (mode == 0)
qseq = ssematch_convertbases(temp_scop->Sse);
else if (mode == 1)
qseq = ssematch_convertbases(temp_scop->Sss);
lenp = ajSeqGetLen(pseq); /* Length of query sequence. */
lenq = ajSeqGetLen(qseq); /* Length of subject sequence. */
/* Start of main application loop */
/* Intitialise variables for use by alignment functions*/
len = (lenp * lenq);
if(len>maxarr)
{
AJCRESIZE(path,len);
AJCRESIZE(compass,len);
maxarr=len;
}
p = ajSeqGetSeqC(pseq);
q = ajSeqGetSeqC(qseq);
ajStrAssignC(&pstr,"");
ajStrAssignC(&qstr,"");
/* Check that no sequence length is 0. */
if((lenp == 0)||(lenq == 0))
{
AJFREE(compass);
AJFREE(path);
ajStrDel(&pstr);
ajStrDel(&qstr);
}
/* Call alignment functions. */
embAlignPathCalc(p,q,lenp,lenq, gapopen,
gapextend,path,sub,cvt,compass,show);
/*embAlignScoreNWMatrix(path,compass,gapopen,gapextend,
pseq, qseq,
lenp,lenq,sub,cvt,
&start1,&start2);*/
embAlignWalkNWMatrix(path,pseq,qseq,&pstr,&qstr,
lenp,lenq,&start1,&start2,
gapopen,gapextend,compass);
embAlignCalcSimilarity(pstr,qstr,sub,cvt,lenp,
lenq,&id,&sim,&idx, &simx);
/* Assign score. */
temp_scop->Score = sim;
/* Tidy up */
AJFREE(compass);
AJFREE(path);
ajStrDel(&pstr);
ajStrDel(&qstr);
ajSeqDel(&qseq);
/* Bye Bye */
return ajTrue;
}
int main(int argc, char **argv)
{
AjPSeqall queryseqs;
AjPSeqset targetseqs;
AjPSeq queryseq;
const AjPSeq targetseq;
AjPStr queryaln = 0;
AjPStr targetaln = 0;
AjPFile errorf;
AjBool show = ajFalse;
const char *queryseqc;
const char *targetseqc;
AjPMatrixf matrix;
AjPSeqCvt cvt = 0;
float **sub;
ajint *compass = NULL;
float *path = NULL;
float gapopen;
float gapextend;
float score;
float minscore;
ajuint j, k;
ajint querystart = 0;
ajint targetstart = 0;
ajint queryend = 0;
ajint targetend = 0;
ajint width = 0;
AjPTable kmers = 0;
ajint wordlen = 6;
ajint oldmax = 0;
ajint newmax = 0;
ajuint ntargetseqs;
ajuint nkmers;
AjPAlign align = NULL;
EmbPWordMatch maxmatch; /* match with maximum score */
/* Cursors for the current sequence being scanned,
** i.e., until which location it was scanned.
** Separate cursor/location entries for each sequence in the seqset.
*/
ajuint* lastlocation;
EmbPWordRK* wordsw = NULL;
AjPList* matchlist = NULL;
embInit("supermatcher", argc, argv);
matrix = ajAcdGetMatrixf("datafile");
queryseqs = ajAcdGetSeqall("asequence");
targetseqs= ajAcdGetSeqset("bsequence");
gapopen = ajAcdGetFloat("gapopen");
gapextend = ajAcdGetFloat("gapextend");
wordlen = ajAcdGetInt("wordlen");
align = ajAcdGetAlign("outfile");
errorf = ajAcdGetOutfile("errorfile");
width = ajAcdGetInt("width"); /* width for banded Smith-Waterman */
minscore = ajAcdGetFloat("minscore");
gapopen = ajRoundFloat(gapopen, 8);
gapextend = ajRoundFloat(gapextend, 8);
sub = ajMatrixfGetMatrix(matrix);
cvt = ajMatrixfGetCvt(matrix);
embWordLength(wordlen);
/* seqset sequence is the reference sequence for SAM format */
ajAlignSetRefSeqIndx(align, 1);
ajSeqsetTrim(targetseqs);
ntargetseqs = ajSeqsetGetSize(targetseqs);
AJCNEW0(matchlist, ntargetseqs);
/* get tables of words */
for(k=0;k<ntargetseqs;k++)
{
targetseq = ajSeqsetGetseqSeq(targetseqs, k);
embWordGetTable(&kmers, targetseq);
ajDebug("Number of distinct kmers found so far: %d\n",
ajTableGetLength(kmers));
}
AJCNEW0(lastlocation, ntargetseqs);
if(ajTableGetLength(kmers)<1)
ajErr("no kmers found");
nkmers = embWordRabinKarpInit(kmers, &wordsw, wordlen, targetseqs);
while(ajSeqallNext(queryseqs,&queryseq))
{
ajSeqTrim(queryseq);
queryaln = ajStrNewRes(1+ajSeqGetLen(queryseq));
ajDebug("Read '%S'\n", ajSeqGetNameS(queryseq));
for(k=0;k<ntargetseqs;k++)
{
lastlocation[k]=0;
matchlist[k] = ajListstrNew();
}
embWordRabinKarpSearch(ajSeqGetSeqS(queryseq), targetseqs,
(const EmbPWordRK*)wordsw, wordlen, nkmers,
matchlist, lastlocation, ajFalse);
for(k=0;k<ajSeqsetGetSize(targetseqs);k++)
{
targetseq = ajSeqsetGetseqSeq(targetseqs, k);
ajDebug("Processing '%S'\n", ajSeqGetNameS(targetseq));
if(ajListGetLength(matchlist[k])==0)
{
ajFmtPrintF(errorf,
"No wordmatch start points for "
"%s vs %s. No alignment\n",
ajSeqGetNameC(queryseq),ajSeqGetNameC(targetseq));
embWordMatchListDelete(&matchlist[k]);
continue;
}
/* only the maximum match is used as seed
* (if there is more than one location with the maximum match
* only the first one is used)
* TODO: we should add a new option to make above limit optional
*/
maxmatch = embWordMatchFirstMax(matchlist[k]);
supermatcher_findendpoints(maxmatch,targetseq, queryseq,
&targetstart, &querystart,
&targetend, &queryend);
targetaln=ajStrNewRes(1+ajSeqGetLen(targetseq));
queryseqc = ajSeqGetSeqC(queryseq);
targetseqc = ajSeqGetSeqC(targetseq);
ajStrAssignC(&queryaln,"");
ajStrAssignC(&targetaln,"");
ajDebug("++ %S v %S start:%d %d end:%d %d\n",
ajSeqGetNameS(targetseq), ajSeqGetNameS(queryseq),
targetstart, querystart, targetend, queryend);
newmax = (targetend-targetstart+2)*width;
if(newmax > oldmax)
{
AJCRESIZE0(path,oldmax,newmax);
AJCRESIZE0(compass,oldmax,newmax);
oldmax=newmax;
ajDebug("++ memory re/allocation for path/compass arrays"
" to size: %d\n", newmax);
}
else
{
AJCSET0(path,newmax);
AJCSET0(compass,newmax);
}
ajDebug("Calling embAlignPathCalcSWFast "
"%d..%d [%d/%d] %d..%d [%d/%d] width:%d\n",
querystart, queryend, (queryend - querystart + 1),
ajSeqGetLen(queryseq),
targetstart, targetend, (targetend - targetstart + 1),
ajSeqGetLen(targetseq),
width);
score = embAlignPathCalcSWFast(&targetseqc[targetstart],
&queryseqc[querystart],
targetend-targetstart+1,
queryend-querystart+1,
0,width,
gapopen,gapextend,
path,sub,cvt,
compass,show);
if(score>minscore)
{
embAlignWalkSWMatrixFast(path,compass,gapopen,gapextend,
targetseq,queryseq,
&targetaln,&queryaln,
targetend-targetstart+1,
queryend-querystart+1,
0,width,
&targetstart,&querystart);
if(!ajAlignFormatShowsSequences(align))
{
ajAlignDefineCC(align, ajStrGetPtr(targetaln),
ajStrGetPtr(queryaln),
ajSeqGetNameC(targetseq),
ajSeqGetNameC(queryseq));
ajAlignSetScoreR(align, score);
}
else
{
ajDebug(" queryaln:%S \ntargetaln:%S\n",
queryaln,targetaln);
embAlignReportLocal(align,
queryseq, targetseq,
queryaln, targetaln,
querystart, targetstart,
gapopen, gapextend,
score, matrix,
1 + ajSeqGetOffset(queryseq),
1 + ajSeqGetOffset(targetseq)
);
}
ajAlignWrite(align);
ajAlignReset(align);
}
ajStrDel(&targetaln);
embWordMatchListDelete(&matchlist[k]);
}
ajStrDel(&queryaln);
}
for(k=0;k<nkmers;k++)
{
AJFREE(wordsw[k]->seqindxs);
AJFREE(wordsw[k]->nSeqMatches);
for(j=0;j<wordsw[k]->nseqs;j++)
AJFREE(wordsw[k]->locs[j]);
AJFREE(wordsw[k]->nnseqlocs);
AJFREE(wordsw[k]->locs);
AJFREE(wordsw[k]);
}
embWordFreeTable(&kmers);
if(!ajAlignFormatShowsSequences(align))
ajMatrixfDel(&matrix);
AJFREE(path);
AJFREE(compass);
AJFREE(kmers);
AJFREE(wordsw);
AJFREE(matchlist);
AJFREE(lastlocation);
ajAlignClose(align);
ajAlignDel(&align);
ajSeqallDel(&queryseqs);
ajSeqDel(&queryseq);
ajSeqsetDel(&targetseqs);
ajFileClose(&errorf);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPSeqall seqall;
AjPSeq seq = NULL;
AjPFile inf = NULL;
AjPStr strand = NULL;
AjPStr substr = NULL;
AjPStr name = NULL;
AjPStr mname = NULL;
AjPStr tname = NULL;
AjPStr pname = NULL;
AjPStr line = NULL;
AjPStr cons = NULL;
AjPStr m = NULL;
AjPStr n = NULL;
AjPAlign align= NULL; /* JISON, replaces AjPOutfile outf */
ajint type;
ajint begin;
ajint end;
ajulong len;
ajint i;
ajint j;
float **fmatrix=NULL;
ajint mlen;
float maxfs;
ajint thresh;
float gapopen;
float gapextend;
float opencoeff;
float extendcoeff;
const char *p;
ajulong maxarr = 1000;
ajulong alen;
float *path;
ajint *compass;
size_t stlen;
embInit("prophet", argc, argv);
seqall = ajAcdGetSeqall("sequence");
inf = ajAcdGetInfile("infile");
opencoeff = ajAcdGetFloat("gapopen");
extendcoeff = ajAcdGetFloat("gapextend");
align = ajAcdGetAlign("outfile"); /*JISON replacing outfile */
opencoeff = ajRoundFloat(opencoeff, 8);
extendcoeff = ajRoundFloat(extendcoeff, 8);
substr = ajStrNew();
name = ajStrNew();
mname = ajStrNew();
tname = ajStrNew();
line = ajStrNew();
m = ajStrNewC("");
n = ajStrNewC("");
type = prophet_getType(inf,&tname);
if(!type)
ajFatal("Unrecognised profile/matrix file format");
prophet_read_profile(inf,&pname,&mname,&mlen,&gapopen,&gapextend,&thresh,
&maxfs, &cons);
ajAlignSetMatrixName(align, mname);
AJCNEW(fmatrix, mlen);
for(i=0;i<mlen;++i)
{
AJCNEW(fmatrix[i], AZ);
if(!ajReadlineTrim(inf,&line))
ajFatal("Missing matrix line");
p = ajStrGetPtr(line);
p = ajSysFuncStrtok(p," \t");
for(j=0;j<AZ;++j)
{
sscanf(p,"%f",&fmatrix[i][j]);
p = ajSysFuncStrtok(NULL," \t");
}
}
AJCNEW(path, maxarr);
AJCNEW(compass, maxarr);
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);
len = ajStrGetLen(substr);
if(len > (ULONG_MAX/(ajulong)(mlen+1)))
ajFatal("Sequences too big. Try 'supermatcher'");
alen = len*mlen;
if(alen>maxarr)
{
stlen = (size_t) alen;
AJCRESIZE(path,stlen);
AJCRESIZE(compass,stlen);
maxarr=alen;
}
ajStrAssignC(&m,"");
ajStrAssignC(&n,"");
/* JISON used to be
prophet_scan_profile(substr,pname,name,mlen,fmatrix,
outf,cons,opencoeff,
extendcoeff,path,compass,&m,&n,len); */
/* JISON new call and reset align */
prophet_scan_profile(substr,name,pname,mlen,fmatrix,
align,cons,opencoeff,
extendcoeff,path,compass,&m,&n,(ajint)len);
ajAlignReset(align);
ajStrDel(&strand);
}
for(i=0;i<mlen;++i)
AJFREE (fmatrix[i]);
AJFREE (fmatrix);
AJFREE(path);
AJFREE(compass);
ajStrDel(&line);
ajStrDel(&cons);
ajStrDel(&name);
ajStrDel(&pname);
ajStrDel(&mname);
ajStrDel(&tname);
ajStrDel(&substr);
ajStrDel(&m);
ajStrDel(&n);
ajSeqDel(&seq);
ajFileClose(&inf);
ajAlignClose(align);
ajAlignDel(&align);
ajSeqallDel(&seqall);
embExit();
return 0;
}
