static void matPushHitInt(const AjPStr n, const EmbPMatPrints m,
AjPList *l, ajint pos,
ajint score, ajint elem, ajint hpe, ajint hpm)
{
EmbPMatMatch mat;
AJNEW0 (mat);
mat->seqname = ajStrNewC(ajStrGetPtr(n));
mat->cod = ajStrNewC(ajStrGetPtr((m)->cod));
mat->acc = ajStrNewC(ajStrGetPtr((m)->acc));
mat->tit = ajStrNewC(ajStrGetPtr((m)->tit));
mat->pat = ajStrNew();
mat->n = (m)->n;
mat->len = (m)->len[elem];
mat->thresh = (m)->thresh[elem];
mat->max = (m)->max[elem];
mat->element = elem;
mat->start = pos;
mat->score = score;
mat->hpe = hpe;
mat->hpm = hpm;
mat->all = ajFalse;
mat->ordered = ajFalse;
ajListPush(*l,(void *)mat);
return;
}
static void prima_TwoSortscorepos(AjPList *pairlist)
{
PPair tmp = NULL;
AjPList intlist = NULL;
AjPList filist = NULL;
PPair save = NULL;
float score = 0.0;
ajListSort(*pairlist,prima_Compare);
intlist = ajListNew();
filist = ajListNew();
score = (float) -1.0;
while(ajListPop(*pairlist,(void **)&tmp))
{
if(tmp->f->score == score)
{
ajListPush(intlist,(void *)tmp);
continue;
}
save = tmp;
ajListSort(intlist,prima_PosCompare);
score = tmp->f->score;
prima_RevSort(&intlist);
while(ajListPop(intlist,(void **)&tmp))
ajListPushAppend(filist,(void *)tmp);
ajListPush(intlist,(void *)save);
}
ajListSort(intlist,prima_PosCompare);
prima_RevSort(&intlist);
while(ajListPop(intlist,(void **)&tmp))
ajListPushAppend(filist,(void *)tmp);
ajListFree(&intlist);
ajListFree(pairlist);
*pairlist = filist;
return;
}
static void prima_RevSort(AjPList *alist)
{
PPair tmp = NULL;
AjPList intlist = NULL;
AjPList filist = NULL;
PPair save = NULL;
ajint pos = -1;
intlist = ajListNew();
filist = ajListNew();
pos = -1;
while(ajListPop(*alist,(void **)&tmp))
{
if(tmp->f->start+tmp->f->primerlen == pos)
{
ajListPush(intlist,(void *)tmp);
continue;
}
save = tmp;
ajListSort(intlist,prima_PosEndCompare);
pos = tmp->f->start+tmp->f->primerlen;
while(ajListPop(intlist,(void **)&tmp))
ajListPushAppend(filist,(void *)tmp);
ajListPush(intlist,(void *)save);
}
ajListSort(intlist,prima_PosEndCompare);
while(ajListPop(intlist,(void **)&tmp))
ajListPushAppend(filist,(void *)tmp);
ajListFree(&intlist);
ajListFree(alist);
*alist = filist;
return;
}
static void dotmatcher_pushpoint(AjPList *l, float x1, float y1, float x2,
float y2, AjBool stretch)
{
PPoint p;
if(!stretch)
{
ajGraphicsDrawposLine(x1+1,y1+1,x2+1,y2+1);
return;
}
AJNEW0(p);
p->x1 = x1+1;
p->y1 = y1+1;
p->x2 = x2+1;
p->y2 = y2+1;
ajListPush(*l,(void *)p);
return;
}
ajuint embMatProtScanInt(const AjPStr s, const AjPStr n, const EmbPMatPrints m,
AjPList *l,
AjBool *all, AjBool *ordered, AjBool overlap)
{
EmbPMatMatch mm;
AjPStr t;
char *p;
char *q;
ajint slen;
ajint score;
ajint mlen;
ajint elem;
ajint minpc;
ajint maxscore;
ajint limit;
ajint sum;
ajint hpe;
ajint hpm;
ajint lastelem;
ajint lastpos;
ajint op;
ajint i;
ajint j;
t = ajStrNewC(ajStrGetPtr(s));
ajStrFmtUpper(&t);
p = q = ajStrGetuniquePtr(&t);
slen = ajStrGetLen(t);
for(i=0;i<slen;++i,++p)
*p = ajSysCastItoc(ajBasecodeToInt((ajint)*p));
p = q;
*all = *ordered = ajTrue;
lastelem = lastpos = INT_MAX;
hpm=0;
for(elem=(m)->n - 1;elem >= 0;--elem)
{
hpe = 0;
mlen = (m)->len[elem];
minpc = (m)->thresh[elem];
maxscore = (m)->max[elem];
limit = slen-mlen;
for(i=0;i<limit;++i)
{
sum = 0;
for(j=0;j<mlen;++j)
sum += (m)->matrix[elem][(ajint) p[i+j]][j];
score = (sum*100)/maxscore;
if(score>=minpc)
{
if(elem<lastelem && *ordered)
{
if(lastelem == INT_MAX)
{
lastelem = elem;
lastpos = i;
}
else
{
lastelem = elem;
op = i;
if(!overlap)
op += mlen;
if(op >= lastpos)
*ordered = ajFalse;
lastpos = i;
}
}
++hpe;
++hpm;
matPushHitInt(n,m,l,i,score,elem,hpe,hpm);
}
}
if(!hpe)
*all = ajFalse;
}
if(hpm)
{
ajListPop(*l,(void **)&mm);
if(*all)
{
mm->all = ajTrue;
if(*ordered)
mm->ordered = ajTrue;
else
mm->ordered = ajFalse;
}
else
{
mm->all = ajFalse;
if(*ordered)
mm->ordered = ajTrue;
else
mm->ordered = ajFalse;
}
ajListPush(*l,(void *)mm);
}
ajStrDel(&t);
return hpm;
}
static ajint silent_restr_read(AjPList *relist,const AjPStr enzymes)
{
EmbPPatRestrict rptr = NULL;
AjPFile fin = NULL;
AjPStr refilename = NULL;
register ajint RStotal = 0;
PRinfo rinfo = NULL;
AjBool isall = ajFalse;
ajint ne = 0;
ajint i;
AjPStr *ea = NULL;
refilename = ajStrNewC("REBASE/embossre.enz");
rptr = embPatRestrictNew();
*relist = ajListNew();
fin = ajDatafileNewInNameS(refilename);
if(!fin)
ajFatal("Aborting...restriction file '%S' not found", refilename);
/* Parse the user-selected enzyme list */
if(!enzymes)
isall = ajTrue;
else
{
ne = ajArrCommaList(enzymes,&ea);
for(i=0;i<ne;++i)
ajStrRemoveWhite(&ea[i]);
if(ajStrMatchCaseC(ea[0],"all"))
isall = ajTrue;
else
isall = ajFalse;
}
while(!ajFileIsEof(fin))
{
if(!embPatRestrictReadEntry(rptr,fin))
continue;
if(!isall)
{
for(i=0;i<ne;++i)
if(ajStrMatchCaseS(ea[i],rptr->cod))
break;
if(i==ne)
continue;
}
AJNEW(rinfo);
/* reading in RE info into rinfo from EmbPPatRestrict structure */
rinfo->code = ajStrNewC(ajStrGetPtr(rptr->cod));
rinfo->site = ajStrNewC(ajStrGetPtr(rptr->pat));
rinfo->ncuts = rptr->ncuts;
rinfo->cut1 = rptr->cut1;
rinfo->cut2 = rptr->cut2;
rinfo->cut3 = rptr->cut3;
rinfo->cut4 = rptr->cut4;
ajListPush(*relist,(void *)rinfo);
RStotal++;
}
for(i=0;i<ne;++i)
ajStrDel(&ea[i]);
AJFREE(ea);
embPatRestrictDel(&rptr);
ajFileClose(&fin);
ajStrDel(&refilename);
return RStotal;
}
static void prima_testproduct(const AjPStr seqstr,
ajint startpos, ajint endpos,
ajint primerlen, ajint minprimerlen,
ajint maxprimerlen, float minpmGCcont,
float maxpmGCcont, ajint minprimerTm,
ajint maxprimerTm, ajint minprodlen,
ajint maxprodlen, float prodTm, float prodGC,
ajint seqlen, PPrimer *eric,
PPrimer *fred, AjPList forlist,
AjPList revlist, ajint *neric,
ajint *nfred, ajint stepping_value,
float saltconc, float dnaconc,
AjBool isDNA, ajint begin)
{
AjPStr substr = NULL;
PPrimer rubbish = NULL;
ajint forpstart;
ajint forpend;
ajint revpstart;
ajint revpend;
ajint i;
ajint tnum = 0;
ajint thisplen;
float primerTm = 0.0;
float primGCcont = 0.0;
(void) primerlen;
(void) minprodlen;
(void) maxprodlen;
(void) stepping_value;
forpend = startpos -1;
revpstart = endpos +1;
tnum = maxprimerlen-minprimerlen+1;
substr=ajStrNew();
/* FORWARD PRIMERS */
forpstart = forpend-minprimerlen+1;
for(i=0; i<tnum; ++i,--forpstart)
{
if(forpstart<0)
break;
ajStrAssignSubC(&substr,ajStrGetPtr(seqstr),forpstart,forpend);
thisplen = minprimerlen + i;
primerTm = ajMeltTempSave("",forpstart,thisplen, saltconc,
dnaconc, isDNA,
&entropy, &enthalpy, &energy);
/* If temp out of range ignore rest of loop iteration */
if(primerTm<minprimerTm || primerTm>maxprimerTm)
continue;
primGCcont = ajMeltGC(substr, thisplen);
/* If GC content out of range ignore rest of loop iteration */
if(primGCcont<minpmGCcont || primGCcont>maxpmGCcont)
continue;
/*
** This is a valid primer as far as Tm & GC is concerned
** so push it to the storage list
*/
AJNEW0(*eric);
(*eric)->substr = ajStrNewC(ajStrGetPtr(substr));
(*eric)->start = forpstart+begin;
(*eric)->primerlen = thisplen;
(*eric)->primerTm = primerTm;
(*eric)->primGCcont = primGCcont;
(*eric)->prodTm = prodTm;
(*eric)->prodGC = prodGC;
ajListPush(forlist, (void*)*eric);
(*neric)++;
}
if(!*neric)
{
ajStrDel(&substr);
return;
}
/* REVERSE PRIMERS */
revpend=revpstart + minprimerlen-1;
for(i=0; i<tnum; ++i,++revpend)
{
if(revpend>seqlen)
break;
ajStrAssignSubC(&substr,ajStrGetPtr(seqstr),revpstart,revpend);
ajSeqstrReverse(&substr);
thisplen = minprimerlen + i;
primerTm = ajMeltTempSave("",revpstart,thisplen, saltconc,
dnaconc, isDNA,
&entropy, &enthalpy, &energy);
/* If temp out of range ignore rest of loop iteration */
if(primerTm<minprimerTm || primerTm>maxprimerTm)
continue;
primGCcont = ajMeltGC(substr, thisplen);
/* If GC content out of range ignore rest of loop iteration */
if(primGCcont<minpmGCcont || primGCcont>maxpmGCcont)
continue;
/*
** This is a valid primer as far as Tm & GC is concerned
** so push it to the reverse primer storage list
*/
AJNEW0(*fred);
(*fred)->substr = ajStrNewC(ajStrGetPtr(substr));
(*fred)->start = revpstart+begin;
(*fred)->primerlen = thisplen;
(*fred)->primerTm = primerTm;
(*fred)->primGCcont = primGCcont;
ajListPush(revlist, (void*)*fred);
(*nfred)++;
}
ajStrDel(&substr);
if(!*nfred)
{
*neric = 0;
while(ajListPop(forlist,(void**)&rubbish))
prima_PrimerDel(&rubbish);
}
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 prima_testtarget(const AjPStr seqstr, const AjPStr revstr,
ajint targetstart,
ajint targetend, ajint minprimerlen,
ajint maxprimerlen, ajint seqlen,
float minprimerTm, float maxprimerTm,
float minpmGCcont, float maxpmGCcont,
float minprodGCcont, float maxprodGCcont,
float saltconc, float dnaconc,
AjPList pairlist, ajint *npair)
{
AjPStr fstr;
AjPStr rstr;
AjPStr str1;
AjPStr str2;
PPrimer f;
PPrimer r;
PPair ppair;
ajint i;
ajint j;
ajint forstart = 0;
ajint forend;
ajint revstart = 0;
ajint revend;
ajint Limit;
ajint tnum;
ajint thisplen;
ajint cut;
float primerTm = 0.0;
float primGCcont = 0.0;
float prodgc = 0.0;
AjBool found = ajFalse;
AjBool revfound = ajFalse;
AjBool isDNA = ajTrue;
ajint flen = 0;
ajint rlen = 0;
float ftm = 0.0;
float rtm = 0.0;
float fgc = 0.0;
float rgc = 0.0;
ajint fsc = 0;
ajint rsc = 0;
const char *s;
const char *s2;
const char *p;
ajint pv;
ajint plimit;
ajint pcount;
ajint k;
(void) minprodGCcont;
(void) maxprodGCcont;
fstr = ajStrNew();
rstr = ajStrNew();
str1 = ajStrNew();
str2 = ajStrNew();
tnum=maxprimerlen-minprimerlen+1;
/******FORWARDS *******/
for(i=targetstart-minprimerlen; i>-1; --i)
{
forstart = i;
forend = i+minprimerlen-1;
for(j=0; j<tnum; ++j,++forend)
{
if(forend==targetstart)
break;
ajStrAssignSubC(&fstr, ajStrGetPtr(seqstr), forstart, forend);
thisplen = ajStrGetLen(fstr);
primerTm = ajMeltTempSave("",forstart,thisplen,
saltconc, dnaconc, isDNA,
&entropy, &enthalpy, &energy);
if(primerTm <minprimerTm || primerTm>maxprimerTm)
continue;
primGCcont= ajMeltGC(fstr, thisplen);
if(primGCcont< minpmGCcont || primGCcont >maxpmGCcont)
continue;
/*instead of calling the self-reject function */
cut = (thisplen/2)-1;
ajStrAssignSubS(&str1, fstr, 0, cut);
ajStrAssignSubS(&str2, fstr, cut+1, thisplen-1);
if((fsc=prima_primalign(str1, str2)) > SIMLIMIT)
continue;
/* Test for match with rest of sequence */
s = ajStrGetPtr(seqstr);
s2 = ajStrGetPtr(revstr);
p = ajStrGetPtr(fstr);
pv = thisplen;
pcount = 0;
plimit = seqlen-pv+1;
for(k=0;k<plimit && pcount<2;++k)
{
if(prima_seq_align(s+k,p,pv)>SIMLIMIT2)
++pcount;
if(prima_seq_align(s2+k,p,pv)>SIMLIMIT2)
++pcount;
}
if(pcount<2)
{
found = ajTrue;
flen = thisplen;
ftm = primerTm;
fgc = primGCcont;
break;
}
}
if(found)
break;
}
/******* REVERSES IN TARGETRANGE *****/
Limit = seqlen-minprimerlen;
if(found)
for(i=targetend+1; i<Limit; ++i)
{
revstart = i;
revend = i+minprimerlen-1;
for(j=0; j<tnum; ++j,++revend)
{
if(revend==seqlen)
break;
ajStrAssignSubC(&rstr, ajStrGetPtr(seqstr), revstart, revend);
ajSeqstrReverse(&rstr);
thisplen = ajStrGetLen(rstr);
primerTm = ajMeltTempSave("", revstart, thisplen,
saltconc, dnaconc, 1,
&entropy, &enthalpy, &energy);
if(primerTm <minprimerTm || primerTm>maxprimerTm)
continue;
primGCcont= ajMeltGC(rstr, thisplen);
if(primGCcont< minpmGCcont || primGCcont >maxpmGCcont)
continue;
/*instead of calling the self-reject function */
cut = (thisplen/2)-1;
ajStrAssignSubS(&str1, rstr, 0, cut);
ajStrAssignSubS(&str2, rstr, cut+1, thisplen-1);
if((rsc=prima_primalign(str1, str2)) < SIMLIMIT)
continue;
/* Test for match with rest of sequence */
s = ajStrGetPtr(seqstr);
s2 = ajStrGetPtr(revstr);
p = ajStrGetPtr(rstr);
pv = thisplen;
pcount = 0;
plimit = seqlen-pv+1;
for(k=0;k<plimit && pcount<2;++k)
{
if(prima_seq_align(s+k,p,pv)>SIMLIMIT2)
++pcount;
if(prima_seq_align(s2+k,p,pv)>SIMLIMIT2)
++pcount;
}
if(pcount<2)
{
revfound = ajTrue;
rlen = thisplen;
rtm = primerTm;
rgc = primGCcont;
break;
}
}
if(revfound)
break;
}
if(found && !revfound)
{
found = ajFalse;
ajWarn("No reverse primers found in targetrange");
*npair = 0;
return;
}
if(!found)
{
ajWarn("No forward primers found in targetrange");
*npair = 0;
return;
}
ajStrAssignSubC(&str1,ajStrGetPtr(seqstr),forstart+flen,revstart-1);
prodgc = ajMeltGC(str1,revstart-(forstart+flen));
AJNEW0(f);
f->substr = ajStrNewC(ajStrGetPtr(fstr));
f->start = forstart;
f->primerlen = flen;
f->primerTm = ftm;
f->primGCcont = fgc;
f->score = fsc;
f->prodGC = prodgc;
f->prodTm = ajMeltTempProd(prodgc,saltconc,revstart-(forstart+flen));
AJNEW0(r);
r->substr = ajStrNewC(ajStrGetPtr(rstr));
r->start = revstart;
r->primerlen = rlen;
r->primerTm = rtm;
r->primGCcont = rgc;
r->score = rsc;
AJNEW0(ppair);
ppair->f = f;
ppair->r = r;
ajListPush(pairlist,(void *)ppair);
*npair = 1;
return;
}
static AjBool dbxflat_ParseFastq(EmbPBtreeEntry entry, AjPFile inf)
{
AjPStr line = NULL;
ajlong pos = 0L;
ajuint seqlen = 0;
ajuint qlen = 0;
AjPStr tmpfd = NULL;
AjPStr str = NULL;
AjPStr de = NULL;
AjBool ok;
if(!dbxflat_wrdexp)
dbxflat_wrdexp = ajRegCompC("([A-Za-z0-9.:=]+)");
line = ajStrNewC("");
pos = ajFileResetPos(inf);
if(!ajReadlineTrim(inf,&line))
{
ajStrDel(&line);
return ajFalse;
}
/* first line of entry */
if(!ajStrPrefixC(line,"@"))
return ajFalse;
entry->fpos = pos;
ajStrCutStart(&line, 1);
ajStrExtractFirst(line, &de, &entry->id);
if(desfield && ajStrGetLen(de))
{
while(ajRegExec(dbxflat_wrdexp,de))
{
ajRegSubI(dbxflat_wrdexp, 1, &tmpfd);
str = ajStrNew();
ajStrAssignS(&str,tmpfd);
ajListPush(desfield->data,(void *)str);
ajRegPost(dbxflat_wrdexp, &de);
}
}
/* now read sequence */
ok = ajReadlineTrim(inf,&line);
while(ok && !ajStrPrefixC(line, "+"))
{
ajStrRemoveWhite(&line);
seqlen += MAJSTRGETLEN(line);
ok = ajReadlineTrim(inf,&line);
}
if(!ok)
return ajFalse;
ok = ajReadlineTrim(inf,&line);
while(ok)
{
qlen += MAJSTRGETLEN(line);
if(qlen < seqlen)
ok = ajReadlineTrim(inf,&line);
else
ok = ajFalse;
}
ajStrDel(&de);
ajStrDel(&tmpfd);
ajStrDel(&line);
return ajTrue;
}
void embPropCalcFragments(const char *s, ajint n,
AjPList *l, AjPList *pa,
AjBool unfavoured, AjBool overlap,
AjBool allpartials, ajint *ncomp, ajint *npart,
AjPStr *rname, AjBool nterm, AjBool cterm,
AjBool dorag, EmbPPropMolwt const *mwdata,
AjBool mono)
{
static const char *PROPENZReagent[]=
{
"Trypsin","Lys-C","Arg-C","Asp-N","V8-bicarb","V8-phosph",
"Chymotrypsin","CNBr"
};
static const char *PROPENZSite[]=
{
"KR","K","R","D","E","DE","FYWLM","M"
};
static const char *PROPENZAminoCarboxyl[]=
{
"CC","C","C","N","C","CC","CCCCC","C"
};
static const char *PROPENZUnfavoured[]=
{
"KRIFLP","P","P","","KREP","P","P",""
};
ajint i;
ajint j;
ajint lim;
ajint len;
AjPList t;
EmbPPropFrag fr;
ajint *begsa = NULL;
ajint *endsa = NULL;
double molwt;
double *molwtsa = NULL;
AjBool *afrag = NULL;
ajint mark;
ajint bwp;
ajint ewp;
ajint *ival;
ajint defcnt;
ajint it;
ajint st = 0;
ajint mt = 0;
ajint et = 0;
ajStrAssignC(rname,PROPENZReagent[n]);
defcnt = 0;
len = (ajint) strlen(s);
t = ajListNew(); /* Temporary list */
/* First get all potential cut points */
for(i=0;i<len;++i)
{
if(!strchr(PROPENZSite[n],s[i]))
continue;
if(len==i+1)
continue;
if(strchr(PROPENZUnfavoured[n],s[i+1])
&& !unfavoured)
continue;
AJNEW0(ival);
*ival = i;
ajListPushAppend(t,(void *)ival);
++defcnt;
}
if(defcnt)
{
AJCNEW(begsa,(defcnt+1));
AJCNEW(endsa,(defcnt+1));
AJCNEW(molwtsa,(defcnt+1));
AJCNEW(afrag,(defcnt+1));
}
for(i=0;i<defcnt;++i) /* Pop them into a temporary array */
{
ajListPop(t,(void **)&ival);
endsa[i] = *ival;
AJFREE(ival);
}
mark = 0;
for(i=0;i<defcnt;++i) /* Work out true starts, ends and molwts */
{
bwp = mark;
ewp = endsa[i];
if(strchr(PROPENZAminoCarboxyl[n],'N'))
--ewp;
molwt=embPropCalcMolwt(s,bwp,ewp,mwdata,mono);
if(n==PROPENZCNBR)
molwt -= (17.045 + 31.095);
begsa[i] = mark;
endsa[i] = ewp;
molwtsa[i] = molwt;
afrag[i] = ajFalse;
mark = ewp+1;
}
if(defcnt) /* Special treatment for last fragment */
{
molwt = embPropCalcMolwt(s,mark,len-1,mwdata,mono);
if(n==PROPENZCNBR)
molwt -= (17.045 + 31.095);
begsa[i] = mark;
endsa[i] = len-1;
molwtsa[i] = molwt;
afrag[i] = ajFalse;
++defcnt;
}
/* Push the hits */
for(i=0;i<defcnt;++i)
{
if(dorag)
{
st = begsa[i];
et = endsa[i];
for(it=st+RAG_MINPEPLEN-1; it < et; ++it)
{
AJNEW0(fr);
fr->start = st;
fr->end = it;
fr->molwt = embPropCalcMolwt(s,st,it,mwdata,mono);
if(n == PROPENZCNBR)
fr->molwt -= (17.045 + 31.095);
fr->isfrag = ajTrue;
ajListPush(*l,(void *)fr);
}
}
AJNEW0(fr);
fr->start = begsa[i];
fr->end = endsa[i];
fr->molwt = molwtsa[i];
fr->isfrag = afrag[i];
ajListPush(*l,(void *) fr);
if(dorag && nterm)
for(it=st+1; it < et-RAG_MINPEPLEN+2; ++it)
{
AJNEW0(fr);
fr->start = it;
fr->end = et;
fr->molwt = embPropCalcMolwt(s,it,et,mwdata,mono);
if(n == PROPENZCNBR)
fr->molwt -= (17.045 + 31.095);
fr->isfrag = ajTrue;
ajListPush(*l,(void *)fr);
}
}
if(!dorag)
ajListSort(*l, &propFragCompare);
*ncomp = defcnt;
/* Now deal with overlaps */
*npart = 0;
lim = defcnt -1;
if(overlap && !allpartials)
{
for(i=0;i<lim;++i)
{
if(dorag)
{
st = begsa[i];
mt = endsa[i];
et = endsa[i+1];
if(cterm)
for(it=mt+1; it < et; ++it)
{
AJNEW0(fr);
fr->start = st;
fr->end = it;
fr->molwt = embPropCalcMolwt(s,st,it,mwdata,mono);
if(n == PROPENZCNBR)
fr->molwt -= (17.045 + 31.095);
fr->isfrag = ajTrue;
ajListPush(*l,(void *)fr);
}
}
AJNEW0(fr);
fr->isfrag = ajTrue;
fr->molwt = embPropCalcMolwt(s,begsa[i],endsa[i+1],mwdata,mono);
if(n==PROPENZCNBR)
fr->molwt -= (17.045 + 31.095);
fr->start = begsa[i];
fr->end = endsa[i+1];
ajListPush(*pa,(void *)fr);
++(*npart);
if(dorag && nterm)
for(it=st+1; it<mt; ++it)
{
AJNEW0(fr);
fr->start = it;
fr->end = et;
fr->molwt = embPropCalcMolwt(s,it,et,mwdata,mono);
if(n == PROPENZCNBR)
fr->molwt -= (17.045 + 31.095);
fr->isfrag = ajTrue;
ajListPush(*l,(void *)fr);
}
}
if(*npart) /* Remove complete sequence */
{
--(*npart);
ajListPop(*pa,(void **)&fr);
}
if(!dorag)
ajListSort(*pa, &propFragCompare);
}
if(allpartials)
{
lim = defcnt;
for(i=0;i<lim;++i)
for(j=i+1;j<lim;++j)
{
AJNEW0(fr);
fr->isfrag = ajTrue;
fr->molwt = embPropCalcMolwt(s,begsa[i],endsa[j],mwdata,mono);
if(n==PROPENZCNBR)
fr->molwt -= (17.045 + 31.095);
fr->start = begsa[i];
fr->end = endsa[j];
ajListPush(*pa,(void *)fr);
++(*npart);
}
if(*npart) /* Remove complete sequence */
{
--(*npart);
ajListPop(*pa,(void **)&fr);
}
if(!dorag)
ajListSort(*pa, &propFragCompare);
}
if(defcnt)
{
AJFREE(molwtsa);
AJFREE(endsa);
AJFREE(begsa);
AJFREE(afrag);
}
ajListFree(&t);
return;
}
/* @prog domainreso ***********************************************************
**
** Removes low resolution domains from a DCF file (domain
** classification file).
**
******************************************************************************/
int main(ajint argc, char **argv)
{
AjPList cpdb_path = NULL; /* Location of coordinate files for input */
AjPStr cpdb_name = NULL; /* Name of coordinate file */
AjPStr temp = NULL; /* temp string */
AjPStr temp2 = NULL; /* temp string */
AjPList entry = NULL; /* List of pdb codes with resolution */
/* ABOVE the threshold */
AjPStr *entryarr = NULL; /* entry as an array */
AjPFile fptr_cpdb = NULL; /* Pointer to current coordinate file */
AjPFile dcfin = NULL; /* DCF input file */
AjPFile dcfout = NULL; /* DCF output file */
AjPPdb pdb = NULL; /* Pdb object pointer */
AjPDomain domain = NULL; /* Domain structure */
float threshold = 0.0; /* Resolution threshold */
ajint num = 0; /* number of nodes in list */
ajint type = 0; /* Type of domain (ajSCOP or ajCATH) in
the DCF file */
/* Read data from acd */
embInitPV("domainreso",argc,argv,"DOMAINATRIX",VERSION);
cpdb_path = ajAcdGetDirlist("cpdbpath");
threshold = ajAcdGetFloat("threshold");
dcfin = ajAcdGetInfile("dcfinfile");
dcfout = ajAcdGetOutfile("dcfoutfile");
/* Allocate strings etc. */
cpdb_name = ajStrNew();
temp = ajStrNew();
/* Create list . */
entry = ajListNew();
/* Create list of files in CPDB directory. */
/* Determine number of nodes on list */
num = ajListGetLength(cpdb_path);
/*
domainreso reads a directory of clean coordinate files file, creates a list
of the files, then reads every list entry and extracts the resolution of the
structure. If the value is less than a threshold (user defined) then the
domain identifier is pushed onto a list. The DCF file (domain classification
file) is then read and domain identifiers compared to those on the list, if
found then the domain structure data is written the new DCF file.
*/
type = ajDomainDCFType(dcfin);
/* Start of main application loop */
/* Produce list of pdb codes with resolution */
/* ABOVE the threshold. */
while(ajListPop(cpdb_path,(void **)&temp))
{
/* Open coordinate file. */
if((fptr_cpdb=ajFileNewInNameS(temp))==NULL)
{
ajWarn("Could not open cpdb file");
ajStrDel(&temp);
continue;
}
ajFmtPrint("%S\n", temp);
fflush(stdout);
/* Read coordinate data file. */
pdb = ajPdbReadFirstModelNew(fptr_cpdb);
/* Check if resolution is above threshold. */
if(pdb->Reso > threshold)
{
/* assign ID to list. */
temp2=ajStrNew();
ajStrAssignS(&temp2, pdb->Pdb);
ajListPush(entry, (AjPStr) temp2);
}
/* Close coordinate file and tidy up*/
ajPdbDel(&pdb);
ajFileClose(&fptr_cpdb);
ajStrDel(&temp);
}
num = ajListGetLength(entry);
/* Sort the list of pdb codes & convert to an array. */
ajListSort(entry, domainreso_StrComp);
ajListToarray(entry, (void ***)&entryarr);
/* Read DCF file and compare IDs to those in list
if not present then write domain structure data to output. . */
while((domain=(ajDomainReadCNew(dcfin, "*", type))))
{
/* DOMAIN id not found in the list of domains with resolution
above the threshold, so include it in the output file. */
if((domainreso_StrBinSearchDomain(ajDomainGetId(domain),
entryarr, num))==-1)
ajDomainWrite(dcfout, domain);
/* Delete domain structure. */
ajDomainDel(&domain);
}
/* Tidy up. */
ajStrDel(&temp2);
ajStrDel(&cpdb_name);
ajFileClose(&dcfout);
ajFileClose(&dcfin);
ajListFree(&cpdb_path);
ajListFree(&entry);
AJFREE(entryarr);
/* Return. */
ajExit();
return 0;
}
