int main(int argc, char *argv[])
{
char *sequence;
char *structure = NULL;
char *ns_bases = NULL, *c;
int i, length, l, sym;
int istty;
double deltap=0.;
int delta=100;
int n_back = 0;
int noconv=0;
int circ=0;
int dos=0;
AjPSeq seq = NULL;
AjPFile confile = NULL;
AjPFile paramfile = NULL;
AjPFile outf = NULL;
AjPStr constring = NULL;
float eT = 0.;
AjBool eGU;
AjBool eclose;
AjBool lonely;
AjBool convert;
AjPStr ensbases = NULL;
AjBool etloop;
AjPStr edangles = NULL;
char edangle = '\0';
ajint len;
float erange;
float prange;
embInitPV("vrnasubopt",argc,argv,"VIENNA",VERSION);
constring = ajStrNew();
seq = ajAcdGetSeq("sequence");
confile = ajAcdGetInfile("constraintfile");
paramfile = ajAcdGetInfile("paramfile");
eT = ajAcdGetFloat("temperature");
circ = !!ajAcdGetBoolean("circular");
dos = !!ajAcdGetBoolean("dos");
eGU = ajAcdGetBoolean("gu");
eclose = ajAcdGetBoolean("closegu");
lonely = ajAcdGetBoolean("lp");
convert = ajAcdGetBoolean("convert");
ensbases = ajAcdGetString("nsbases");
etloop = ajAcdGetBoolean("tetraloop");
erange = ajAcdGetFloat("erange");
prange = ajAcdGetFloat("prange");
subopt_sorted = !!ajAcdGetBoolean("sort");
logML = !!ajAcdGetBoolean("logml");
n_back = ajAcdGetInt("nrandom");
edangles = ajAcdGetListSingle("dangles");
outf = ajAcdGetOutfile("outfile");
if(dos)
print_energy = -999999;
do_backtrack = 1;
istty = 0;
temperature = (double) eT;
noGU = (eGU) ? 0 : 1;
no_closingGU = (eclose) ? 0 : 1;
noLonelyPairs = (lonely) ? 0 : 1;
noconv = (convert) ? 0 : 1;
ns_bases = (ajStrGetLen(ensbases)) ? MAJSTRGETPTR(ensbases) : NULL;
tetra_loop = !!etloop;
delta = (int) (0.1 + erange * 100);
deltap = prange;
edangle = *ajStrGetPtr(edangles);
if(edangle == '0')
dangles = 0;
else if(edangle == '1')
dangles = 1;
else if(edangle == '2')
dangles = 2;
else if(edangle == '3')
dangles = 3;
if(paramfile)
read_parameter_file(paramfile);
if (ns_bases != NULL)
{
nonstandards = space(33);
c=ns_bases;
i=sym=0;
if (*c=='-')
{
sym=1;
c++;
}
while (*c)
{
if (*c!=',')
{
nonstandards[i++]=*c++;
nonstandards[i++]=*c;
if ((sym)&&(*c!=*(c-1)))
{
nonstandards[i++]=*c;
nonstandards[i++]=*(c-1);
}
}
c++;
}
}
if(confile)
vienna_GetConstraints(confile,&constring);
if(n_back)
init_rand();
sequence = NULL;
structure = NULL;
length = ajSeqGetLen(seq);
sequence = (char *) space(length+1);
strcpy(sequence,ajSeqGetSeqC(seq));
len = ajStrGetLen(constring);
structure = (char *) space(length+1);
if(len)
{
fold_constrained = 1;
strcpy(structure,ajStrGetPtr(constring));
}
istty = 0;
if (fold_constrained)
{
for (i=0; i<length; i++)
if (structure[i]=='|')
ajFatal("Constraints of type '|' are not allowed\n");
}
for (l = 0; l < length; l++)
{
sequence[l] = toupper(sequence[l]);
if (!noconv && sequence[l] == 'T')
sequence[l] = 'U';
}
if ((logML!=0 || dangles==1 || dangles==3) && dos==0)
if (deltap<=0) deltap=delta/100. +0.001;
if (deltap>0)
print_energy = deltap;
/* first lines of output (suitable for sort +1n) */
ajFmtPrintF(outf,"> %s [%d]\n", ajSeqGetNameC(seq), delta);
if(n_back>0)
{
int i;
double mfe, kT;
char *ss;
st_back=1;
ss = (char *) space(strlen(sequence)+1);
strncpy(ss, structure, length);
mfe = (circ) ? circfold(sequence, ss) : fold(sequence, ss);
kT = (temperature+273.15)*1.98717/1000.; /* in Kcal */
pf_scale = exp(-(1.03*mfe)/kT/length);
strncpy(ss, structure, length);
/*
** we are not interested in the free energy but in the bppm, so we
** drop free energy into the void
*/
(circ) ? (void) pf_circ_fold(sequence, ss) :
(void) pf_fold(sequence, ss);
free(ss);
for (i=0; i<n_back; i++)
{
char *s;
s = (circ) ? pbacktrack_circ(sequence) : pbacktrack(sequence);
ajFmtPrintF(outf,"%s\n", s);
free(s);
}
free_pf_arrays();
}
else
{
(circ) ? subopt_circ(sequence, structure, delta, ajFileGetFileptr(outf)) :
subopt(sequence, structure, delta, ajFileGetFileptr(outf));
}
free(sequence);
free(structure);
ajSeqDel(&seq);
ajStrDel(&ensbases);
ajStrDel(&edangles);
ajFileClose(&confile);
ajFileClose(&outf);
ajFileClose(¶mfile);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPSeq seq = NULL;
AjPFile angles = NULL;
AjPFile energies = NULL;
AjPFile result = NULL;
AjPTable angletable = NULL;
AjPTable energytable = NULL;
AjPStr nucs = NULL;
const AjPStr valstr = NULL;
const char * dinuc = NULL;
ajint len;
ajint begin;
ajint end;
ajint i;
float val;
float anglesum = 0.0;
float energysum = 0.0;
float twists = 0.0;
float basesperturn = 0.0;
float energyperbase = 0.0;
embInit ("btwisted", argc, argv);
seq = ajAcdGetSeq ("sequence");
angles = ajAcdGetDatafile("angledata");
energies = ajAcdGetDatafile("energydata");
result = ajAcdGetOutfile ("outfile");
nucs = ajStrNew();
angletable = btwisted_getdinucdata(angles);
energytable = btwisted_getdinucdata(energies);
ajFileClose(&angles);
ajFileClose(&energies);
begin = ajSeqGetBegin(seq);
end = ajSeqGetEnd(seq);
len = end-begin+1;
dinuc = ajSeqGetSeqC(seq);
for(i=begin-1; i<end-1; ++i)
{
ajStrAssignSubC(&nucs,dinuc,i,i+1);
if(!(valstr = ajTableFetchS(angletable, nucs)))
ajFatal("Incomplete table");
ajStrToFloat(valstr,&val);
anglesum += val;
if(!(valstr = ajTableFetchS(energytable, nucs)))
ajFatal("Incomplete table");
ajStrToFloat(valstr,&val);
energysum += val;
}
twists = anglesum / (float)360.0 ;
basesperturn = (float) len * (float)360.0 /anglesum;
energyperbase = energysum/(float) (len-1);
ajFmtPrintF(result, "# Output from BTWISTED\n");
ajFmtPrintF(result, "# Twisting calculated from %d to %d of %s\n",
begin, end, ajSeqGetNameC(seq));
ajFmtPrintF(result,"Total twist (degrees): %.1f\n", anglesum);
ajFmtPrintF(result,"Total turns : %.2f\n", twists);
ajFmtPrintF(result,"Average bases per turn: %.2f\n", basesperturn);
ajFmtPrintF(result,"Total stacking energy : %.2f\n", energysum);
ajFmtPrintF(result,"Average stacking energy per dinucleotide: %.2f\n",
energyperbase);
ajTablestrFree(&angletable);
ajTablestrFree(&energytable);
ajStrDel(&nucs);
ajFileClose(&result);
ajSeqDel(&seq);
embExit ();
return 0;
}
int main(int argc, char **argv)
{
AjPSeqall seqall;
AjPSeq seq;
AjPFile outf;
AjPCod codon;
AjPStr substr;
AjBool sum;
ajint ccnt;
ajint beg;
ajint end;
float Nc;
double td;
embInit("chips", argc, argv);
seqall = ajAcdGetSeqall("seqall");
outf = ajAcdGetOutfile("outfile");
sum = ajAcdGetBoolean("sum");
codon = ajCodNewCodenum(0);
ccnt = 0;
substr = ajStrNew();
while(ajSeqallNext(seqall, &seq))
{
beg = ajSeqallGetseqBegin(seqall);
end = ajSeqallGetseqEnd(seqall);
ajStrAssignSubS(&substr,ajSeqGetSeqS(seq),beg-1,end-1);
ajStrFmtUpper(&substr);
ajCodSetTripletsS(codon,substr,&ccnt);
if(!sum)
{
ajCodCalcUsage(codon,ccnt);
td = ajCodCalcNc(codon);
Nc = (float) td;
ajFmtPrintF(outf,"%-20s Nc = %.3f\n",ajSeqGetNameC(seq),Nc);
ajCodClearData(codon);
}
}
if(sum)
{
ajCodCalcUsage(codon,ccnt);
td = ajCodCalcNc(codon);
Nc = (float) td;
ajFmtPrintF(outf,"# CHIPS codon usage statistics\n\n");
ajFmtPrintF(outf,"Nc = %.3f\n",Nc);
}
ajFileClose(&outf);
ajCodDel(&codon);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&substr);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPList list = NULL;
AjPSeq seq;
AjPSeq seq2;
AjPStr aa0str = 0;
AjPStr aa1str = 0;
const char *s1;
const char *s2;
char *strret = NULL;
ajuint i;
ajuint j;
ajuint k;
ajint l;
ajint abovethresh;
ajint total;
ajint starti = 0;
ajint startj = 0;
ajint windowsize;
float thresh;
AjPGraph graph = NULL;
AjPGraph xygraph = NULL;
float flen1;
float flen2;
ajuint len1;
ajuint len2;
AjPTime ajtime = NULL;
time_t tim;
AjBool boxit=AJTRUE;
/* Different ticks as they need to be different for x and y due to
length of string being important on x */
ajuint acceptableticksx[]=
{
1,10,50,100,500,1000,1500,10000,
500000,1000000,5000000
};
ajuint acceptableticks[]=
{
1,10,50,100,200,500,1000,2000,5000,10000,15000,
500000,1000000,5000000
};
ajint numbofticks = 10;
float xmargin;
float ymargin;
float ticklen;
float tickgap;
float onefifth;
float k2;
float max;
char ptr[10];
AjPMatrix matrix = NULL;
ajint** sub;
AjPSeqCvt cvt;
AjPStr subt = NULL;
ajint b1;
ajint b2;
ajint e1;
ajint e2;
AjPStr se1;
AjPStr se2;
ajint ithresh;
AjBool stretch;
PPoint ppt = NULL;
float xa[1];
float ya[1];
AjPGraphdata gdata=NULL;
AjPStr tit = NULL;
AjIList iter = NULL;
float x1 = 0.;
float x2 = 0.;
float y1 = 0.;
float y2 = 0.;
ajuint tui;
se1 = ajStrNew();
se2 = ajStrNew();
embInit("dotmatcher", argc, argv);
seq = ajAcdGetSeq("asequence");
seq2 = ajAcdGetSeq("bsequence");
stretch = ajAcdGetToggle("stretch");
graph = ajAcdGetGraph("graph");
xygraph = ajAcdGetGraphxy("xygraph");
windowsize = ajAcdGetInt("windowsize");
ithresh = ajAcdGetInt("threshold");
matrix = ajAcdGetMatrix("matrixfile");
sub = ajMatrixGetMatrix(matrix);
cvt = ajMatrixGetCvt(matrix);
thresh = (float)ithresh;
ajtime = ajTimeNew();
tim = time(0);
ajTimeSetLocal(ajtime, tim);
b1 = ajSeqGetBegin(seq);
b2 = ajSeqGetBegin(seq2);
e1 = ajSeqGetEnd(seq);
e2 = ajSeqGetEnd(seq2);
len1 = ajSeqGetLen(seq);
len2 = ajSeqGetLen(seq2);
tui = ajSeqGetLen(seq);
flen1 = (float) tui;
tui = ajSeqGetLen(seq2);
flen2 = (float) tui;
ajStrAssignSubC(&se1,ajSeqGetSeqC(seq),b1-1,e1-1);
ajStrAssignSubC(&se2,ajSeqGetSeqC(seq2),b2-1,e2-1);
ajSeqAssignSeqS(seq,se1);
ajSeqAssignSeqS(seq2,se2);
s1 = ajStrGetPtr(ajSeqGetSeqS(seq));
s2 = ajStrGetPtr(ajSeqGetSeqS(seq2));
aa0str = ajStrNewRes(1+len1); /* length plus trailing blank */
aa1str = ajStrNewRes(1+len2);
list = ajListNew();
for(i=0;i<len1;i++)
ajStrAppendK(&aa0str,(char)ajSeqcvtGetCodeK(cvt, *s1++));
for(i=0;i<len2;i++)
ajStrAppendK(&aa1str,(char)ajSeqcvtGetCodeK(cvt, *s2++));
max = (float)len1;
if(len2 > max)
max = (float) len2;
xmargin = ymargin = max *(float)0.15;
ticklen = xmargin*(float)0.1;
onefifth = xmargin*(float)0.2;
subt = ajStrNewC((strret=
ajFmtString("(windowsize = %d, threshold = %3.2f %D)",
windowsize,thresh,ajtime)));
if(!stretch)
{
if( ajStrGetLen(ajGraphGetSubtitleS(graph)) <=1)
ajGraphSetSubtitleS(graph,subt);
ajGraphOpenWin(graph, (float)0.0-ymargin,(max*(float)1.35)+ymargin,
(float)0.0-xmargin,(float)max+xmargin);
ajGraphicsDrawposTextAtmid(flen1*(float)0.5,
(float)0.0-(xmargin/(float)2.0),
ajGraphGetXlabelC(graph));
ajGraphicsDrawposTextAtlineJustify((float)0.0-(xmargin*(float)0.75),
flen2*(float)0.5,
(float)0.0-(xmargin*(float)0.75),flen1,
ajGraphGetYlabelC(graph),0.5);
ajGraphicsSetCharscale(0.5);
}
s1= ajStrGetPtr(aa0str);
s2 = ajStrGetPtr(aa1str);
for(j=0; (ajint)j < (ajint)len2-windowsize;j++)
{
i =0;
total = 0;
abovethresh =0;
k = j;
for(l=0;l<windowsize;l++)
total = total + sub[(ajint)s1[i++]][(ajint)s2[k++]];
if(total >= thresh)
{
abovethresh=1;
starti = i-windowsize;
startj = k-windowsize;
}
while(i < len1 && k < len2)
{
total = total - sub[(ajint)s1[i-windowsize]]
[(ajint)s2[k-windowsize]];
total = total + sub[(ajint)s1[i]][(ajint)s2[k]];
if(abovethresh)
{
if(total < thresh)
{
abovethresh = 0;
/* draw the line */
dotmatcher_pushpoint(&list,(float)starti,(float)startj,
(float)i-1,(float)k-1,stretch);
}
}
else if(total >= thresh)
{
starti = i-windowsize;
startj = k-windowsize;
abovethresh= 1;
}
i++;
k++;
}
if(abovethresh)
/* draw the line */
dotmatcher_pushpoint(&list,(float)starti,(float)startj,
(float)i-1,(float)k-1,
stretch);
}
for(i=0; (ajint)i < (ajint)len1-windowsize;i++)
{
j = 0;
total = 0;
abovethresh =0;
k = i;
for(l=0;l<windowsize;l++)
total = total + sub[(ajint)s1[k++]][(ajint)s2[j++]];
if(total >= thresh)
{
abovethresh=1;
starti = k-windowsize;
startj = j-windowsize;
}
while(k < len1 && j < len2)
{
total = total - sub[(ajint)s1[k-windowsize]]
[(ajint)s2[j-windowsize]];
total = total + sub[(ajint)s1[k]][(ajint)s2[j]];
if(abovethresh)
{
if(total < thresh)
{
abovethresh = 0;
/* draw the line */
dotmatcher_pushpoint(&list,(float)starti,(float)startj,
(float)k-1,(float)j-1,stretch);
}
}
else if(total >= thresh)
{
starti = k-windowsize;
startj = j-windowsize;
abovethresh= 1;
}
j++;
k++;
}
if(abovethresh)
/* draw the line */
dotmatcher_pushpoint(&list,(float)starti,(float)startj,
(float)k-1,(float)j-1,
stretch);
}
if(boxit && !stretch)
{
ajGraphicsDrawposRect(0.0,0.0,flen1, flen2);
i=0;
while(acceptableticksx[i]*numbofticks < len1)
i++;
if(i<=13)
tickgap = (float)acceptableticksx[i];
else
tickgap = (float)acceptableticksx[10];
ticklen = xmargin*(float)0.1;
onefifth = xmargin*(float)0.2;
if(len2/len1 > 10 )
{
/* if a lot smaller then just label start and end */
ajGraphicsDrawposLine((float)0.0,(float)0.0,(float)0.0,(float)0.0-ticklen);
sprintf(ptr,"%d",b1-1);
ajGraphicsDrawposTextAtmid((float)0.0,(float)0.0-(onefifth),ptr);
ajGraphicsDrawposLine(flen1,(float)0.0,
flen1,(float)0.0-ticklen);
sprintf(ptr,"%d",len1+b1-1);
ajGraphicsDrawposTextAtmid(flen1,(float)0.0-(onefifth),ptr);
}
else
for(k2=0.0;k2<len1;k2+=tickgap)
{
ajGraphicsDrawposLine(k2,(float)0.0,k2,(float)0.0-ticklen);
sprintf(ptr,"%d",(ajint)k2+b1-1);
ajGraphicsDrawposTextAtmid(k2,(float)0.0-(onefifth),ptr);
}
i = 0;
while(acceptableticks[i]*numbofticks < len2)
i++;
tickgap = (float)acceptableticks[i];
ticklen = ymargin*(float)0.01;
onefifth = ymargin*(float)0.02;
if(len1/len2 > 10 )
{
/* if a lot smaller then just label start and end */
ajGraphicsDrawposLine((float)0.0,(float)0.0,(float)0.0-ticklen,(float)0.0);
sprintf(ptr,"%d",b2-1);
ajGraphicsDrawposTextAtend((float)0.0-(onefifth),(float)0.0,ptr);
ajGraphicsDrawposLine((float)0.0,flen2,(float)0.0-ticklen,
flen2);
sprintf(ptr,"%d",len2+b2-1);
ajGraphicsDrawposTextAtend((float)0.0-(onefifth),flen2,ptr);
}
else
for(k2=0.0;k2<len2;k2+=tickgap)
{
ajGraphicsDrawposLine((float)0.0,k2,(float)0.0-ticklen,k2);
sprintf(ptr,"%d",(ajint)k2+b2-1);
ajGraphicsDrawposTextAtend((float)0.0-(onefifth),k2,ptr);
}
}
if(!stretch)
ajGraphicsClose();
else /* the xy graph for -stretch */
{
tit = ajStrNew();
ajFmtPrintS(&tit,"%S",ajGraphGetTitleS(xygraph));
gdata = ajGraphdataNewI(1);
xa[0] = (float)b1;
ya[0] = (float)b2;
ajGraphSetTitleC(xygraph,ajStrGetPtr(tit));
ajGraphSetXlabelC(xygraph,ajSeqGetNameC(seq));
ajGraphSetYlabelC(xygraph,ajSeqGetNameC(seq2));
ajGraphdataSetTypeC(gdata,"2D Plot Float");
ajGraphdataSetTitleS(gdata,subt);
ajGraphdataSetMinmax(gdata,(float)b1,(float)e1,(float)b2,
(float)e2);
ajGraphdataSetTruescale(gdata,(float)b1,(float)e1,(float)b2,
(float)e2);
ajGraphxySetXstartF(xygraph,(float)b1);
ajGraphxySetXendF(xygraph,(float)e1);
ajGraphxySetYstartF(xygraph,(float)b2);
ajGraphxySetYendF(xygraph,(float)e2);
ajGraphxySetXrangeII(xygraph,b1,e1);
ajGraphxySetYrangeII(xygraph,b2,e2);
if(list)
{
iter = ajListIterNewread(list);
while((ppt = ajListIterGet(iter)))
{
x1 = ppt->x1+b1-1;
y1 = ppt->y1+b2-1;
x2 = ppt->x2+b1-1;
y2 = ppt->y2+b2-1;
ajGraphAddLine(xygraph,x1,y1,x2,y2,0);
AJFREE(ppt);
}
ajListIterDel(&iter);
}
ajGraphdataAddXY(gdata,xa,ya);
ajGraphDataReplace(xygraph,gdata);
ajGraphxyDisplay(xygraph,ajFalse);
ajGraphicsClose();
ajStrDel(&tit);
}
ajListFree(&list);
ajSeqDel(&seq);
ajSeqDel(&seq2);
ajGraphxyDel(&graph);
ajGraphxyDel(&xygraph);
ajMatrixDel(&matrix);
ajTimeDel(&ajtime);
/* deallocate memory */
ajStrDel(&aa0str);
ajStrDel(&aa1str);
ajStrDel(&se1);
ajStrDel(&se2);
ajStrDel(&subt);
AJFREE(strret); /* created withing ajFmtString */
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPSeqall seqall;
AjPSeq seq = NULL;
AjPFile outf = NULL;
AjPStr strand = NULL;
AjPStr substr = NULL;
AjPFeattabOut featout;
AjPFeattable feattable=NULL;
ajint begin;
ajint end;
ajint len;
ajint score;
embInit("cpgreport",argc,argv);
seqall = ajAcdGetSeqall("sequence");
score = ajAcdGetInt("score");
outf = ajAcdGetOutfile("outfile");
featout = ajAcdGetFeatout("outfeat");
substr = ajStrNew();
while(ajSeqallNext(seqall, &seq))
{
if (!feattable)
feattable = ajFeattableNewDna(ajSeqGetNameS(seq));
begin = ajSeqallGetseqBegin(seqall);
end = ajSeqallGetseqEnd(seqall);
strand = ajSeqGetSeqCopyS(seq);
ajStrFmtUpper(&strand);
ajStrAssignSubC(&substr,ajStrGetPtr(strand),begin-1,end-1);
len=ajStrGetLen(substr);
ajFmtPrintF(outf,"\n\nCPGREPORT of %s from %d to %d\n\n",
ajSeqGetNameC(seq),begin,begin+len-1);
ajFmtPrintF(outf,"Sequence Begin End Score");
ajFmtPrintF(outf," CpG %%CG CG/GC\n");
cpgreport_cpgsearch(outf,0,len,ajStrGetPtr(substr),ajSeqGetNameC(seq),
begin,score,feattable);
ajStrDel(&strand);
}
ajSeqDel(&seq);
ajStrDel(&substr);
ajFileClose(&outf);
ajFeatSortByStart(feattable);
ajFeattableWrite(featout, feattable);
ajFeattableDel(&feattable);
ajFeattabOutDel(&featout);
ajSeqallDel(&seqall);
ajStrDel(&cpgreportSource);
ajStrDel(&cpgreportType);
embExit();
return 0;
}
static void dottup_stretchplot(AjPGraph graph, const AjPList matchlist,
const AjPSeq seq1, const AjPSeq seq2,
ajint begin1, ajint begin2,
ajint end1, ajint end2)
{
EmbPWordMatch wmp = NULL;
float xa[1];
float ya[2];
AjPGraphdata gdata = NULL;
AjPStr tit = NULL;
float x1;
float y1;
float x2;
float y2;
AjIList iter = NULL;
tit = ajStrNew();
ajFmtPrintS(&tit,"%S",ajGraphGetTitleS(graph));
gdata = ajGraphdataNewI(1);
xa[0] = (float)begin1;
ya[0] = (float)begin2;
ajGraphSetTitleC(graph,ajStrGetPtr(tit));
ajGraphSetXlabelC(graph,ajSeqGetNameC(seq1));
ajGraphSetYlabelC(graph,ajSeqGetNameC(seq2));
ajGraphdataSetTypeC(gdata,"2D Plot Float");
ajGraphdataSetMinmax(gdata,(float)begin1,(float)end1,(float)begin2,
(float)end2);
ajGraphdataSetTruescale(gdata,(float)begin1,(float)end1,(float)begin2,
(float)end2);
ajGraphxySetXstartF(graph,(float)begin1);
ajGraphxySetXendF(graph,(float)end1);
ajGraphxySetYstartF(graph,(float)begin2);
ajGraphxySetYendF(graph,(float)end2);
ajGraphxySetXrangeII(graph,begin1,end1);
ajGraphxySetYrangeII(graph,begin2,end2);
if(matchlist)
{
iter = ajListIterNewread(matchlist);
while((wmp = ajListIterGet(iter)))
{
x1 = x2 = (float) (wmp->seq1start + begin1);
y1 = y2 = (float) (wmp->seq2start + begin2);
x2 += (float) wmp->length-1;
y2 += (float) wmp->length-1;
ajGraphAddLine(graph,x1,y1,x2,y2,0);
}
ajListIterDel(&iter);
}
ajGraphdataAddXY(gdata,xa,ya);
ajGraphDataReplace(graph,gdata);
ajGraphxyDisplay(graph,ajFalse);
ajGraphicsClose();
ajStrDel(&tit);
return;
}
int main(int argc, char **argv)
{
AjPSeqall seq1;
AjPSeqset seq2;
AjPSeq a;
const AjPSeq b;
AjPStr m = 0;
AjPStr n = 0;
AjPFile errorf;
AjBool show = ajFalse;
ajint lena = 0;
ajint lenb = 0;
const char *p;
const char *q;
AjPMatrixf matrix;
AjPSeqCvt cvt = 0;
float **sub;
ajint *compass = NULL;
float *path = NULL;
float gapopen;
float gapextend;
float score;
ajint begina;
ajint i;
ajuint k;
ajint beginb;
ajint start1 = 0;
ajint start2 = 0;
ajint end1 = 0;
ajint end2 = 0;
ajint width = 0;
AjPTable seq1MatchTable = 0;
ajint wordlen = 6;
ajint oldmax = 0;
AjPAlign align = NULL;
embInit("supermatcher", argc, argv);
matrix = ajAcdGetMatrixf("datafile");
seq1 = ajAcdGetSeqall("asequence");
seq2 = ajAcdGetSeqset("bsequence");
gapopen = ajAcdGetFloat("gapopen");
gapextend = ajAcdGetFloat("gapextend");
wordlen = ajAcdGetInt("wordlen");
align = ajAcdGetAlign("outfile");
errorf = ajAcdGetOutfile("errorfile");
width = ajAcdGetInt("width"); /* not the same as awidth */
gapopen = ajRoundFloat(gapopen, 8);
gapextend = ajRoundFloat(gapextend, 8);
sub = ajMatrixfGetMatrix(matrix);
cvt = ajMatrixfGetCvt(matrix);
embWordLength(wordlen);
ajSeqsetTrim(seq2);
while(ajSeqallNext(seq1,&a))
{
ajSeqTrim(a);
begina = 1 + ajSeqGetOffset(a);
m = ajStrNewRes(1+ajSeqGetLen(a));
lena = ajSeqGetLen(a);
ajDebug("Read '%S'\n", ajSeqGetNameS(a));
if(!embWordGetTable(&seq1MatchTable, a)) /* get table of words */
ajErr("Could not generate table for %s\n",
ajSeqGetNameC(a));
for(k=0;k<ajSeqsetGetSize(seq2);k++)
{
b = ajSeqsetGetseqSeq(seq2, k);
lenb = ajSeqGetLen(b);
beginb = 1 + ajSeqGetOffset(b);
ajDebug("Processing '%S'\n", ajSeqGetNameS(b));
p = ajSeqGetSeqC(a);
q = ajSeqGetSeqC(b);
if(!supermatcher_findstartpoints(seq1MatchTable,b,a,
&start1, &start2,
&end1, &end2))
{
ajFmtPrintF(errorf,
"No wordmatch start points for "
"%s vs %s. No alignment\n",
ajSeqGetNameC(a),ajSeqGetNameC(b));
continue;
}
n=ajStrNewRes(1+ajSeqGetLen(b));
ajStrAssignC(&m,"");
ajStrAssignC(&n,"");
ajDebug("++ %S v %S start:%d %d end:%d %d\n",
ajSeqGetNameS(a), ajSeqGetNameS(b),
start1, start2, end1, end2);
if(end1-start1+1 > oldmax)
{
oldmax = ((end1-start1)+1);
AJRESIZE(path,oldmax*width*sizeof(float));
AJRESIZE(compass,oldmax*width*sizeof(ajint));
ajDebug("++ resize to oldmax: %d\n", oldmax);
}
for(i=0;i<((end1-start1)+1)*width;i++)
path[i] = 0.0;
ajDebug("Calling embAlignPathCalcFast "
"%d..%d [%d/%d] %d..%d [%d/%d]\n",
start1, end1, (end1 - start1 + 1), lena,
start2, end2, (end2 - start2 + 1), lenb);
score = embAlignPathCalcSWFast(&p[start1],&q[start2],
end1-start1+1,end2-start2+1,
0,width,
gapopen,gapextend,
path,sub,cvt,
compass,show);
embAlignWalkSWMatrixFast(path,compass,gapopen,gapextend,a,b,
&m,&n,end1-start1+1,end2-start2+1,
0,width,
&start1,&start2);
if(!ajAlignFormatShowsSequences(align))
{
ajAlignDefineCC(align, ajStrGetPtr(m),
ajStrGetPtr(n), ajSeqGetNameC(a),
ajSeqGetNameC(b));
ajAlignSetScoreR(align, score);
}
else
{
embAlignReportLocal(align, a, b,
m,n,start1,start2,
gapopen, gapextend,
score,matrix, begina, beginb);
}
ajAlignWrite(align);
ajAlignReset(align);
ajStrDel(&n);
}
embWordFreeTable(&seq1MatchTable); /* free table of words */
seq1MatchTable=0;
ajStrDel(&m);
}
if(!ajAlignFormatShowsSequences(align))
{
ajMatrixfDel(&matrix);
}
AJFREE(path);
AJFREE(compass);
ajAlignClose(align);
ajAlignDel(&align);
ajSeqallDel(&seq1);
ajSeqDel(&a);
ajSeqsetDel(&seq2);
ajFileClose(&errorf);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPSeqall seqall;
AjPSeq seq = NULL;
AjPStr seqcmp = NULL;
AjPStr enzymes = NULL;
AjPFile outf = NULL;
ajint begin;
ajint end;
ajint min;
ajint max;
ajint sitelen;
AjBool alpha;
AjBool single;
AjBool blunt;
AjBool ambiguity;
AjBool sticky;
AjBool plasmid;
AjBool threeprime;
AjBool commercial;
AjBool html;
AjBool limit;
AjBool frags;
AjBool methyl;
AjPFile dfile;
AjPFile enzfile = NULL;
AjPFile equfile = NULL;
AjPFile methfile = NULL;
AjPStr name = NULL;
AjPTable table = NULL;
ajint hits;
AjPList l = NULL;
embInit("restover", argc, argv);
seqall = ajAcdGetSeqall("sequence");
seqcmp = ajAcdGetString("seqcomp");
ajStrFmtUpper(&seqcmp);
outf = ajAcdGetOutfile("outfile");
/*
** Some of these are not needed but I left them in case someone wants to
** use them some time ...
*/
enzymes = ajStrNewC("all");
min = ajAcdGetInt("min");
max = ajAcdGetInt("max");
sitelen = 2;
threeprime = ajAcdGetBoolean("threeprime");
blunt = ajAcdGetBoolean("blunt");
sticky = ajAcdGetBoolean("sticky");
single = ajAcdGetBoolean("single");
html = ajAcdGetBoolean("html");
alpha = ajAcdGetBoolean("alphabetic");
ambiguity = ajAcdGetBoolean("ambiguity");
plasmid = ajAcdGetBoolean("plasmid");
commercial = ajAcdGetBoolean("commercial");
limit = ajAcdGetBoolean("limit");
frags = ajAcdGetBoolean("fragments");
methyl = ajAcdGetBoolean("methylation");
dfile = ajAcdGetDatafile("datafile");
methfile = ajAcdGetDatafile("mfile");
if(single)
max = min = 1;
table = ajTablestrNew(EQUGUESS);
l = ajListNew();
if(threeprime)
ajStrReverse(&seqcmp);
/* read the local file of enzymes names */
restover_read_file_of_enzyme_names(&enzymes);
if(!dfile)
{
enzfile = ajDatafileNewInNameC(ENZDATA);
if(!enzfile)
ajFatal("Cannot locate enzyme file. Run REBASEEXTRACT");
}
else
{
enzfile = dfile;
}
if(limit)
{
equfile = ajDatafileNewInNameC(EQUDATA);
if(!equfile)
limit=ajFalse;
else
{
restover_read_equiv(equfile,table);
ajFileClose(&equfile);
}
}
while(ajSeqallNext(seqall, &seq))
{
begin = ajSeqallGetseqBegin(seqall);
end = ajSeqallGetseqEnd(seqall);
ajFileSeek(enzfile,0L,0);
ajSeqFmtUpper(seq);
hits = embPatRestrictMatch(seq,begin,end,enzfile,methfile,enzymes,
sitelen,plasmid,ambiguity,min,max,blunt,
sticky,commercial,methyl,l);
ajDebug("hits:%d listlen:%u\n", hits, ajListGetLength(l));
if(hits)
{
name = ajStrNewC(ajSeqGetNameC(seq));
restover_printHits(seq, seqcmp, outf,l,name,hits,begin,end,
min,max,plasmid,
sitelen,limit,table,alpha,frags,
html);
ajStrDel(&name);
}
ajListFree(&l);
}
ajListFree(&l);
ajSeqDel(&seq);
ajFileClose(&outf);
ajFileClose(&dfile);
ajFileClose(&enzfile);
ajFileClose(&equfile);
ajFileClose(&methfile);
ajSeqallDel(&seqall);
ajStrDel(&seqcmp);
ajStrDel(&enzymes);
ajStrDel(&name);
ajTablestrFree(&table);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPSeqall seqall;
AjPSeq seq = NULL;
AjPFile outf = NULL;
ajint begin;
ajint end;
ajuint emin;
ajuint emax;
AjPFile mfile = NULL;
EmbPMatPrints s = NULL;
AjPList l = NULL;
AjPStr strand = NULL;
AjPStr substr = NULL;
AjPStr name = NULL;
AjBool all;
AjBool ordered;
ajint hits;
ajint nmotifs;
embInit("pscan", argc, argv);
seqall = ajAcdGetSeqall("sequence");
outf = ajAcdGetOutfile("outfile");
emin = ajAcdGetInt("emin");
emax = ajAcdGetInt("emax");
substr = ajStrNew();
name = ajStrNew();
all = ordered = ajTrue;
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);
nmotifs = 0;
ajDebug("pscan sequence '%S'\n", ajSeqGetNameS(seq));
embMatPrintsInit(&mfile);
ajDebug("pscan prints file '%F'\n", mfile);
l = ajListNew();
while((s = embMatProtReadInt(mfile)))
{
ajDebug("pscan file '%F' read\n", mfile);
if(s->n >= emin && s->n <= emax)
{
hits=embMatProtScanInt(substr,name,s,&l,&all,&ordered,
1);
if(hits)
++nmotifs;
}
embMatProtDelInt(&s);
}
pscan_print_hits(outf, l, nmotifs, begin);
ajListFree(&l);
ajStrDel(&strand);
ajFileClose(&mfile);
}
ajStrDel(&substr);
ajStrDel(&name);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajFileClose(&outf);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPSeqall seqall;
AjPSeq sequence;
AjPFile outfile;
ajint minLen;
ajint maxLen;
ajint maxGap;
ajint beginPos;
ajint endPos;
ajint maxmismatches;
AjPStr seqstr;
ajint current;
ajint rev;
ajint count;
ajint gap;
ajint begin;
ajint end;
ajint mismatches;
ajint mismatchAtEnd;
ajint istart;
ajint iend;
ajint ic;
ajint ir;
AjBool alln; /* TRUE if all of palindrome is N's */
Palindrome pfirstpal;
Palindrome plastpal = NULL;
Palindrome ppal = NULL;
Palindrome pnext = NULL;
AjBool found = AJFALSE;
embInit("palindrome", argc, argv);
seqall = ajAcdGetSeqall("sequence");
minLen = ajAcdGetInt("minpallen");
maxLen = ajAcdGetInt("maxpallen");
maxGap = ajAcdGetInt("gaplimit");
outfile = ajAcdGetOutfile("outfile");
maxmismatches = ajAcdGetInt("nummismatches");
overlap = ajAcdGetBoolean("overlap");
while(ajSeqallNext(seqall, &sequence))
{
beginPos = ajSeqallGetseqBegin(seqall);
endPos = ajSeqallGetseqEnd(seqall);
/* set to NULL to indicate that we have no first palindrome find yet */
pfirstpal = NULL;
/* write header to file */
ajFmtPrintF(outfile, "Palindromes of: %s \n", ajSeqGetNameC(sequence));
ajFmtPrintF(outfile, "Sequence length is: %d \n", ajSeqGetLen(sequence));
ajFmtPrintF(outfile, "Start at position: %d\nEnd at position: %d\n",
beginPos, endPos);
ajFmtPrintF(outfile,"Minimum length of Palindromes is: %d \n", minLen);
ajFmtPrintF(outfile,"Maximum length of Palindromes is: %d \n", maxLen);
ajFmtPrintF(outfile,"Maximum gap between elements is: %d \n", maxGap);
ajFmtPrintF(outfile,"Number of mismatches allowed in Palindrome: %d\n",
maxmismatches);
ajFmtPrintF(outfile, "\n\n\n");
ajFmtPrintF(outfile, "Palindromes:\n");
/* set vars in readiness to enter loop */
seqstr = ajStrNewC(ajSeqGetSeqC(sequence));
begin = beginPos - 1;
end = endPos - 1;
ajStrFmtLower(&seqstr); /* make comparisons case independent */
/* loop to look for inverted repeats */
for(current = begin; current < end; current++)
{
iend = current + 2*(maxLen) + maxGap;
if(iend > end)
iend = end;
istart = current + minLen;
for(rev = iend; rev > istart; rev--)
{
count = 0;
mismatches = 0;
mismatchAtEnd = 0;
alln = ajTrue;
ic = current;
ir = rev;
if(ajStrGetCharPos(seqstr, ic) ==
ajBaseAlphacharComp(ajStrGetCharPos(seqstr, ir)))
while(mismatches <= maxmismatches && ic < ir)
{
if(ajStrGetCharPos(seqstr, ic++) ==
ajBaseAlphacharComp(ajStrGetCharPos(seqstr, ir--)))
{
mismatchAtEnd = 0;
if(ajStrGetCharPos(seqstr, ic-1) != 'n')
alln = ajFalse;
}
else
{
mismatches++;
mismatchAtEnd++;
}
count++;
}
count -= mismatchAtEnd;
gap = rev - current - count - count + 1;
/* Find out if there's a reverse repeat long enough */
if(count >= minLen && gap <= maxGap && !alln)
{
/* create new struct to hold palindrome data */
ppal = palindrome_New(current,(current+count),rev,
(rev-count));
/*
** if it is the first palindrome find then save it as start
** of palindrome list
*/
if(pfirstpal == NULL)
{
pfirstpal = ppal;
plastpal = ppal;
}
else
{
/* Is it a subset of a palindrome already met */
pnext = pfirstpal;
found = AJFALSE;
while(pnext != NULL)
{
if(overlap && palindrome_AInB(ppal, pnext))
{
found = AJTRUE;
break;
}
if(!overlap && palindrome_AOverB(ppal, pnext))
{
if(palindrome_Longer(ppal, pnext))
{
palindrome_Swap(ppal, pnext);
}
found = AJTRUE;
break;
}
pnext = pnext->next;
}
/* if new palindrome add to end of list */
if(!found)
{
plastpal->next = ppal;
plastpal = ppal;
}
else
AJFREE(ppal);
}
}
}
}
/* Print out palindromes */
ppal = pfirstpal;
while(ppal != NULL)
{
palindrome_Print(outfile, seqstr, ppal, maxLen);
ppal = ppal->next;
}
/* make a gap beween outputs of different sequences */
ajFmtPrintF(outfile, "\n\n\n");
/* free memory used for palindrome list */
ppal = pfirstpal;
while(ppal != NULL)
{
pnext = ppal->next;
AJFREE(ppal);
ppal = pnext;
}
ajStrDel(&seqstr);
}
ajFileClose(&outfile);
ajSeqallDel(&seqall);
ajSeqDel(&sequence);
ajStrDel(&seqstr);
embExit();
return 0;
}
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)
{
AjPSeqset seqset;
AjPSeqall seqall;
AjPSeq queryseq;
const AjPSeq targetseq;
ajint wordlen;
AjPTable wordsTable = NULL;
AjPList* matchlist = NULL;
AjPFile logfile;
AjPFeattable* seqsetftables = NULL;
AjPFeattable seqallseqftable = NULL;
AjPFeattabOut ftoutforseqsetseq = NULL;
AjPFeattabOut ftoutforseqallseq = NULL;
AjPAlign align = NULL;
AjIList iter = NULL;
ajint targetstart;
ajint querystart;
ajint len;
ajuint i, j;
ajulong nAllMatches = 0;
ajulong sumAllScore = 0;
AjBool dumpAlign = ajTrue;
AjBool dumpFeature = ajTrue;
AjBool checkmode = ajFalse;
EmbPWordRK* wordsw = NULL;
ajuint npatterns = 0;
ajuint seqsetsize;
ajuint nmatches;
ajuint* nmatchesseqset;
ajuint* lastlocation; /* Cursors for Rabin-Karp search. */
/* Shows until what point the query sequence was
* scanned for a pattern sequences in the seqset.
*/
char* paddedheader = NULL;
const char* header;
AjPStr padding;
header = "Pattern %S #pat-sequences #all-matches avg-match-length\n";
padding = ajStrNew();
embInit("wordmatch", argc, argv);
wordlen = ajAcdGetInt("wordsize");
seqset = ajAcdGetSeqset("asequence");
seqall = ajAcdGetSeqall("bsequence");
logfile = ajAcdGetOutfile("logfile");
dumpAlign = ajAcdGetToggle("dumpalign");
dumpFeature = ajAcdGetToggle("dumpfeat");
if(dumpAlign)
{
align = ajAcdGetAlign("outfile");
ajAlignSetExternal(align, ajTrue);
}
seqsetsize = ajSeqsetGetSize(seqset);
ajSeqsetTrim(seqset);
AJCNEW0(matchlist, seqsetsize);
AJCNEW0(seqsetftables, seqsetsize);
AJCNEW0(nmatchesseqset, seqsetsize);
if (dumpFeature)
{
ftoutforseqsetseq = ajAcdGetFeatout("aoutfeat");
ftoutforseqallseq = ajAcdGetFeatout("boutfeat");
}
checkmode = !dumpFeature && !dumpAlign;
embWordLength(wordlen);
ajFmtPrintF(logfile, "Small sequence/file for constructing"
" target patterns: %S\n", ajSeqsetGetUsa(seqset));
ajFmtPrintF(logfile, "Large sequence/file to be scanned"
" for patterns: %S\n", ajSeqallGetUsa(seqall));
ajFmtPrintF(logfile, "Number of sequences in the patterns file: %u\n",
seqsetsize);
ajFmtPrintF(logfile, "Pattern/word length: %u\n", wordlen);
for(i=0;i<seqsetsize;i++)
{
targetseq = ajSeqsetGetseqSeq(seqset, i);
embWordGetTable(&wordsTable, targetseq);
}
AJCNEW0(lastlocation, seqsetsize);
if(ajTableGetLength(wordsTable)>0)
{
npatterns = embWordRabinKarpInit(wordsTable,
&wordsw, wordlen, seqset);
ajFmtPrintF(logfile, "Number of patterns/words found: %u\n", npatterns);
while(ajSeqallNext(seqall,&queryseq))
{
for(i=0;i<seqsetsize;i++)
{
lastlocation[i]=0;
if (!checkmode)
matchlist[i] = ajListstrNew();
}
nmatches = embWordRabinKarpSearch(
ajSeqGetSeqS(queryseq), seqset,
(EmbPWordRK const *)wordsw, wordlen, npatterns,
matchlist, lastlocation, checkmode);
nAllMatches += nmatches;
if (checkmode)
continue;
for(i=0;i<seqsetsize;i++)
{
if(ajListGetLength(matchlist[i])>0)
{
iter = ajListIterNewread(matchlist[i]) ;
while(embWordMatchIter(iter, &targetstart, &querystart, &len,
&targetseq))
{
if(dumpAlign)
{
ajAlignDefineSS(align, targetseq, queryseq);
ajAlignSetScoreI(align, len);
/* ungapped alignment means same length
* for both sequences
*/
ajAlignSetSubRange(align, targetstart, 1, len,
ajSeqIsReversed(targetseq),
ajSeqGetLen(targetseq),
querystart, 1, len,
ajSeqIsReversed(queryseq),
ajSeqGetLen(queryseq));
}
}
if(dumpAlign)
{
ajAlignWrite(align);
ajAlignReset(align);
}
if(ajListGetLength(matchlist[i])>0 && dumpFeature)
{
embWordMatchListConvToFeat(matchlist[i],
&seqsetftables[i],
&seqallseqftable,
targetseq, queryseq);
ajFeattableWrite(ftoutforseqallseq, seqallseqftable);
ajFeattableDel(&seqallseqftable);
}
ajListIterDel(&iter);
}
embWordMatchListDelete(&matchlist[i]);
}
}
/* search completed, now report statistics */
for(i=0;i<npatterns;i++)
{
sumAllScore += wordsw[i]->lenMatches;
for(j=0;j<wordsw[i]->nseqs;j++)
nmatchesseqset[wordsw[i]->seqindxs[j]] +=
wordsw[i]->nSeqMatches[j];
}
ajFmtPrintF(logfile, "Number of sequences in the file scanned "
"for patterns: %u\n", ajSeqallGetCount(seqall));
ajFmtPrintF(logfile, "Number of all matches: %Lu"
" (wordmatch finds exact matches only)\n", nAllMatches);
if(nAllMatches>0)
{
ajFmtPrintF(logfile, "Sum of match lengths: %Lu\n", sumAllScore);
ajFmtPrintF(logfile, "Average match length: %.2f\n",
sumAllScore*1.0/nAllMatches);
ajFmtPrintF(logfile, "\nDistribution of the matches among pattern"
" sequences:\n");
ajFmtPrintF(logfile, "-----------------------------------------"
"-----------\n");
for(i=0;i<ajSeqsetGetSize(seqset);i++)
{
if (nmatchesseqset[i]>0)
ajFmtPrintF(logfile, "%-42s: %8u\n",
ajSeqGetNameC(ajSeqsetGetseqSeq(seqset, i)),
nmatchesseqset[i]);
ajFeattableWrite(ftoutforseqsetseq, seqsetftables[i]);
ajFeattableDel(&seqsetftables[i]);
}
ajFmtPrintF(logfile, "\nPattern statistics:\n");
ajFmtPrintF(logfile, "-------------------\n");
if(wordlen>7)
ajStrAppendCountK(&padding, ' ', wordlen-7);
paddedheader = ajFmtString(header,padding);
ajFmtPrintF(logfile, paddedheader);
for(i=0;i<npatterns;i++)
if (wordsw[i]->nMatches>0)
ajFmtPrintF(logfile, "%-7s: %12u %12u %17.2f\n",
wordsw[i]->word->fword, wordsw[i]->nseqs,
wordsw[i]->nMatches,
wordsw[i]->lenMatches*1.0/wordsw[i]->nMatches);
}
}
for(i=0;i<npatterns;i++)
{
for(j=0;j<wordsw[i]->nseqs;j++)
AJFREE(wordsw[i]->locs[j]);
AJFREE(wordsw[i]->locs);
AJFREE(wordsw[i]->seqindxs);
AJFREE(wordsw[i]->nnseqlocs);
AJFREE(wordsw[i]->nSeqMatches);
AJFREE(wordsw[i]);
}
embWordFreeTable(&wordsTable);
AJFREE(wordsw);
AJFREE(matchlist);
AJFREE(lastlocation);
AJFREE(nmatchesseqset);
AJFREE(seqsetftables);
if(dumpAlign)
{
ajAlignClose(align);
ajAlignDel(&align);
}
if(dumpFeature)
{
ajFeattabOutDel(&ftoutforseqsetseq);
ajFeattabOutDel(&ftoutforseqallseq);
}
ajFileClose(&logfile);
ajSeqallDel(&seqall);
ajSeqsetDel(&seqset);
ajSeqDel(&queryseq);
ajStrDel(&padding);
AJFREE(paddedheader);
embExit();
return 0;
}
int main(ajint argc, char **argv)
{
AjPFile datafile;
AjPFile outf = NULL;
AjPSeqall seqall;
AjPSeq ajseq = NULL;
ajuint i;
ajint verb;
ajint window;
ajint pt;
ajint which;
ajint weighted;
ajint t = 0;
ajint tc = 0;
ajint mode;
ajint min_seg;
const AjPStr seqdes;
float min_P;
struct hept_pref *h;
embInit("newcoils",argc,argv);
window = ajAcdGetInt("window");
weighted = ajAcdGetInt("weighted");
verb = ajAcdGetInt("verb");
mode = ajAcdGetInt("mode");
min_P = ajAcdGetFloat("minp");
min_seg = ajAcdGetInt("minseg");
outf = ajAcdGetOutfile("outfile");
datafile = ajAcdGetDatafile("datafile");
seqall = ajAcdGetSeqall("sequence");
ajseq = ajSeqNew();
h = newcoils_read_matrix(datafile);
if(verb)
{
for(i=0; i<strlen(NCAAs); ++i)
if(NCAAs[i] != '_')
{
pt = (int)(NCAAs[i]-'A');
ajFmtPrintF(outf,"AA %c %4.2f %4.2f %4.2f %4.2f %4.2f %4.2f "
"%4.2f\n",NCAAs[i],h->m[pt][0],h->m[pt][1],
h->m[pt][2],h->m[pt][3],h->m[pt][4],
h->m[pt][5],h->m[pt][6]);
}
for(i=0; i<(ajuint)h->n; ++i)
ajFmtPrintF(outf,"Window %4d %1d %f %f %f %f %f\n",h->f[i].win,
h->f[i].w,h->f[i].m_cc,h->f[i].sd_cc,h->f[i].m_g,
h->f[i].sd_g,h->f[i].sc);
}
/* See if there is a file for the chosen window length/weight scheme */
which = -1;
for(i=0; i<(ajuint)h->n; ++i)
{
if((h->f[i].win == window) && (h->f[i].w == weighted))
{ /* match */
if(verb)
ajFmtPrintF(outf,"Found fitting data for win %4d w %d\n",
window,weighted);
which = i;
}
}
while(ajSeqallNext(seqall, &ajseq))
{
seqdes = ajSeqGetDescS(ajseq);
newcoils_pred_coils(outf,ajSeqGetSeqC(ajseq),ajSeqGetNameC(ajseq),
seqdes,h,window,
which,weighted,mode,min_P,&t,&tc,min_seg);
}
if (outf)
ajFileClose(&outf);
ajSeqDel(&ajseq);
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;
}
static void primersearch_scan_seq(const Primer primdata,
const AjPSeq seq, AjBool reverse)
{
AjPStr seqstr = NULL;
AjPStr revstr = NULL;
AjPStr seqname = NULL;
ajuint fhits = 0;
ajuint rhits = 0;
AjPList fhits_list = NULL;
AjPList rhits_list = NULL;
/* initialise variables for search */
ajStrAssignC(&seqname,ajSeqGetNameC(seq));
ajStrAssignS(&seqstr, ajSeqGetSeqS(seq));
ajStrAssignS(&revstr, ajSeqGetSeqS(seq));
ajStrFmtUpper(&seqstr);
ajStrFmtUpper(&revstr);
ajSeqstrReverse(&revstr);
fhits_list = ajListNew();
rhits_list = ajListNew();
if(!reverse)
{
/* test OligoA against forward sequence, and OligoB against reverse */
embPatFuzzSearch(primdata->forward->type,
ajSeqGetBegin(seq),
primdata->forward->patstr,
seqname,
seqstr,
fhits_list,
primdata->forward->len,
primdata->forward->mm,
primdata->forward->amino,
primdata->forward->carboxyl,
primdata->forward->buf,
primdata->forward->off,
primdata->forward->sotable,
primdata->forward->solimit,
primdata->forward->re,
primdata->forward->skipm,
&fhits,
primdata->forward->real_len,
&(primdata->forward->tidy));
if(fhits)
embPatFuzzSearch(primdata->reverse->type,
ajSeqGetBegin(seq),
primdata->reverse->patstr,
seqname,
revstr,
rhits_list,
primdata->reverse->len,
primdata->reverse->mm,
primdata->reverse->amino,
primdata->reverse->carboxyl,
primdata->reverse->buf,
primdata->reverse->off,
primdata->reverse->sotable,
primdata->reverse->solimit,
primdata->reverse->re,
primdata->reverse->skipm,
&rhits,
primdata->reverse->real_len,
&(primdata->reverse->tidy));
}
else
{
/*test OligoB against forward sequence, and OligoA against reverse */
embPatFuzzSearch(primdata->reverse->type,
ajSeqGetBegin(seq),
primdata->reverse->patstr,
seqname,
seqstr,
fhits_list,
primdata->reverse->len,
primdata->reverse->mm,
primdata->reverse->amino,
primdata->reverse->carboxyl,
primdata->reverse->buf,
primdata->reverse->off,
primdata->reverse->sotable,
primdata->reverse->solimit,
primdata->reverse->re,
primdata->reverse->skipm,
&fhits,
primdata->reverse->real_len,
&(primdata->reverse->tidy));
if(fhits)
embPatFuzzSearch(primdata->forward->type,
ajSeqGetBegin(seq),
primdata->forward->patstr,
seqname,
revstr,
rhits_list,
primdata->forward->len,
primdata->forward->mm,
primdata->forward->amino,
primdata->forward->carboxyl,
primdata->forward->buf,
primdata->forward->off,
primdata->forward->sotable,
primdata->forward->solimit,
primdata->forward->re,
primdata->forward->skipm,
&rhits,
primdata->forward->real_len,
&(primdata->forward->tidy));
}
if(fhits && rhits)
/* get amplimer length(s) and write out the hit */
primersearch_store_hits(primdata, fhits_list, rhits_list,
seq, reverse);
/* tidy up */
primersearch_clean_hitlist(&fhits_list);
primersearch_clean_hitlist(&rhits_list);
ajStrDel(&seqstr);
ajStrDel(&revstr);
ajStrDel(&seqname);
return;
}
int main(int argc, char **argv)
{
AjPFile outf = NULL;
AjPSeq sequence = NULL;
AjPStr substr = NULL;
AjPStr seqstr = NULL;
AjPStr revstr = NULL;
AjPStr p1;
AjPStr p2;
PPrimer eric = NULL;
PPrimer fred = NULL;
PPrimer f;
PPrimer r;
PPair pair;
AjPList forlist = NULL;
AjPList revlist = NULL;
AjPList pairlist = NULL;
AjBool targetrange;
AjBool isDNA = ajTrue;
AjBool dolist = ajFalse;
ajint primerlen = 0;
ajint minprimerlen = 0;
ajint maxprimerlen = 0;
ajint minprodlen = 0;
ajint maxprodlen = 0;
ajint prodlen = 0;
ajint seqlen = 0;
ajint stepping_value = 1;
ajint targetstart = 0;
ajint targetend = 0;
ajint limit = 0;
ajint limit2 = 0;
ajint lastpos = 0;
ajint startpos = 0;
ajint endpos = 0;
ajint begin;
ajint end;
ajint v1;
ajint v2;
ajint overlap;
float minpmGCcont = 0.;
float maxpmGCcont = 0.;
float minprodGCcont = 0.;
float maxprodGCcont = 0.;
float prodTm;
float prodGC;
ajint i;
ajint j;
ajint neric=0;
ajint nfred=0;
ajint npair=0;
float minprimerTm = 0.0;
float maxprimerTm = 0.0;
float saltconc = 0.0;
float dnaconc = 0.0;
embInit ("prima", argc, argv);
substr = ajStrNew();
forlist = ajListNew();
revlist = ajListNew();
pairlist = ajListNew();
p1 = ajStrNew();
p2 = ajStrNew();
sequence = ajAcdGetSeq("sequence");
outf = ajAcdGetOutfile("outfile");
minprimerlen = ajAcdGetInt("minprimerlen");
maxprimerlen = ajAcdGetInt("maxprimerlen");
minpmGCcont = ajAcdGetFloat("minpmGCcont");
maxpmGCcont = ajAcdGetFloat("maxpmGCcont");
minprimerTm = ajAcdGetFloat("mintmprimer");
maxprimerTm = ajAcdGetFloat("maxtmprimer");
minprodlen = ajAcdGetInt("minplen");
maxprodlen = ajAcdGetInt("maxplen");
minprodGCcont = ajAcdGetFloat("minpgccont");
maxprodGCcont = ajAcdGetFloat("maxpgccont");
saltconc = ajAcdGetFloat("saltconc");
dnaconc = ajAcdGetFloat("dnaconc");
targetrange = ajAcdGetToggle("targetrange");
targetstart = ajAcdGetInt("targetstart");
targetend = ajAcdGetInt("targetend");
overlap = ajAcdGetInt("overlap");
dolist = ajAcdGetBoolean("list");
seqstr = ajSeqGetSeqCopyS(sequence);
ajStrFmtUpper(&seqstr);
begin = ajSeqGetBegin(sequence);
end = ajSeqGetEnd(sequence);
seqlen = end-begin+1;
ajStrAssignSubC(&substr,ajStrGetPtr(seqstr),begin-1,end-1);
revstr = ajStrNewC(ajStrGetPtr(substr));
ajSeqstrReverse(&revstr);
AJCNEW0(entropy, seqlen);
AJCNEW0(enthalpy, seqlen);
AJCNEW0(energy, seqlen);
/* Initialise Tm calculation arrays */
ajMeltTempSave(ajStrGetPtr(substr),0,seqlen,saltconc,dnaconc,1,
&entropy, &enthalpy, &energy);
ajFmtPrintF(outf, "\n\nINPUT SUMMARY\n");
ajFmtPrintF(outf, "*************\n\n");
if(targetrange)
ajFmtPrintF
(outf, "Prima of %s from positions %d to %d bps\n",
ajSeqGetNameC(sequence),targetstart, targetend);
else
ajFmtPrintF(outf, "Prima of %s\n", ajSeqGetNameC(sequence));
ajFmtPrintF(outf, "PRIMER CONSTRAINTS:\n");
ajFmtPrintF
(outf, "PRIMA DOES NOT ALLOW PRIMER SEQUENCE AMBIGUITY OR ");
ajFmtPrintF(outf,"DUPLICATE PRIMER ENDPOINTS\n");
ajFmtPrintF(outf,
"Primer size range is %d-%d\n",minprimerlen,maxprimerlen);
ajFmtPrintF(outf,
"Primer GC content range is %.2f-%.2f\n",minpmGCcont,
maxpmGCcont);
ajFmtPrintF(outf,"Primer melting Temp range is %.2f - %.2f C\n",
minprimerTm, maxprimerTm);
ajFmtPrintF (outf, "PRODUCT CONSTRAINTS:\n");
ajFmtPrintF(outf,"Product GC content range is %.2f-%.2f\n",
minprodGCcont, maxprodGCcont);
ajFmtPrintF(outf, "Salt concentration is %.2f (mM)\n", saltconc);
ajFmtPrintF(outf, "DNA concentration is %.2f (nM)\n", dnaconc);
if(targetrange)
ajFmtPrintF(outf, "Targeted range to amplify is from %d to %d\n",
targetstart,targetend);
else
{
ajFmtPrintF(outf,"Considering all suitable Primer pairs with ");
ajFmtPrintF(outf,"Product length ranges %d to %d\n\n\n", minprodlen,
maxprodlen);
}
ajFmtPrintF(outf, "\n\nPRIMER/PRODUCT PAIR CALCULATIONS & OUTPUT\n");
ajFmtPrintF(outf, "*****************************************\n\n");
if(seqlen-minprimerlen < 0)
ajFatal("Sequence too short");
if(targetrange)
{
ajStrAssignSubC(&p1,ajStrGetPtr(substr),targetstart-begin,targetend-begin);
prodGC = ajMeltGC(substr,seqlen);
prodTm = ajMeltTempProd(prodGC,saltconc,seqlen);
if(prodGC<minprodGCcont || prodGC>maxprodGCcont)
{
ajFmtPrintF(outf,
"Product GC content [%.2f] outside acceptable range\n",
prodGC);
embExitBad();
return 0;
}
prima_testtarget(substr, revstr, targetstart-begin, targetend-begin,
minprimerlen, maxprimerlen,
seqlen, minprimerTm, maxprimerTm, minpmGCcont,
maxpmGCcont, minprodGCcont, maxprodGCcont, saltconc,
dnaconc, pairlist, &npair);
}
if(!targetrange)
{
limit = seqlen-minprimerlen-minprodlen+1;
lastpos = seqlen-minprodlen;
limit2 = maxprodlen-minprodlen;
/* Outer loop selects all possible product start points */
for(i=minprimerlen; i<limit; ++i)
{
startpos = i;
ajDebug("Position in sequence %d\n",startpos);
endpos = i+minprodlen-1;
/* Inner loop selects all possible product lengths */
for(j=0; j<limit2; ++j, ++endpos)
{
if(endpos>lastpos)
break;
v1 = endpos-startpos+1;
ajStrAssignSubC(&p1,ajStrGetPtr(substr),startpos,endpos);
prodGC = ajMeltGC(p1,v1);
prodTm = ajMeltTempProd(prodGC,saltconc,v1);
if(prodGC<minprodGCcont || prodGC>maxprodGCcont)
continue;
/* Only accept primers with acceptable Tm and GC */
neric = 0;
nfred = 0;
prima_testproduct(substr, startpos, endpos, primerlen,
minprimerlen, maxprimerlen,minpmGCcont,
maxpmGCcont, minprimerTm, maxprimerTm,
minprodlen, maxprodlen, prodTm, prodGC, seqlen,
&eric,&fred,forlist,revlist,&neric,&nfred,
stepping_value, saltconc,dnaconc, isDNA, begin);
if(!neric)
continue;
/* Now reject those primers with self-complementarity */
prima_reject_self(forlist,revlist,&neric,&nfred);
if(!neric)
continue;
/* Reject any primers that could bind elsewhere in the
sequence */
prima_test_multi(forlist,revlist,&neric,&nfred,substr,revstr,
seqlen);
/* Now select the least complementary pair (if any) */
prima_best_primer(forlist, revlist, &neric, &nfred);
if(!neric)
continue;
AJNEW(pair);
ajListPop(forlist,(void **)&f);
ajListPop(revlist,(void **)&r);
pair->f = f;
pair->r = r;
++npair;
ajListPush(pairlist,(void *)pair);
}
}
}
if(!targetrange)
{
/* Get rid of primer pairs nearby the top scoring ones */
prima_TwoSortscorepos(&pairlist);
prima_prune_nearby(pairlist, &npair, maxprimerlen-1);
ajListSort(pairlist,prima_PosCompare);
prima_check_overlap(pairlist,&npair,overlap);
}
if(npair)
{
if(!targetrange)
ajFmtPrintF(outf,"%d pairs found\n\n",npair);
else
ajFmtPrintF(outf,
"Closest primer pair to specified product is:\n\n");
if((maxprimerlen<26 && seqlen<999999 && !dolist))
ajFmtPrintF(outf,"\n\t\tForward\t\t\t\t\tReverse\n\n");
}
for(i=0;i<npair;++i)
{
if(!targetrange)
ajFmtPrintF(outf,"[%d]\n",i+1);
ajListPop(pairlist,(void **)&pair);
prodlen = pair->r->start - (pair->f->start + pair->f->primerlen);
if((maxprimerlen<26 && seqlen<999999 && !dolist))
{
v1 = pair->f->start;
v2 = v1 + pair->f->primerlen -1;
ajStrAssignSubS(&p1,substr,v1,v2);
ajFmtPrintF(outf,"%6d %-25.25s %d\t", v1+begin, ajStrGetPtr(p1),
v2+begin);
v1 = pair->r->start;
v2 = v1 + pair->r->primerlen -1;
ajStrAssignSubS(&p2,substr,v1,v2);
ajSeqstrReverse(&p2);
ajFmtPrintF(outf,
"%6d %-25.25s %d\n", v1+begin, ajStrGetPtr(p2), v2+begin);
ajFmtPrintF(outf," Tm %.2f C (GC %.2f%%)\t\t ",
pair->f->primerTm,pair->f->primGCcont*100.);
ajFmtPrintF(outf,"Tm %.2f C (GC %.2f%%)\n",
pair->r->primerTm,pair->r->primGCcont*100.);
ajFmtPrintF(outf," Length: %-32dLength: %d\n",
pair->f->primerlen,pair->r->primerlen);
ajFmtPrintF(outf," Tma: %.2f C\t\t\t",
ajAnneal(pair->f->primerTm,pair->f->prodTm));
ajFmtPrintF(outf," Tma: %.2f C\n\n\n",
ajAnneal(pair->r->primerTm,pair->f->prodTm));
ajFmtPrintF(outf," Product GC: %.2f%%\n",
pair->f->prodGC * 100.0);
ajFmtPrintF(outf," Product Tm: %.2f C\n",
pair->f->prodTm);
ajFmtPrintF(outf," Length: %d\n\n\n",prodlen);
}
else
{
ajFmtPrintF(outf," Product from %d to %d\n",pair->f->start+
pair->f->primerlen+begin,pair->r->start-1+begin);
ajFmtPrintF(outf," Tm: %.2f C GC: %.2f%%\n",
pair->f->prodTm,pair->f->prodGC*(float)100.);
ajFmtPrintF(outf," Length: %d\n\n\n",prodlen);
v1 = pair->f->start;
v2 = v1 + pair->f->primerlen -1;
ajStrAssignSubS(&p1,substr,v1,v2);
ajFmtPrintF(outf," Forward: 5' %s 3'\n",ajStrGetPtr(p1));
ajFmtPrintF(outf," Start: %d\n",v1+begin);
ajFmtPrintF(outf," End: %d\n",v2+begin);
ajFmtPrintF(outf," Tm: %.2f C\n",
pair->f->primerTm);
ajFmtPrintF(outf," GC: %.2f%%\n",
pair->f->primGCcont*(float)100.);
ajFmtPrintF(outf," Len: %d\n",
pair->f->primerlen);
ajFmtPrintF(outf," Tma: %.2f C\n\n\n",
ajAnneal(pair->f->primerTm,pair->f->prodTm));
v1 = pair->r->start;
v2 = v1 + pair->r->primerlen -1;
ajStrAssignSubS(&p2,substr,v1,v2);
ajSeqstrReverse(&p2);
ajStrAssignSubS(&p1,substr,v1,v2);
ajFmtPrintF(outf," Reverse: 5' %s 3'\n",ajStrGetPtr(p1));
ajFmtPrintF(outf," Start: %d\n",v1+begin);
ajFmtPrintF(outf," End: %d\n",v2+begin);
ajFmtPrintF(outf," Tm: %.2f C\n",
pair->r->primerTm);
ajFmtPrintF(outf," GC: %.2f%%\n",
pair->r->primGCcont*(float)100.);
ajFmtPrintF(outf," Len: %d\n",
pair->r->primerlen);
ajFmtPrintF(outf," Tma: %.2f C\n\n\n",
ajAnneal(pair->r->primerTm,pair->f->prodTm));
}
prima_PrimerDel(&pair->f);
prima_PrimerDel(&pair->r);
AJFREE(pair);
}
ajStrDel(&seqstr);
ajStrDel(&revstr);
ajStrDel(&substr);
ajStrDel(&p1);
ajStrDel(&p2);
ajListFree(&forlist);
ajListFree(&revlist);
ajListFree(&pairlist);
ajFileClose(&outf);
ajSeqDel(&sequence);
AJFREE(entropy);
AJFREE(enthalpy);
AJFREE(energy);
embExit();
return 0;
}
static void primersearch_store_hits(const Primer primdata,
AjPList fhits, AjPList rhits,
const AjPSeq seq, AjBool reverse)
{
ajint amplen = 0;
AjIList fi;
AjIList ri;
PHit primerhit = NULL;
fi = ajListIterNewread(fhits);
while(!ajListIterDone(fi))
{
EmbPMatMatch fm = NULL;
EmbPMatMatch rm = NULL;
amplen = 0;
fm = ajListIterGet(fi);
ri = ajListIterNewread(rhits);
while(!ajListIterDone(ri))
{
ajint seqlen = ajSeqGetLen(seq);
ajint s = (fm->start);
ajint e;
rm = ajListIterGet(ri);
e = (rm->start-1);
amplen = seqlen-(s-1)-e;
if (amplen > 0) /* no point making a hit if -ve length! */
{
primerhit = NULL;
AJNEW(primerhit);
primerhit->desc=NULL; /* must be NULL for ajStrAss */
primerhit->seqname=NULL; /* must be NULL for ajStrAss */
primerhit->acc=NULL;
primerhit->forward=NULL;
primerhit->reverse=NULL;
ajStrAssignC(&primerhit->seqname,ajSeqGetNameC(seq));
ajStrAssignS(&primerhit->desc, ajSeqGetDescS(seq));
ajStrAssignS(&primerhit->acc, ajSeqGetAccS(seq));
primerhit->forward_pos = fm->start;
primerhit->reverse_pos = rm->start;
primerhit->forward_mismatch = fm->mm;
primerhit->reverse_mismatch = rm->mm;
primerhit->amplen = amplen;
if(!reverse)
{
ajStrAssignS(&primerhit->forward,
primdata->forward->patstr);
ajStrAssignS(&primerhit->reverse,
primdata->reverse->patstr);
}
else
{
ajStrAssignS(&primerhit->forward,
primdata->reverse->patstr);
ajStrAssignS(&primerhit->reverse,
primdata->forward->patstr);
}
ajListPushAppend(primdata->hitlist, primerhit);
}
}
/*
** clean up rListIter here as it will be new'ed again next
** time through
*/
ajListIterDel(&ri);
}
ajListIterDel(&fi);
return;
}
int main(int argc, char **argv)
{
AjPSeqset seqset;
const AjPSeq seq1;
const AjPSeq seq2;
ajint wordlen;
AjPTable seq1MatchTable = NULL;
AjPList matchlist ;
AjPGraph graph = 0;
ajuint i;
ajuint j;
float total=0;
ajuint acceptableticks[]=
{
1,10,50,100,200,500,1000,1500,10000,50000,
100000,500000,1000000,5000000
};
ajint numbofticks = 10;
ajint gap,tickgap;
AjBool boxit = AJTRUE;
AjBool dumpfeat = AJFALSE;
float xmargin;
float ymargin;
float k;
char ptr[10];
float ticklen;
float onefifth;
AjPFeattable *tabptr = NULL;
AjPFeattabOut seq1out = NULL;
AjPStr sajb = NULL;
float flen1;
float flen2;
ajuint tui;
embInit("polydot", argc, argv);
wordlen = ajAcdGetInt("wordsize");
seqset = ajAcdGetSeqset("sequences");
graph = ajAcdGetGraph("graph");
gap = ajAcdGetInt("gap");
boxit = ajAcdGetBoolean("boxit");
seq1out = ajAcdGetFeatout("outfeat");
dumpfeat = ajAcdGetToggle("dumpfeat");
sajb = ajStrNew();
embWordLength(wordlen);
AJCNEW(lines,ajSeqsetGetSize(seqset));
AJCNEW(pts,ajSeqsetGetSize(seqset));
AJCNEW(tabptr,ajSeqsetGetSize(seqset));
for(i=0;i<ajSeqsetGetSize(seqset);i++)
{
seq1 = ajSeqsetGetseqSeq(seqset, i);
total += ajSeqGetLen(seq1);
}
total +=(float)(gap*(ajSeqsetGetSize(seqset)-1));
xmargin = total*(float)0.15;
ymargin = total*(float)0.15;
ticklen = xmargin*(float)0.1;
onefifth = xmargin*(float)0.2;
i = 0;
while(acceptableticks[i]*numbofticks < ajSeqsetGetLen(seqset))
i++;
if(i<=13)
tickgap = acceptableticks[i];
else
tickgap = acceptableticks[13];
ajGraphAppendTitleS(graph, ajSeqsetGetUsa(seqset));
ajGraphOpenWin(graph, (float)0.0-xmargin,(total+xmargin)*(float)1.35,
(float)0.0-ymargin,
total+ymargin);
ajGraphicsSetCharscale((float)0.3);
for(i=0;i<ajSeqsetGetSize(seqset);i++)
{
which = i;
seq1 = ajSeqsetGetseqSeq(seqset, i);
tui = ajSeqGetLen(seq1);
flen1 = (float) tui;
if(embWordGetTable(&seq1MatchTable, seq1)){ /* get table of words */
for(j=0;j<ajSeqsetGetSize(seqset);j++)
{
seq2 = ajSeqsetGetseqSeq(seqset, j);
tui = ajSeqGetLen(seq2);
flen2 = (float) tui;
if(boxit)
ajGraphicsDrawposRect(xstart,ystart,
xstart+flen1,
ystart+flen2);
matchlist = embWordBuildMatchTable(seq1MatchTable, seq2,
ajTrue);
if(matchlist)
polydot_plotMatches(matchlist);
if(i<j && dumpfeat)
embWordMatchListConvToFeat(matchlist,&tabptr[i],
&tabptr[j],seq1,
seq2);
if(matchlist) /* free the match structures */
embWordMatchListDelete(&matchlist);
if(j==0)
{
for(k=0.0;k<ajSeqGetLen(seq1);k+=tickgap)
{
ajGraphicsDrawposLine(xstart+k,ystart,xstart+k,
ystart-ticklen);
sprintf(ptr,"%d",(ajint)k);
ajGraphicsDrawposTextAtmid(xstart+k,
ystart-(onefifth),
ptr);
}
ajGraphicsDrawposTextAtmid(
xstart+(flen1/(float)2.0),
ystart-(3*onefifth),
ajStrGetPtr(ajSeqsetGetseqNameS(seqset, i)));
}
if(i==0)
{
for(k=0.0;k<ajSeqGetLen(seq2);k+=tickgap)
{
ajGraphicsDrawposLine(xstart,ystart+k,xstart-ticklen,
ystart+k);
sprintf(ptr,"%d",(ajint)k);
ajGraphicsDrawposTextAtend(xstart-(onefifth),
ystart+k,
ptr);
}
ajGraphicsDrawposTextAtlineJustify(
xstart-(3*onefifth),
ystart+(flen2/(float)2.0),
xstart-(3*onefifth),ystart+flen2,
ajStrGetPtr(ajSeqsetGetseqNameS(seqset, j)),0.5);
}
ystart += flen2+(float)gap;
}
}
embWordFreeTable(&seq1MatchTable);
seq1MatchTable = NULL;
xstart += flen1+(float)gap;
ystart = 0.0;
}
ajGraphicsDrawposTextAtstart(total+onefifth,total-(onefifth),
"No. Length Lines Points Sequence");
for(i=0;i<ajSeqsetGetSize(seqset);i++)
{
seq1 = ajSeqsetGetseqSeq(seqset, i);
ajFmtPrintS(&sajb,"%3u %6d %5d %6d %s",i+1,
ajSeqGetLen(seq1),lines[i],
pts[i],ajSeqGetNameC(seq1));
ajGraphicsDrawposTextAtstart(total+onefifth,total-(onefifth*(i+2)),
ajStrGetPtr(sajb));
}
if(dumpfeat && seq1out)
{
for(i=0;i<ajSeqsetGetSize(seqset);i++)
{
ajFeattableWrite(seq1out, tabptr[i]);
ajFeattableDel(&tabptr[i]);
}
}
ajGraphicsClose();
ajGraphxyDel(&graph);
ajStrDel(&sajb);
AJFREE(lines);
AJFREE(pts);
AJFREE(tabptr);
ajSeqsetDel(&seqset);
ajFeattabOutDel(&seq1out);;
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 void stssearch_primTest(void **x,void *cl)
{
Primer* p;
Primer primdata;
AjBool testa;
AjBool testb;
AjBool testc;
AjBool testd;
ajint ioff;
(void) cl; /* make it used */
p = (Primer*) x;
primdata = *p;
ntests++;
if(!(ntests % 1000))
ajDebug("completed tests: %d\n", ntests);
testa = ajRegExec(primdata->Prima, seqstr);
if(testa)
{
ioff = ajRegOffset(primdata->Prima);
ajDebug("%s: %S PrimerA matched at %d\n",
ajSeqGetNameC(seq), primdata->Name, ioff);
ajFmtPrintF(out, "%s: %S PrimerA matched at %d\n",
ajSeqGetNameC(seq), primdata->Name, ioff);
ajRegTrace(primdata->Prima);
}
testb = ajRegExec(primdata->Primb, seqstr);
if(testb)
{
ioff = ajRegOffset(primdata->Primb);
ajDebug("%s: %S PrimerB matched at %d\n",
ajSeqGetNameC(seq), primdata->Name, ioff);
ajFmtPrintF(out, "%s: %S PrimerB matched at %d\n",
ajSeqGetNameC(seq), primdata->Name, ioff);
ajRegTrace(primdata->Primb);
}
testc = ajRegExec(primdata->Prima, revstr);
if(testc)
{
ioff = ajStrGetLen(seqstr) - ajRegOffset(primdata->Prima);
ajDebug("%s: (rev) %S PrimerA matched at %d\n",
ajSeqGetNameC(seq), primdata->Name, ioff);
ajFmtPrintF(out, "%s: (rev) %S PrimerA matched at %d\n",
ajSeqGetNameC(seq), primdata->Name, ioff);
ajRegTrace(primdata->Prima);
}
testd = ajRegExec(primdata->Primb, revstr);
if(testd)
{
ioff = ajStrGetLen(seqstr) - ajRegOffset(primdata->Primb);
ajDebug("%s: (rev) %S PrimerB matched at %d\n",
ajSeqGetNameC(seq), primdata->Name, ioff);
ajFmtPrintF(out, "%s: (rev) %S PrimerB matched at %d\n",
ajSeqGetNameC(seq), primdata->Name, ioff);
ajRegTrace(primdata->Primb);
}
return;
}
int main(int argc, char **argv)
{
AjPSeqall seqall;
AjPSeq seq = NULL;
AjPReport outf = NULL;
AjPFile inf = NULL;
ajint begin;
ajint end;
AjPList l = NULL;
AjPStr strand = NULL;
AjPStr substr = NULL;
AjPStr line = NULL;
AjPStr name = NULL;
AjPStr acc = NULL;
AjPStr bf = NULL;
AjPStr menu;
AjPStr pattern = NULL;
AjPStr opattern = NULL;
AjPStr pname = NULL;
AjPStr key = NULL;
AjPStr value = NULL;
AjPTable atable = NULL;
AjPTable btable = NULL;
ajint mismatch;
ajint minlength;
ajint sum;
ajint v;
char cp;
const char *p;
embInit("tfscan", argc, argv);
seqall = ajAcdGetSeqall("sequence");
outf = ajAcdGetReport("outfile");
mismatch = ajAcdGetInt("mismatch");
minlength = ajAcdGetInt("minlength");
menu = ajAcdGetListSingle("menu");
pname = ajStrNew();
cp=ajStrGetCharFirst(menu);
if(cp=='F')
ajStrAssignC(&pname,"tffungi");
else if(cp=='I')
ajStrAssignC(&pname,"tfinsect");
else if(cp=='O')
ajStrAssignC(&pname,"tfother");
else if(cp=='P')
ajStrAssignC(&pname,"tfplant");
else if(cp=='V')
ajStrAssignC(&pname,"tfvertebrate");
else if(cp=='C')
inf = ajAcdGetDatafile("custom");
if(cp!='C')
{
inf = ajDatafileNewInNameS(pname);
if(!inf)
ajFatal("Either EMBOSS_DATA undefined or TFEXTRACT needs running");
}
name = ajStrNew();
acc = ajStrNew();
bf = ajStrNewC("");
substr = ajStrNew();
line = ajStrNew();
pattern = ajStrNewC("AA");
opattern = ajStrNew();
while(ajSeqallNext(seqall, &seq))
{
begin=ajSeqallGetseqBegin(seqall);
end=ajSeqallGetseqEnd(seqall);
ajStrAssignC(&name,ajSeqGetNameC(seq));
strand=ajSeqGetSeqCopyS(seq);
ajStrAssignSubC(&substr,ajStrGetPtr(strand),begin-1,end-1);
ajStrFmtUpper(&substr);
l=ajListNew();
atable = ajTablestrNew(1000);
btable = ajTablestrNew(1000);
sum=0;
while(ajReadlineTrim(inf,&line))
{
p = ajStrGetPtr(line);
if(!*p || *p=='#' || *p=='\n' || *p=='!')
continue;
ajFmtScanS(line,"%S%S%S",&pname,&pattern,&acc);
p += ajStrGetLen(pname);
while(*p && *p==' ')
++p;
p += ajStrGetLen(pattern);
while(*p && *p==' ')
++p;
p += ajStrGetLen(acc);
while(*p && *p==' ')
++p;
ajStrAssignS(&opattern,pattern);
ajStrAssignC(&bf,p); /* rest of line */
v = embPatVariablePattern(pattern,substr,pname,l,0,
mismatch,begin);
if(v)
{
key = ajStrNewS(pname);
value = ajStrNewS(acc);
ajTablePut(atable,(void *)key,(void *)value);
key = ajStrNewS(pname);
value = ajStrNewS(bf);
ajTablePut(btable,(void *)key,(void *)value);
}
sum += v;
}
if(sum)
tfscan_print_hits(&l,sum,outf,atable,seq,minlength,
btable);
ajFileSeek(inf,0L,0);
ajListFree(&l);
ajTablestrFree(&atable);
ajTablestrFree(&btable);
ajStrDel(&strand);
}
ajStrDel(&line);
ajStrDel(&name);
ajStrDel(&acc);
ajStrDel(&pname);
ajStrDel(&opattern);
ajStrDel(&bf);
ajStrDel(&pattern);
ajStrDel(&substr);
ajSeqDel(&seq);
ajFileClose(&inf);
ajReportClose(outf);
ajReportDel(&outf);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&menu);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPSeqall seqall;
AjPFile primfile;
AjPStr rdline = NULL;
Primer primdata;
AjPStrTok handle = NULL;
AjPList primList = NULL;
embInit("stssearch", argc, argv);
primfile = ajAcdGetInfile("infile");
out = ajAcdGetOutfile("outfile");
seqall = ajAcdGetSeqall("seqall");
while(ajReadlineTrim(primfile, &rdline))
{
if(ajStrGetCharFirst(rdline) == '#')
continue;
if(ajStrSuffixC(rdline, ".."))
continue;
AJNEW(primdata);
primdata->Name = NULL;
primdata->Oligoa = NULL;
primdata->Oligob = NULL;
handle = ajStrTokenNewC(rdline, " \t");
ajStrTokenNextParse(&handle, &primdata->Name);
if(!(nprimers % 1000))
ajDebug("Name [%d]: '%S'\n", nprimers, primdata->Name);
ajStrTokenNextParse(&handle, &primdata->Oligoa);
ajStrFmtUpper(&primdata->Oligoa);
primdata->Prima = ajRegComp(primdata->Oligoa);
ajStrTokenNextParse(&handle, &primdata->Oligob);
ajStrFmtUpper(&primdata->Oligob);
primdata->Primb = ajRegComp(primdata->Oligob);
ajStrTokenDel(&handle);
if(!nprimers)
primList = ajListNew();
ajListPushAppend(primList, primdata);
nprimers++;
}
if(!nprimers)
ajFatal("No primers read\n");
ajDebug("%d primers read\n", nprimers);
while(ajSeqallNext(seqall, &seq))
{
ajSeqFmtUpper(seq);
ajStrAssignS(&seqstr, ajSeqGetSeqS(seq));
ajStrAssignS(&revstr, ajSeqGetSeqS(seq));
ajSeqstrReverse(&revstr);
ajDebug("Testing: %s\n", ajSeqGetNameC(seq));
ntests = 0;
ajListMap(primList, stssearch_primTest, NULL);
}
ajFileClose(&out);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajFileClose(&out);
ajStrDel(&revstr);
ajStrDel(&seqstr);
ajFileClose(&primfile);
ajListMap(primList, stssearch_primDel, NULL);
ajListFree(&primList);
ajStrDel(&rdline);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPSeqall seqall;
AjPSeq seq = NULL;
AjPFile outf = NULL;
AjPStr strand = NULL;
AjPStr substr = NULL;
AjPStr bases = NULL;
ajint begin;
ajint end;
ajint len;
ajint minlen;
float minobsexp;
float minpc;
ajint window;
ajint shift;
ajint plotstart;
ajint plotend;
float *xypc = NULL;
float *obsexp = NULL;
AjBool *thresh = NULL;
float obsexpmax;
ajint i;
ajint maxarr;
embInit("newcpgreport",argc,argv);
seqall = ajAcdGetSeqall("sequence");
window = ajAcdGetInt("window");
shift = ajAcdGetInt("shift");
outf = ajAcdGetOutfile("outfile");
minobsexp = ajAcdGetFloat("minoe");
minlen = ajAcdGetInt("minlen");
minpc = ajAcdGetFloat("minpc");
substr = ajStrNew();
bases = ajStrNewC("CG");
maxarr = 0;
while(ajSeqallNext(seqall, &seq))
{
begin = ajSeqallGetseqBegin(seqall);
end = ajSeqallGetseqEnd(seqall);
strand = ajSeqGetSeqCopyS(seq);
ajStrFmtUpper(&strand);
ajStrAssignSubC(&substr,ajStrGetPtr(strand),--begin,--end);
len=ajStrGetLen(substr);
if(len > maxarr)
{
AJCRESIZE(obsexp, len);
AJCRESIZE(thresh, len);
AJCRESIZE(xypc, len);
maxarr = len;
}
for(i=0;i<len;++i)
obsexp[i]=xypc[i]=0.0;
newcpgreport_findbases(substr, len, window, shift, obsexp,
xypc, bases, &obsexpmax, &plotstart, &plotend);
newcpgreport_identify(outf, obsexp, xypc, thresh, 0, len, shift,
ajStrGetPtr(bases), ajSeqGetNameC(seq), minlen,
minobsexp, minpc, ajStrGetPtr(strand));
ajStrDel(&strand);
}
ajStrDel(&bases);
ajSeqDel(&seq);
ajStrDel(&substr);
ajFileClose(&outf);
AJFREE(obsexp);
AJFREE(thresh);
AJFREE(xypc);
ajSeqallDel(&seqall);
embExit();
return 0;
}
int main(int argc, char **argv)
{
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;
}