AjPStr embPropProt1to3(AjPSeq seq, ajint pad)
{
const char *p;
const char *p3;
AjPStr temp;
ajint i;
temp = ajStrNewRes(ajSeqGetLen(seq)*3 + pad+1);
/* put any required padding spaces at the start */
for(i=0; i<pad; i++)
ajStrAppendC(&temp, " ");
for(p=ajSeqGetSeqC(seq); *p; p++)
{
if(*p == '*')
ajStrAppendC(&temp, "***");
else if(*p == '.')
ajStrAppendC(&temp, "...");
else if(*p == '-')
ajStrAppendC(&temp, "---");
else if(!isalpha((ajint)*p))
ajStrAppendC(&temp, "???");
else
{
p3 = embPropCharToThree(*p);
ajStrAppendK(&temp, *p3);
ajStrAppendK(&temp, *(p3+1));
ajStrAppendK(&temp, *(p3+2));
}
}
return temp;
}
static void dbiblast_newname(AjPStr* nname, const AjPStr oname,
const char *suff)
{
ajStrAssignS(nname, oname);
if(ajStrGetCharFirst(oname)=='@')
ajStrCutStart(nname, 1);
ajStrAppendK(nname, '.');
ajStrAppendC(nname, suff);
return;
}
AjPStr ajMatrixfGetCodes(const AjPMatrixf thys)
{
AjPStr ret = NULL;
ajint i;
ajint maxcode;
ret = ajStrNewRes(thys->Size + 1);
maxcode = thys->Size - 1;
for (i=0;i<maxcode;i++)
ajStrAppendK(&ret, ajStrGetCharFirst(thys->Codes[i]));
return ret;
}
/* @funcstatic ssematch_convertbases ******************************************
**
** Convert AjPStr of stride-assigned secondary structures to AjPSeq of
** secondary structures in 3-state assignment.
**
** @param [r] qs [AjPstr] String
**
** @return [w] q3s [AjPSeq] Sequence
**
** @@
******************************************************************************/
static AjPSeq ssematch_convertbases(AjPStr qs)
{
AjIStr iter = NULL;
char base;
AjPSeq tmp_seq = NULL;
AjPStr tmp_str = NULL;
AjPStr name_str = NULL;
/* Iterate through letters of string*/
/* StrIterGetK:returns Current text string within iterator, char* */
/* helices H, G, I -> G & I are changed to H
extended conformation -> E stays as E
bridge B/b, turn T, coil C -> all changed to L */
iter = ajStrIterNew(qs);
tmp_str = ajStrNew();
do
{
base = ajStrIterGetK(iter);
if((base == 'G') || (base == 'I'))
base = 'H';
else if((base == 'B') || (base == 'b') || (base == 'T')
|| (base == 'C'))
base = 'L';
ajStrAppendK(&tmp_str, base);
}
while(ajStrIterNext(iter));
ajStrAssignC(&name_str, "convertbases");
tmp_seq = ajSeqNewNameS(tmp_str, name_str);
/* Tidy up */
ajStrIterDel(&iter);
ajStrDel(&tmp_str);
ajStrDel(&name_str);
return tmp_seq;
}
static void eprimer3_read(int fd, AjPStr* result)
{
FILE *stream;
int ch;
ajDebug("reading primer3_core output\n");
if((stream = fdopen(fd, "r")) == NULL)
ajFatal("fdopen() read error");
while((ch = getc( stream )) != EOF)
ajStrAppendK(result, ch);
ajDebug("primer3_core output:\n%S\n", *result);
fclose(stream);
ajDebug("reading done\n");
return;
}
AjPStr embPropProtGaps(AjPSeq seq, ajint pad)
{
const char *p;
AjPStr temp;
ajint i;
temp = ajStrNewRes(ajSeqGetLen(seq)*3 + pad+1);
/* put any required padding spaces at the start */
for(i=0; i<pad; i++)
ajStrAppendC(&temp, " ");
for(p=ajSeqGetSeqC(seq); *p; p++)
{
ajStrAppendK(&temp, *p);
ajStrAppendC(&temp, " ");
}
return temp;
}
AjPStr embPropProt1to3Rev(AjPSeq seq, ajint pad)
{
const char *p;
const char *p3;
AjPStr temp;
ajint i=0;
temp = ajStrNewRes(ajSeqGetLen(seq)*3 + pad+1);
for(p=ajSeqGetSeqC(seq); *p; p++)
{
if(*p == '*')
ajStrAppendC(&temp, "***");
else if(*p == '.')
ajStrAppendC(&temp, "...");
else if(*p == '-')
ajStrAppendC(&temp, "---");
else if(!isalpha((ajint)*p))
ajStrAppendC(&temp, "???");
else
{
p3 = embPropCharToThree(*p);
if(i++)
{
ajStrAppendK(&temp, *(p3+2));
ajStrAppendK(&temp, *(p3+1));
ajStrAppendK(&temp, *p3);
}
else
{
if(pad >= 2)
ajStrAppendK(&temp, *(p3+2));
if(pad >= 1)
ajStrAppendK(&temp, *(p3+1));
ajStrAppendK(&temp, *p3);
}
}
}
return temp;
}
/* @funcstatic seqwords_keysearch ********************************************
**
** Search swissprot with terms structure and writes a hitlist structure
**
** @param [r] inf [AjPFile] File pointer to swissprot database
** @param [r] terms [AjPTerms] Terms object pointer
** @param [w] hits [EmbPHitlist*] Hitlist object pointer
**
** @return [AjBool] True on success
** @@
******************************************************************************/
static AjBool seqwords_keysearch(AjPFile inf,
AjPTerms terms,
EmbPHitlist *hits)
{
AjPStr line =NULL; /* Line of text. */
AjPStr id =NULL; /* Line of text. */
AjPStr temp =NULL;
ajint s =0; /* Temp. start of hit value. */
ajint e =0; /* Temp. end of hit value. */
AjPInt start =NULL; /* Array of start of hit(s). */
AjPInt end =NULL; /* Array of end of hit(s). */
ajint nhits =0; /* Number of hits. */
ajint x =0;
AjBool foundkw =ajFalse;
AjBool foundft =ajFalse;
/* Check for valid args. */
if(!inf)
return ajFalse;
/* Allocate strings and arrays. */
line = ajStrNew();
id = ajStrNew();
start = ajIntNew();
end = ajIntNew();
/* Start of main loop. */
while((ajReadlineTrim(inf,&line)))
{
/* Parse the AC line. */
if(ajStrPrefixC(line,"AC"))
{
/* Copy accesion number and remove the ';' from the end. */
ajFmtScanS(line, "%*s %S", &id);
ajStrExchangeCC(&id, ";", "\0");
/* Reset flags & no. hits. */
foundkw=ajFalse;
foundft=ajFalse;
nhits=0;
}
/* Search the description and keyword lines with search terms. */
else if((ajStrPrefixC(line,"DE") || (ajStrPrefixC(line,"KW"))))
{
/*
** Search terms have a leading and trailing space to prevent
** them being found as substrings within other words. To
** catch cases where a DE or KW line begins with a search
** term, we must add a leading and trailing space to line.
** We must first remove punctation from the line to be parsed.
*/
ajStrExchangeSetCC(&line, ".,;:", " ");
ajStrAppendK(&line, ' ');
ajStrInsertC(&line, 0, " ");
for (x = 0; x < terms->N; x++)
/* Search term is found. */
if((ajStrFindCaseS(line, terms->Keywords[x])!=-1))
{
foundkw=ajTrue;
break;
}
}
/* Search the feature table line with search terms. */
else if((ajStrPrefixC(line,"FT DOMAIN")))
{
/*
** Search terms have a leading and trailing space to prevent
** them being found as substrings within other words. To
** catch cases where a FT line ends with a search
** term, we must add a trailing space to line
** We must first remove punctation from the line to be parsed.
*/
ajStrExchangeSetCC(&line, ".,;:", " ");
ajStrAppendK(&line, ' ');
for (x = 0; x < terms->N; x++)
if((ajStrFindCaseS(line, terms->Keywords[x])!=-1))
{
/* Search term is found. */
foundft = ajTrue;
nhits++;
/* Assign start and end of hit. */
ajFmtScanS(line, "%*s %*s %d %d", &s, &e);
ajIntPut(&start, nhits-1, s);
ajIntPut(&end, nhits-1, e);
break;
}
}
/* Parse the sequence. */
else if((ajStrPrefixC(line,"SQ") && ((foundkw == ajTrue) ||
(foundft == ajTrue))))
{
/* Allocate memory for temp. sequence. */
temp = ajStrNew();
/* Read the sequence into hitlist structure. */
while((ajReadlineTrim(inf,&line)) && !ajStrPrefixC(line,"//"))
/* Read sequence line into temp. */
ajStrAppendC(&temp,ajStrGetPtr(line)+3);
/* Clean up temp. sequence. */
ajStrRemoveWhite(&temp);
/*Priority is given to domain (rather than full length) sequence.*/
if(foundft)
{
for(x=0;x<nhits;x++)
{
/* Increment counter of hits for subsequent hits*/
(*hits)->N++;
/* Reallocate memory for array of hits in hitlist
structure. */
AJCRESIZE((*hits)->hits, (*hits)->N);
(*hits)->hits[(*hits)->N-1]=embHitNew();
ajStrAssignC(&(*hits)->hits[(*hits)->N-1]->Model,
"KEYWORD");
/* Assign start and end of hit. */
(*hits)->hits[(*hits)->N-1]->Start = ajIntGet(start, x);
(*hits)->hits[(*hits)->N-1]->End = ajIntGet(end, x);
/* Extract sequence within specified range */
ajStrAssignSubS(&(*hits)->hits[(*hits)->N - 1]->Seq, temp,
(*hits)->hits[(*hits)->N - 1]->Start - 1,
(*hits)->hits[(*hits)->N - 1]->End - 1);
/* Put id into structure */
ajStrAssignRef(&(*hits)->hits[(*hits)->N - 1]->Acc, id);
}
}
else
{
/* Increment counter of hits */
(*hits)->N++;
/* Reallocate memory for array of hits in hitlist structure */
AJCRESIZE((*hits)->hits, (*hits)->N);
(*hits)->hits[(*hits)->N-1]=embHitNew();
ajStrAssignC(&(*hits)->hits[(*hits)->N-1]->Model, "KEYWORD");
/* Extract whole sequence */
ajStrAssignRef(&(*hits)->hits[(*hits)->N - 1]->Seq, temp);
(*hits)->hits[(*hits)->N - 1]->Start = 1;
(*hits)->hits[(*hits)->N - 1]->End =
ajStrGetLen((*hits)->hits[(*hits)->N - 1]->Seq);
/* Put id into structure */
ajStrAssignRef(&(*hits)->hits[(*hits)->N - 1]->Acc, id);
}
/* Free temp. sequence */
ajStrDel(&temp);
}
}
/* Clean up */
ajStrDel(&line);
ajStrDel(&id);
ajIntDel(&start);
ajIntDel(&end);
return ajTrue;
}
/* @funcstatic seqwords_TermsRead *********************************************
**
** Read the next Terms object from a file in embl-like format. The search
** terms are modified with a leading and trailing space.
**
** @param [r] inf [AjPFile] Input file stream
** @param [w] thys [AjPTerms*] Terms object
**
** @return [AjBool] True on succcess
** @@
*****************************************************************************/
static AjBool seqwords_TermsRead(AjPFile inf,
AjPTerms *thys)
{
AjPStr line =NULL; /* Line of text. */
AjPStr temp =NULL;
AjPList list_terms =NULL; /* List of keywords for a scop node*/
AjBool ok =ajFalse;
AjPStr type = NULL;
/* Memory management */
(*thys)=seqwords_TermsNew();
list_terms = ajListstrNew();
line = ajStrNew();
type = ajStrNew();
/* Read first line. */
ok = ajReadlineTrim(inf,&line);
while(ok && !ajStrPrefixC(line,"//"))
{
if(ajStrPrefixC(line,"XX"))
{
ok = ajReadlineTrim(inf,&line);
continue;
}
else if(ajStrPrefixC(line,"TY"))
{
ajFmtScanS(line, "%*s %S", &type);
if(ajStrMatchC(type, "SCOP"))
(*thys)->Type = ajSCOP;
else if(ajStrMatchC(type, "CATH"))
(*thys)->Type = ajCATH;
}
else if(ajStrPrefixC(line,"CL"))
{
ajStrAssignC(&(*thys)->Class,ajStrGetPtr(line)+3);
ajStrRemoveWhiteExcess(&(*thys)->Class);
}
else if(ajStrPrefixC(line,"AR"))
{
ajStrAssignC(&(*thys)->Architecture,ajStrGetPtr(line)+3);
ajStrRemoveWhiteExcess(&(*thys)->Architecture);
}
else if(ajStrPrefixC(line,"TP"))
{
ajStrAssignC(&(*thys)->Topology,ajStrGetPtr(line)+3);
ajStrRemoveWhiteExcess(&(*thys)->Topology);
}
else if(ajStrPrefixC(line,"FO"))
{
ajStrAssignC(&(*thys)->Fold,ajStrGetPtr(line)+3);
while(ajReadlineTrim(inf,&line))
{
if(ajStrPrefixC(line,"XX"))
break;
ajStrAppendC(&(*thys)->Fold,ajStrGetPtr(line)+3);
}
ajStrRemoveWhiteExcess(&(*thys)->Fold);
}
else if(ajStrPrefixC(line,"SF"))
{
ajStrAssignC(&(*thys)->Superfamily,ajStrGetPtr(line)+3);
while(ajReadlineTrim(inf,&line))
{
if(ajStrPrefixC(line,"XX"))
break;
ajStrAppendC(&(*thys)->Superfamily,ajStrGetPtr(line)+3);
}
ajStrRemoveWhiteExcess(&(*thys)->Superfamily);
}
else if(ajStrPrefixC(line,"FA"))
{
ajStrAssignC(&(*thys)->Family,ajStrGetPtr(line)+3);
while(ajReadlineTrim(inf,&line))
{
if(ajStrPrefixC(line,"XX"))
break;
ajStrAppendC(&(*thys)->Family,ajStrGetPtr(line)+3);
}
ajStrRemoveWhiteExcess(&(*thys)->Family);
}
else if(ajStrPrefixC(line,"TE"))
{
/* Copy and clean up term. */
temp = ajStrNew();
ajStrAssignC(&temp,ajStrGetPtr(line)+3);
ajStrRemoveWhiteExcess(&temp);
/* Append a leading and trailing space to search term*/
ajStrAppendK(&temp, ' ');
ajStrInsertC(&temp, 0, " ");
/* Add the current term to the list. */
ajListstrPush(list_terms,temp);
}
ok = ajReadlineTrim(inf,&line);
}
if(!ok)
{
/* Clean up. */
ajListstrFree(&list_terms);
ajStrDel(&line);
/* Return. */
return ajFalse;
}
/* Convert the AjPList of terms to array of AjPSeq's. */
if(!((*thys)->N=ajListstrToarray((AjPList)list_terms,&(*thys)->Keywords)))
ajWarn("Zero sized list of terms passed into seqwords_TermsRead");
/* Clean up. Free the list (not the nodes!). */
ajListstrFree(&list_terms);
ajStrDel(&line);
ajStrDel(&type);
return ajTrue;
}
AjBool ajReadlinePos(AjPFile file, AjPStr* Pdest, ajlong* Ppos)
{
const char *cp;
char *buff;
ajint isize;
ajint ilen;
ajint jlen;
ajint ipos;
ajuint buffsize;
size_t iread;
const char* pnewline = NULL;
MAJSTRDEL(Pdest);
if(file->Buffsize)
buffsize = file->Buffsize;
else
buffsize = ajFileValueBuffsize();
if(!file->Buff)
ajStrAssignResC(&file->Buff, buffsize, "");
else if(buffsize > MAJSTRGETRES(file->Buff))
ajStrSetRes(&file->Buff, buffsize);
if(MAJSTRGETUSE(file->Buff) == 1)
buff = MAJSTRGETPTR(file->Buff);
else
buff = ajStrGetuniquePtr(&file->Buff);
isize = MAJSTRGETRES(file->Buff);
ilen = 0;
ipos = 0;
if(!file->fp)
ajWarn("ajFileGets file not found");
*Ppos = file->Filepos;
while(buff)
{
if(file->End)
{
ajStrAssignClear(Pdest);
ajDebug("at EOF: File already read to end %F\n", file);
return ajFalse;
}
#ifndef __ppc__
if(file->Readblock)
{
if(file->Blockpos >= file->Blocklen)
{
iread = fread(file->Readblock,
1, file->Blocksize,
file->fp);
if(!iread && ferror(file->fp))
ajFatal("fread failed with error:%d '%s'",
ferror(file->fp), strerror(ferror(file->fp)));
file->Blockpos = 0;
file->Blocklen = iread;
file->Readblock[iread] = '\0';
/*ajDebug("++ fread %u Ppos:%Ld\n", iread, *Ppos);*/
}
if(file->Blockpos < file->Blocklen)
{
/* we know we have something in Readblock to process */
pnewline = strchr(&file->Readblock[file->Blockpos], '\n');
if(pnewline)
jlen = pnewline - &file->Readblock[file->Blockpos] + 1;
else
jlen = file->Blocklen - file->Blockpos;
/*ajDebug("ipos:%d jlen:%d pnewline:%p "
"Readblock:%p blockpos:%d blocklen:%d\n",
ipos, jlen, pnewline, file->Readblock,
file->Blockpos, file->Blocklen);*/
memmove(&buff[ipos], &file->Readblock[file->Blockpos], jlen);
buff[ipos+jlen]='\0';
cp = &buff[ipos];
file->Blockpos += jlen;
}
else
{
jlen = 0;
cp = NULL;
}
}
else
{
cp = fgets(&buff[ipos], isize, file->fp);
jlen = strlen(&buff[ipos]);
}
#else
cp = ajSysFuncFgets(&buff[ipos], isize, file->fp);
jlen = strlen(&buff[ipos]);
#endif
if(!cp && !ipos)
{
if(feof(file->fp))
{
file->End = ajTrue;
ajStrAssignClear(Pdest);
ajDebug("EOF ajFileGetsL file %F\n", file);
return ajFalse;
}
else
ajFatal("Error reading from file '%S'\n", ajFileGetNameS(file));
}
ilen += jlen;
file->Filepos += jlen;
/*
** We need to read again if:
** We have read the entire buffer
** and we don't have a newline at the end
** (must be careful about that - we may just have read enough)
*/
if(((file->Readblock && !pnewline) ||(jlen == (isize-1))) &&
(buff[ilen-1] != '\n'))
{
MAJSTRSETVALIDLEN(&file->Buff, ilen); /* fix before resizing! */
ajStrSetResRound(&file->Buff, ilen+buffsize+1);
/*ajDebug("more to do: jlen: %d ipos: %d isize: %d ilen: %d "
"Size: %d\n",
jlen, ipos, isize, ilen, ajStrGetRes(file->Buff));*/
ipos += jlen;
buff = ajStrGetuniquePtr(&file->Buff);
isize = ajStrGetRes(file->Buff) - ipos;
/*ajDebug("expand to: ipos: %d isize: %d Size: %d\n",
ipos, isize, ajStrGetRes(file>Buff));*/
}
else
buff = NULL;
}
MAJSTRSETVALIDLEN(&file->Buff, ilen);
if (ajStrGetCharLast(file->Buff) != '\n')
{
/*ajDebug("Appending missing newline to '%S'\n", file->Buff);*/
ajStrAppendK(&file->Buff, '\n');
}
ajStrAssignRef(Pdest, file->Buff);
/*
if(file->Readblock)
ajDebug("ajFileGetsL done blocklen:%d blockpos:%d readlen:%u\n",
file->Blocklen, file->Blockpos, ajStrGetLen(file->Buff));
*/
return ajTrue;
}
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)
{
AjPDasServer server = NULL;
AjPDasSource source = NULL;
AjPDasSegment segment = NULL;
AjPStr host = NULL;
AjPStr path = NULL;
AjPFile outf = NULL;
ajint port = 80;
AjBool sequencesourcesonly;
AjBool entrypoints;
AjBool showtestqueries;
AjBool runtestqueries = ajTrue;
AjBool quickexit = ajFalse;
ajint itest=0;
ajint j=0;
ajint maxtests=0;
ajint maxfeatures=0;
ajint maxsegments=0;
AjIList iter = NULL;
AjIList coordsi = NULL;
AjIList itereps = NULL;
AjPFilebuff buff = NULL;
AjPUrlref uo = NULL;
AjPList segments = NULL;
AjPStr ffname = NULL;
AjPStr url = NULL;
AjPStr dbhttpver = ajStrNew();
AjPStr dbname = ajStrNew();
AjPStr dbproxy = ajStrNew();
AjPStr servername = NULL;
AjPTable titlecount = NULL;
const ajuint* count;
int k=0;
embInit("dastest", argc, argv);
host = ajAcdGetString("host");
path = ajAcdGetString("path");
port = ajAcdGetInt("port");
sequencesourcesonly = ajAcdGetBoolean("sequencesourcesonly");
entrypoints = ajAcdGetBoolean("entrypoints");
showtestqueries = ajAcdGetBoolean("showtestqueries");
runtestqueries = ajAcdGetBoolean("runtestqueries");
servername = ajAcdGetString("servername");
outf = ajAcdGetOutfile("outfile");
maxtests = ajAcdGetInt("maxtests");
maxfeatures = ajAcdGetInt("maxfeatures");
maxsegments = ajAcdGetInt("maxsegments");
server = ajDasServerNew();
if(runtestqueries)
{
url = ajStrNew();
if(!ajNamServer(servername))
{
ajWarn("following das server is required to be defined "
"for test queries...");
ajWarn("\nSERVER %S [\n"
" type: \"sequence\"\n"
" method: \"das\"\n"
" url: \"http://%S%S\"\n"
"]\n",servername, host,path);
ajWarn("ignoring -runtestqueries option...");
runtestqueries = ajFalse;
}
else
{
ajNamSvrGetUrl(servername, &url);
ajHttpUrlDeconstruct(url, &port, &host, &path);
ajStrDel(&url);
}
}
ajDasServerSethostS(server,host);
ajDasServerSetport(server,port);
if(ajStrGetCharLast(path)!='/')
ajStrAppendK(&path,'/');
ajStrAppendC(&path,"sources");
ajDasServerSetpathS(server,path);
ajFmtPrintF(outf,"host = %S\npath = %S\nport = %d\n",
server->host, server->path, server->port);
/*
* TODO: stop using http-read but instead use
* ajNamSvrListListDatabases(svrname, dbnames);
*/
buff = ajHttpRead(dbhttpver, dbname, dbproxy, host, port, path);
if(!buff)
ajExitAbort();
ajFilebuffHtmlNoheader(buff);
ajDasParseRegistry(buff, server->sources);
ajFmtPrintF(outf,"DAS sources and descriptions\n\n");
titlecount = dastestGetTitleCount(server);
iter = ajListIterNew(server->sources);
while(!ajListIterDone(iter) && !quickexit)
{
source = ajListIterGet(iter);
if ((sequencesourcesonly && !source->sequence)
|| ajStrMatchC(source->title,"cath") || k++ <50)
continue;
ajFmtPrintF(outf,"%-30S %-50S\n%S\n",source->uri,source->title,
source->description);
if(entrypoints && source->entry_points)
{
uo = ajHttpUrlrefNew();
ajHttpUrlrefParseC(&uo, ajStrGetPtr(source->entry_points_uri));
if(ajStrGetLen(uo->Port))
ajStrToInt(uo->Port, &port);
else
port = 80;
ajFilebuffDel(&buff);
buff = ajHttpRead(dbhttpver, dbname, dbproxy,
uo->Host, port, uo->Absolute);
ajHttpUrlrefDel(&uo);
if(!buff)
continue;
ajFilebuffHtmlNoheader(buff);
segments = ajListNew();
ajDasParseEntrypoints(buff, segments);
itereps = ajListIterNew(segments);
ajFmtPrintF(outf, "Number of entry points %d\n",
ajListGetLength(segments));
j=0;
while(!ajListIterDone(itereps))
{
segment = ajListIterGet(itereps);
if (j++ < maxsegments)
ajFmtPrintF(outf,
"segment id:%S orientation:%S start:%d stop:%d\n",
segment->id,
segment->orientation,
segment->start, segment->stop);
ajDasSegmentDel(&segment);
}
ajListIterDel(&itereps);
ajListFree(&segments);
}
if(showtestqueries || runtestqueries)
{
AjPDasCoordinate coord;
coordsi = ajListIterNew(source->coordinates);
while(!ajListIterDone(coordsi) && !quickexit)
{
coord = ajListIterGet(coordsi);
ajDebug("coordinate uri:%S taxid:%S source:%S test_range:%S\n",
coord->uri,
coord->taxid,
coord->source,
coord->test_range);
if(showtestqueries)
{
if(source->sequence)
ajFmtPrintF(outf,
"example/test entry = '%S?segment=%S'\n",
source->sequence_query_uri,coord->test_range);
if(source->features)
ajFmtPrintF(outf,
"example/test entry = '%S?segment=%S'\n",
source->features_query_uri,coord->test_range);
}
if(runtestqueries)
{
AjPStr idqry = ajStrNew();
AjPStr entry = NULL;
AjPSeq seq = NULL;
ajint ibegin = 0;
ajint iend = 0;
AjPStr example = NULL;
example = ajDasTestrangeParse(coord->test_range,
&entry, &ibegin, &iend);
if(ajStrGetLen(entry))
{
count = ajTableFetchS(titlecount, source->title);
dbname = ajDasSourceGetDBname(source, *count>1);
if (source->features)
{
AjPStr qpath=NULL;
uo = ajHttpUrlrefNew();
ajFmtPrintS(&idqry,"dasgff::%S:%S:%S",
servername,
dbname,
entry);
ajFmtPrintF(outf,
"feature query: %S start:%d end:%d\n",
idqry,
ibegin, iend);
ajHttpUrlrefParseC(&uo,
ajStrGetPtr(source->features_query_uri));
ajHttpUrlrefSplitPort(uo);
ajFmtPrintS(&qpath,"%S?segment=%S",
uo->Absolute,entry);
if(iend>0)
ajFmtPrintAppS(&qpath,":%d,%d",ibegin, iend);
if(ajStrGetLen(uo->Port))
ajStrToInt(uo->Port, &port);
else
port = 80;
ajDebug("calling ajHttpRead to get the raw"
" output; host:%S port:%d path:%S\n",
uo->Host, port, qpath);
ajFilebuffDel(&buff);
buff = ajHttpRead(dbhttpver, dbname, dbproxy,
uo->Host, port, qpath);
if(buff)
{
AjPFeattable ft;
ajFmtPrintS(&ffname, "%S.%S", source->uri,
entry);
ajFilebuffHtmlNoheader(buff);
dastestSaveRawFeatures(buff, ffname);
ajDebug("now using EMBOSS feature queries\n");
ft = dastestFeatureQuery(idqry,
ibegin, iend);
dastestSaveMappedFeatures(ft, ffname,
outf, maxfeatures);
ajStrDel(&ffname);
ajFeattableDel(&ft);
}
ajHttpUrlrefDel(&uo);
ajStrDel(&qpath);
if(++itest>=maxtests)
quickexit = ajTrue;
}
else if(source->sequence)
{
seq = ajSeqNewRes(iend-ibegin+1);
ajFmtPrintS(&idqry,"%S:%S:%S",
servername, dbname, entry);
ajFmtPrintF(outf,
"sequence query: %S start:%d end:%d\n",
idqry,
ibegin, iend);
ajSeqGetFromUsaRange(idqry, ajFalse, ibegin, iend,
seq);
ajFmtPrintF(outf,
"length of sequence returned: %d\n",
ajSeqGetLen(seq));
if(ajSeqGetLen(seq)>0)
ajFmtPrintF(outf,
"sequence returned (first 100 bases):"
" %-100.100s\n",
ajSeqGetSeqC(seq));
ajSeqDel(&seq);
}
ajStrDel(&dbname);
}
ajStrDel(&entry);
ajStrDel(&idqry);
ajStrDel(&example);
}
}
ajListIterDel(&coordsi);
}
}
ajListIterDel(&iter);
ajDasServerDel(&server);
ajFilebuffDel(&buff);
ajStrDel(&host);
ajStrDel(&path);
ajStrDel(&servername);
ajStrDel(&dbhttpver);
ajStrDel(&dbname);
ajStrDel(&dbproxy);
ajFileClose(&outf);
ajTableDelValdel(&titlecount, ajMemFree);
embExit();
return 0;
}
static void merger_Merge(AjPAlign align, AjPStr *ms,
const char *a, const char *b,
const AjPStr m, const AjPStr n, ajint start1,
ajint start2,
const char *namea, const char *nameb)
{
ajint apos;
ajint bpos;
ajint i;
AjPStr mm = NULL;
AjPStr nn = NULL;
char *p;
char *q;
ajint olen; /* length of walk alignment */
size_t tt;
/* lengths of the sequences after the aligned region */
ajint alen;
ajint blen;
AjPStr tmpstr = NULL;
mm = ajStrNewS(m);
nn = ajStrNewS(n);
p = ajStrGetuniquePtr(&mm);
q = ajStrGetuniquePtr(&nn);
olen = ajStrGetLen(mm);
/* output the left hand side */
if(start1 > start2)
{
for(i=0; i<start1; i++)
ajStrAppendK(ms, a[i]);
if(start2)
{
ajFmtPrintAppS(&tmpstr, "WARNING: *************************"
"********\n");
ajFmtPrintAppS(&tmpstr, "The region of alignment only starts at "
"position %d of sequence %s\n", start2+1, nameb);
ajFmtPrintAppS(&tmpstr, "Only the sequence of %s is being used "
"before this point\n\n", namea);
ajAlignSetTailApp(align, tmpstr);
ajStrDel(&tmpstr);
}
}
else if(start2 > start1)
{
for(i=0; i<start2; i++)
ajStrAppendK(ms, b[i]);
if(start1)
{
ajFmtPrintAppS(&tmpstr, "WARNING: **************************"
"*******\n");
ajFmtPrintAppS(&tmpstr, "The region of alignment only starts at "
"position %d of sequence %s\n", start1+1, namea);
ajFmtPrintAppS(&tmpstr, "Only the sequence of %s is being used "
"before this point\n\n", nameb);
ajAlignSetTailApp(align, tmpstr);
ajStrDel(&tmpstr);
}
}
else if(start1 && start2)
{
/* both the same length and > 1 before the aligned region */
ajFmtPrintAppS(&tmpstr,
"WARNING: *********************************\n");
ajFmtPrintAppS(&tmpstr, "There is an equal amount of unaligned "
"sequence (%d) at the start of the sequences.\n",
start1);
ajFmtPrintAppS(&tmpstr, "Sequence %s is being arbitrarily chosen "
"for the merged sequence\n\n", namea);
ajAlignSetTailApp(align, tmpstr);
ajStrDel(&tmpstr);
for(i=0; i<start1; i++)
ajStrAppendK(ms, a[i]);
}
/* header */
ajFmtPrintS(&tmpstr, "Conflicts: %15.15s %15.15s\n", namea, nameb);
ajFmtPrintAppS(&tmpstr,
" position base position base Using\n");
ajAlignSetTailApp(align, tmpstr);
/* make the merged sequence
**
** point to the start of the alignment in the complete unaligned
** sequences
*/
apos = start1;
bpos = start2;
for(i=0; i<olen; i++)
{
if(p[i]=='.' || p[i]==' ' || p[i]=='-' ||
q[i]=='.' || q[i]==' ' || q[i]=='-')
{ /* gap! */
if(merger_bestquality(a, b, apos, bpos))
{
p[i] = toupper((ajint)p[i]);
if(p[i] != '.' && p[i] != ' ' && p[i] != '-')
ajStrAppendK(ms, p[i]);
ajFmtPrintS(&tmpstr,
" %8d '%c' %8d '%c' '%c'\n",
apos+1, p[i], bpos+1, q[i], p[i]);
ajAlignSetTailApp(align, tmpstr);
}
else
{
q[i] = toupper((ajint)q[i]);
if(q[i] != '.' && q[i] != ' ' && q[i] != '-')
ajStrAppendK(ms, q[i]);
ajFmtPrintS(&tmpstr,
" %8d '%c' %8d '%c' '%c'\n",
apos+1, p[i], bpos+1, q[i], q[i]);
ajAlignSetTailApp(align, tmpstr);
}
}
else if(p[i]=='n' || p[i]=='N')
{
q[i] = toupper((ajint)q[i]);
ajStrAppendK(ms, q[i]);
}
else if(q[i]=='n' || q[i]=='N')
{
p[i] = toupper((ajint)p[i]);
ajStrAppendK(ms, p[i]);
}
else if(p[i] != q[i])
{
/*
** get the sequence with the best quality and use the base
** from that one
*/
if(merger_bestquality(a, b, apos, bpos))
{
p[i] = toupper((ajint)p[i]);
ajStrAppendK(ms, p[i]);
ajFmtPrintS(&tmpstr,
" %8d '%c' %8d '%c' '%c'\n",
apos+1, p[i], bpos+1, q[i], p[i]);
ajAlignSetTailApp(align, tmpstr);
}
else
{
q[i] = toupper((ajint)q[i]);
ajStrAppendK(ms, q[i]);
ajFmtPrintS(&tmpstr,
" %8d '%c' %8d '%c' '%c'\n",
apos+1, p[i], bpos+1, q[i], q[i]);
ajAlignSetTailApp(align, tmpstr);
}
}
else
ajStrAppendK(ms, p[i]);
/* update the positions in the unaligned complete sequences */
if(p[i] != '.' && p[i] != ' ' && p[i] != '-') apos++;
if(q[i] != '.' && q[i] != ' ' && q[i] != '-') bpos++;
}
/* output the right hand side */
tt = strlen(&a[apos]);
alen = (ajint) tt;
tt = strlen(&b[bpos]);
blen = (ajint) tt;
if(alen > blen)
{
ajStrAppendC(ms, &a[apos]);
if(blen)
{
ajFmtPrintAppS(&tmpstr, "WARNING: ***************************"
"******\n");
ajFmtPrintAppS(&tmpstr, "The region of alignment ends at "
"position %d of sequence %s\n",
bpos+1, nameb);
ajFmtPrintAppS(&tmpstr, "Only the sequence of %s is being used "
"after this point\n\n", namea);
ajAlignSetTailApp(align, tmpstr);
ajStrDel(&tmpstr);
}
}
if(blen > alen)
{
ajStrAppendC(ms, &b[bpos]);
if(alen)
{
ajFmtPrintAppS(&tmpstr, "WARNING: ***************************"
"******\n");
ajFmtPrintAppS(&tmpstr, "The region of alignment ends at "
"position %d of sequence %s\n",
apos+1, namea);
ajFmtPrintAppS(&tmpstr, "Only the sequence of %s is being used "
"after this point\n\n", nameb);
ajAlignSetTailApp(align, tmpstr);
ajStrDel(&tmpstr);
}
}
else if(alen && blen)
{ /* both the same length and > 1 */
ajFmtPrintAppS(&tmpstr, "WARNING: ************************"
"*********\n");
ajFmtPrintAppS(&tmpstr, "There is an equal amount of unaligned "
"sequence (%d) at the end of the sequences.\n",
alen);
ajFmtPrintAppS(&tmpstr, "Sequence %s is being arbitrarily chosen "
"for the merged sequence\n\n", namea);
ajStrAppendC(ms, &a[apos]);
ajAlignSetTailApp(align, tmpstr);
ajStrDel(&tmpstr);
}
ajStrDel(&mm);
ajStrDel(&nn);
ajStrDel(&tmpstr);
return;
}
int main(int argc, char *argv[])
{
char *string/*, *line*/;
char *structure=NULL, *cstruc=NULL;
/*char fname[53], ffname[60]; */
/*char *ParamFile=NULL; */
char *ns_bases=NULL, *c;
char *Concfile;
int i, length, l, sym/*, r*/;
double min_en;
double kT, sfact=1.07;
int pf=0, istty;
int noconv=0;
int doT=0; /*compute dimere free energies etc.*/
int doC=0; /*toggle to compute concentrations*/
int doQ=0; /*toggle to compute prob of base being paired*/
int cofi=0; /*toggle concentrations stdin / file*/
struct plist *prAB;
struct plist *prAA; /*pair probabilities of AA dimer*/
struct plist *prBB;
struct plist *prA;
struct plist *prB;
struct plist *mfAB;
struct plist *mfAA; /*pair mfobabilities of AA dimer*/
struct plist *mfBB;
struct plist *mfA;
struct plist *mfB;
double *ConcAandB;
AjPSeq seq1 = NULL;
AjPFile confile1 = NULL;
AjPSeq seq2 = NULL;
AjPFile confile2 = NULL;
AjPFile concfile = NULL;
AjPFile paramfile = NULL;
AjPFile outf = NULL;
AjPFile essfile = NULL;
AjPFile dotfile = NULL;
AjPFile aoutf = NULL;
AjPFile aaoutf = NULL;
AjPFile boutf = NULL;
AjPFile bboutf = NULL;
AjPFile aboutf = NULL;
AjPStr seqstring1 = NULL;
AjPStr constring1 = NULL;
AjPStr constring2 = NULL;
float eT = 0.;
AjBool eGU;
AjBool eclose;
AjBool lonely;
AjBool convert;
AjPStr ensbases = NULL;
AjBool etloop;
AjPStr eenergy = NULL;
char ewt = '\0';
float escale = 0.;
AjPStr edangles = NULL;
char edangle = '\0';
/* AjBool dimers; */
/* AjBool paired; */
embInitPV("vrnacofold",argc,argv,"VIENNA",VERSION);
seqstring1 = ajStrNew();
constring1 = ajStrNew();
constring2 = ajStrNew();
seq1 = ajAcdGetSeq("asequence");
confile1 = ajAcdGetInfile("aconstraintfile");
seq2 = ajAcdGetSeq("bsequence");
confile2 = ajAcdGetInfile("bconstraintfile");
paramfile = ajAcdGetInfile("paramfile");
eT = ajAcdGetFloat("temperature");
eGU = ajAcdGetBoolean("gu");
eclose = ajAcdGetBoolean("closegu");
lonely = ajAcdGetBoolean("lp");
convert = ajAcdGetBoolean("convert");
ensbases = ajAcdGetString("nsbases");
etloop = ajAcdGetBoolean("tetraloop");
eenergy = ajAcdGetListSingle("energy");
escale = ajAcdGetFloat("scale");
edangles = ajAcdGetListSingle("dangles");
/* dimers = ajAcdGetBoolean("dimers"); */
/* paired = ajAcdGetBoolean("paired"); */
outf = ajAcdGetOutfile("outfile");
essfile = ajAcdGetOutfile("ssoutfile");
/* concfile = ajAcdGetInfile("concentrationfile"); */
/* dotfile = ajAcdGetOutfile("dotoutfile"); */
/*
aoutf = ajAcdGetOutfile("aoutfile");
aaoutf = ajAcdGetOutfile("aaoutfile");
boutf = ajAcdGetOutfile("boutfile");
bboutf = ajAcdGetOutfile("bboutfile");
aboutf = ajAcdGetOutfile("aboutfile");
*/
do_backtrack = 1;
pf = 0;
doT = 0;
doC = 0;
cofi = 0;
doQ = 0;
string = NULL;
Concfile = NULL;
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;
ewt = *ajStrGetPtr(eenergy);
if(ewt == '0')
energy_set = 0;
else if(ewt == '1')
energy_set = 1;
else if(ewt == '2')
energy_set = 2;
sfact = (double) escale;
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!='\0')
{
if (*c!=',')
{
nonstandards[i++]=*c++;
nonstandards[i++]=*c;
if ((sym)&&(*c!=*(c-1)))
{
nonstandards[i++]=*c;
nonstandards[i++]=*(c-1);
}
}
c++;
}
}
cut_point = -1;
ajFmtPrintS(&seqstring1,"%s&%s",ajSeqGetSeqC(seq1),ajSeqGetSeqC(seq2));
string = tokenize(MAJSTRGETPTR(seqstring1)); /* frees line */
length = (int) strlen(string);
if (doC)
{
ConcAandB = read_concentrations(concfile);
}
structure = (char *) space((unsigned) length+1);
if(confile1)
{
vienna_GetConstraints(confile1,&constring1);
vienna_GetConstraints(confile2,&constring2);
ajStrAppendK(&constring1,'&');
ajStrAppendS(&constring1,constring2);
cstruc = tokenize(MAJSTRGETPTR(constring1));
if (cstruc!=NULL)
strncpy(structure, cstruc, length);
else
ajFatal("Constraints missing\n");
}
for (l = 0; l < length; l++)
{
string[l] = toupper(string[l]);
if (!noconv && string[l] == 'T') string[l] = 'U';
}
/*compute mfe of AB dimer*/
min_en = cofold(string, structure);
mfAB=(struct plist *) space(sizeof(struct plist) * (length+1));
mfAB=get_mfe_plist(mfAB);
if (cut_point == -1)
ajFmtPrintF(outf,"%s\n%s", string, structure); /*no cofold*/
else
{
char *pstring, *pstruct;
pstring = costring(string);
pstruct = costring(structure);
ajFmtPrintF(outf,"%s\n%s", pstring, pstruct);
free(pstring);
free(pstruct);
}
ajFmtPrintF(outf," (%6.2f)\n", min_en);
if (length<2000)
(void) PS_rna_plot(string, structure, essfile);
else
{
ajWarn("Structure too long, not doing xy_plot\n");
free_co_arrays();
}
/*compute partition function*/
if (pf)
{
cofoldF AB, AA, BB;
if (dangles==1)
{
dangles=2; /* recompute with dangles as in pf_fold() */
min_en = energy_of_struct(string, structure);
dangles=1;
}
kT = (temperature+273.15)*1.98717/1000.; /* in Kcal */
pf_scale = exp(-(sfact*min_en)/kT/length);
if (length>2000)
ajWarn("scaling factor %f\n", pf_scale);
init_co_pf_fold(length);
if (cstruc!=NULL)
strncpy(structure, cstruc, length+1);
AB = co_pf_fold(string, structure);
if (do_backtrack)
{
char *costruc;
costruc = (char *) space(sizeof(char)*(strlen(structure)+2));
if (cut_point<0)
ajFmtPrintF(outf,"%s", structure);
else
{
strncpy(costruc, structure, cut_point-1);
strcat(costruc, "&");
strcat(costruc, structure+cut_point-1);
ajFmtPrintF(outf,"%s", costruc);
}
ajFmtPrintF(outf," [%6.2f]\n", AB.FAB);
}
if ((istty)||(!do_backtrack))
ajFmtPrintF(outf," free energy of ensemble = %6.2f kcal/mol\n",
AB.FAB);
ajFmtPrintF(outf," frequency of mfe structure in ensemble %g",
exp((AB.FAB-min_en)/kT));
ajFmtPrintF(outf," , delta G binding=%6.2f\n", AB.FcAB - AB.FA - AB.FB);
prAB=(struct plist *) space(sizeof(struct plist) * (2*length));
prAB=get_plist(prAB, length,0.00001);
/* if (doQ) make_probsum(length,fname); */ /*compute prob of base paired*/
/* free_co_arrays(); */
if (doT)
{ /* cofold of all dimers, monomers */
int Blength, Alength;
char *Astring, *Bstring;
char *Newstring;
/*char Newname[30];*/
char comment[80];
if (cut_point<0)
{
free(mfAB);
free(prAB);
ajFatal("Sorry, I cannot do that with only one molecule, "
"please give me two\n");
}
if (dangles==1)
dangles=2;
Alength=cut_point-1; /*length of first molecule*/
Blength=length-cut_point+1; /*length of 2nd molecule*/
/*Sequence of first molecule*/
Astring=(char *)space(sizeof(char)*(Alength+1));
/*Sequence of second molecule*/
Bstring=(char *)space(sizeof(char)*(Blength+1));
strncat(Astring,string,Alength);
strncat(Bstring,string+Alength,Blength);
/* compute AA dimer */
prAA=(struct plist *) space(sizeof(struct plist) * (4*Alength));
mfAA=(struct plist *) space(sizeof(struct plist) * (Alength+1));
AA=do_partfunc(Astring, Alength, 2, &prAA, &mfAA);
/* compute BB dimer */
prBB=(struct plist *) space(sizeof(struct plist) * (4*Blength));
mfBB=(struct plist *) space(sizeof(struct plist) * (Blength+1));
BB=do_partfunc(Bstring, Blength, 2, &prBB, &mfBB);
/*free_co_pf_arrays();*/
/* compute A monomer */
prA=(struct plist *) space(sizeof(struct plist) * (2*Alength));
mfA=(struct plist *) space(sizeof(struct plist) * (Alength+1));
do_partfunc(Astring, Alength, 1, &prA, &mfA);
/* compute B monomer */
prB=(struct plist *) space(sizeof(struct plist) * (2*Blength));
mfB=(struct plist *) space(sizeof(struct plist) * (Blength+1));
do_partfunc(Bstring, Blength, 1, &prB, &mfB);
compute_probabilities(AB.F0AB, AB.FA, AB.FB, prAB, prA, prB,
Alength);
compute_probabilities(AA.F0AB, AA.FA, AA.FA, prAA, prA, prA,
Alength);
compute_probabilities(BB.F0AB, BB.FA, BB.FA, prBB, prA, prB,
Blength);
ajFmtPrintF(outf,"Free Energies:\nAB\t\tAA\t\tBB\t\tA\t\tB\n%.6f"
"\t%6f\t%6f\t%6f\t%6f\n",
AB.FcAB, AA.FcAB, BB.FcAB, AB.FA, AB.FB);
if (doC)
{
do_concentrations(AB.FcAB, AA.FcAB, BB.FcAB, AB.FA, AB.FB,
ConcAandB, outf);
free(ConcAandB);/*freeen*/
}
/*AB dot_plot*/
/*write Free Energy into comment*/
sprintf(comment,"\n%%Heterodimer AB FreeEnergy= %.9f\n", AB.FcAB);
/*reset cut_point*/
cut_point=Alength+1;
(void)PS_dot_plot_list(string, aboutf, prAB, mfAB, comment);
/*AA dot_plot*/
sprintf(comment,"\n%%Homodimer AA FreeEnergy= %.9f\n",AA.FcAB);
/*write AA sequence*/
Newstring=(char*)space((2*Alength+1)*sizeof(char));
strcpy(Newstring,Astring);
strcat(Newstring,Astring);
(void)PS_dot_plot_list(Newstring, aaoutf, prAA, mfAA, comment);
free(Newstring);
/*BB dot_plot*/
sprintf(comment,"\n%%Homodimer BB FreeEnergy= %.9f\n",BB.FcAB);
/*write BB sequence*/
Newstring=(char*)space((2*Blength+1)*sizeof(char));
strcpy(Newstring,Bstring);
strcat(Newstring,Bstring);
/*reset cut_point*/
cut_point=Blength+1;
(void)PS_dot_plot_list(Newstring, bboutf, prBB, mfBB, comment);
free(Newstring);
/*A dot plot*/
/*reset cut_point*/
cut_point=-1;
sprintf(comment,"\n%%Monomer A FreeEnergy= %.9f\n",AB.FA);
/*write A sequence*/
(void)PS_dot_plot_list(Astring, aoutf, prA, mfA, comment);
/*B monomer dot plot*/
sprintf(comment,"\n%%Monomer B FreeEnergy= %.9f\n",AB.FB);
/*write B sequence*/
(void)PS_dot_plot_list(Bstring, boutf, prB, mfB, comment);
free(Astring);
free(Bstring);
free(prAB);
free(prAA);
free(prBB);
free(prA);
free(prB);
free(mfAB);
free(mfAA);
free(mfBB);
free(mfA);
free(mfB);
} /*end if(doT)*/
}/*end if(pf)*/
if (do_backtrack)
{
if (!doT)
{
if (pf)
{
(void) PS_dot_plot_list(string, dotfile, prAB, mfAB, "doof");
free(prAB);
}
free(mfAB);
}
}
if (!doT)
free_co_pf_arrays();
if (cstruc!=NULL)
free(cstruc);
free(string);
free(structure);
ajStrDel(&seqstring1);
ajStrDel(&constring1);
ajStrDel(&constring2);
ajSeqDel(&seq1);
ajSeqDel(&seq2);
ajStrDel(&ensbases);
ajStrDel(&eenergy);
ajStrDel(&edangles);
ajFileClose(&confile1);
ajFileClose(&confile2);
ajFileClose(¶mfile);
ajFileClose(&outf);
ajFileClose(&essfile);
if (length<2000)
free_co_arrays();
embExit();
return 0;
}
static AjBool assemoutWriteSamAlignment(AjPFile outf, const AjPAssemRead r,
AjPAssemContig const * contigs,
ajint ncontigs)
{
AjPAssemTag t = NULL;
AjIList l = NULL;
AjPStr qualstr = NULL;
AjPStr tmp = NULL;
ajint POS = 0;
AjPStr CIGAR = NULL;
const char* RNEXT = NULL;
AjPStr SEQ = NULL;
AjPStr QUAL = NULL;
AjPStr SEQunpadded = NULL;
AjPStr QUALunpadded = NULL;
AjPStr consensus = NULL;
AjBool rc= ajFalse;
AjBool ret = ajTrue;
const char* refseq = NULL;
const AjPAssemContig contig = NULL;
ajuint k = 0;
if(r->Reference>=ncontigs)
ajDie("assemoutWriteSamAlignment: reference sequence number"
" '%d' is larger than or equal to known number of reference"
" sequences '%d'. Problem while processing read '%S'.",
r->Reference,
ncontigs,
r->Name);
contig = (r->Reference==-1 ? NULL : contigs[r->Reference]);
ajStrAssignRef(&SEQ, r->Seq);
consensus = contig==NULL? NULL : contig->Consensus;
if (r->Rnext==-1)
RNEXT= "*";
else if(r->Rnext==r->Reference)
RNEXT = "=";
else
RNEXT = ajStrGetPtr(contigs[r->Rnext]->Name);
if (r->Flag & BAM_FREVERSE)
{
rc = ajTrue;
qualstr = ajStrNewS(r->SeqQ);
if(!r->Reversed)
{
ajStrReverse(&qualstr);
ajSeqstrReverse(&SEQ);
}
QUAL = qualstr;
POS = r->y1;
ajStrAssignSubS(&tmp, SEQ,
ajStrGetLen(r->Seq) - r->y2,
ajStrGetLen(r->Seq) - r->x2
);
}
else
{
rc= ajFalse;
POS = r->x1;
QUAL = r->SeqQ;
ajStrAssignSubS(&tmp, SEQ,
r->x2-1,
r->y2-1
);
}
if(r->Cigar==NULL && consensus)
{
refseq = ajStrGetPtr(consensus) + (rc ? r->y1-1 : r->x1-1);
CIGAR = assemoutMakeCigar(refseq, ajStrGetPtr(tmp));
SEQunpadded = ajStrNewRes(ajStrGetLen(SEQ));
QUALunpadded = ajStrNewRes(ajStrGetLen(SEQ));
for(k=0; k< ajStrGetLen(SEQ); k++)
{
if (ajStrGetCharPos(SEQ, k) == '*')
continue;
ajStrAppendK(&SEQunpadded, ajStrGetCharPos(SEQ, k));
ajStrAppendK(&QUALunpadded, ajStrGetCharPos(QUAL, k));
}
ajDebug("cigar: %S\n", CIGAR);
ajStrAssignS(&tmp, CIGAR);
if(rc)
{
if(r->y2 < (ajint)ajStrGetLen(SEQ))
ajFmtPrintS(&CIGAR, "%dS%S",
ajStrGetLen(SEQ) - r->y2, tmp);
if(r->x2 > 1)
ajFmtPrintAppS(&CIGAR, "%dS", r->x2 - 1);
}
else
{
if(r->x2 > 1)
ajFmtPrintS(&CIGAR, "%dS%S", r->x2 - 1, tmp);
if(r->y2 < (ajint)ajStrGetLen(SEQ))
ajFmtPrintAppS(&CIGAR, "%dS",
ajStrGetLen(SEQ) - r->y2);
}
ajStrDel(&tmp);
}
else if(r->Cigar==NULL)
{
ajErr("both CIGAR string and consensus sequence not available");
ret = ajFalse;
ajStrAssignK(&CIGAR, '*');
}
else if(!ajStrGetLen(r->Cigar))
ajStrAssignK(&CIGAR, '*');
else if(ajStrGetLen(r->Cigar))
{
if(!ajStrGetLen(SEQ))
ajStrAssignK(&SEQ, '*');
if(!ajStrGetLen(QUAL))
ajStrAssignK(&QUAL, '*');
}
ajStrDel(&tmp);
ajFmtPrintF(outf, "%S\t%d\t%s\t%d\t%d\t%S\t%s\t%Ld\t%d\t%S\t%S",
r->Name,
r->Flag,
(contig==NULL ? "*" : ajStrGetPtr(contig->Name)),
POS,
r->MapQ,
(CIGAR ? CIGAR : r->Cigar),
RNEXT,
r->Pnext,
r->Tlen,
(r->Cigar ? SEQ : SEQunpadded),
(r->Cigar ? QUAL : QUALunpadded));
l = ajListIterNewread(r->Tags);
while (!ajListIterDone(l))
{
t = ajListIterGet(l);
/* TODO: array type, 'B' */
/* In SAM, all single integer types are mapped to int32_t [SAM spec] */
ajFmtPrintF(outf, "\t%S:%c:",
t->Name,
(t->type == 'c' || t->type == 'C' ||
t->type == 's' || t->type == 'S'
|| t->type == 'I') ? 'i' : t->type
);
if(t->x1 || t->y1)
ajFmtPrintF(outf, " %u %u", t->x1, t->y1);
if(t->Comment && ajStrGetLen(t->Comment)>0)
ajFmtPrintF(outf, "%S", t->Comment);
}
ajListIterDel(&l);
ajFmtPrintF(outf, "\n");
if(qualstr)
ajStrDel(&qualstr);
ajStrDel(&SEQ);
ajStrDel(&CIGAR);
ajStrDel(&SEQunpadded);
ajStrDel(&QUALunpadded);
return ret;
}
void embConsCalc(const AjPSeqset seqset,const AjPMatrix cmpmatrix,
ajint nseqs, ajint mlen,float fplural,float setcase,
ajint identity, AjBool gaps, AjPStr *cons)
{
ajint i;
ajint j;
ajint k;
ajint **matrix;
ajint m1 = 0;
ajint m2 = 0;
ajint highindex;
ajint matsize;
ajint matchingmaxindex;
ajint identicalmaxindex;
float max;
float contri = 0;
float contrj = 0;
float *identical;
float *matching;
AjPSeqCvt cvt = 0;
AjPFloat score = NULL;
const char **seqcharptr;
char res;
char nocon = '-';
void *freeptr;
matrix = ajMatrixGetMatrix(cmpmatrix);
cvt = ajMatrixGetCvt(cmpmatrix); /* return conversion table */
matsize = ajMatrixGetSize(cmpmatrix);
AJCNEW(seqcharptr,nseqs);
AJCNEW(identical,matsize);
AJCNEW(matching,matsize);
score = ajFloatNew();
if(ajSeqsetIsNuc(seqset)) /* set non-consensus character */
nocon = 'N';
else if ( ajSeqsetIsProt(seqset))
nocon = 'X';
for(i=0;i<nseqs;i++) /* get sequence as string */
seqcharptr[i] = ajSeqsetGetseqSeqC(seqset, i);
for(k=0; k< mlen; k++)
{
res = nocon;
for(i=0;i<matsize;i++) /* reset id's and +ve matches */
{
identical[i] = 0.0;
matching[i] = 0.0;
}
for(i=0;i<nseqs;i++)
ajFloatPut(&score,i,0.);
for(i=0;i<nseqs;i++) /* generate score for columns */
{
m1 = ajSeqcvtGetCodeK(cvt,seqcharptr[i][k]);
if(m1 || gaps)
identical[m1] += ajSeqsetGetseqWeight(seqset,i);
for(j=i+1;j<nseqs;j++)
{
m2 = ajSeqcvtGetCodeK(cvt,seqcharptr[j][k]);
if(m1 && m2)
{
contri = (float)matrix[m1][m2]*
ajSeqsetGetseqWeight(seqset,j)
+ajFloatGet(score,i);
contrj = (float)matrix[m1][m2]*
ajSeqsetGetseqWeight(seqset,i)
+ajFloatGet(score,j);
ajFloatPut(&score,i,contri);
ajFloatPut(&score,j,contrj);
}
}
}
highindex = -1;
max = -(float)INT_MAX;
for(i=0;i<nseqs;i++)
if( ajFloatGet(score,i) > max ||
(ajFloatGet(score,i) == max &&
seqcharptr[highindex][k] == '-') )
{
highindex = i;
max = ajFloatGet(score,i);
}
for(i=0;i<nseqs;i++) /* find +ve matches in the column */
{
m1 = ajSeqcvtGetCodeK(cvt, seqcharptr[i][k]);
if(!matching[m1])
for(j=0;j<nseqs;j++)
{
/*
// if( i != j)
// {
// m2 = ajSeqcvtGetCodeK(cvt, seqcharptr[j][k]);
// if(m1 && m2 && matrix[m1][m2] > 0)
// matching[m1] += ajSeqsetGetseqWeight(seqset, j);
// }
*/
m2 = ajSeqcvtGetCodeK(cvt, seqcharptr[j][k]);
if(m1 && m2 && matrix[m1][m2] > 0)
matching[m1] += ajSeqsetGetseqWeight(seqset, j);
if(gaps && !m1 && !m2)
matching[m1] += ajSeqsetGetseqWeight(seqset, j);
}
}
matchingmaxindex = 0; /* get max matching and identical */
identicalmaxindex = 0;
for(i=0;i<nseqs;i++)
{
m1 = ajSeqcvtGetCodeK(cvt,seqcharptr[i][k]);
if(identical[m1] > identical[identicalmaxindex])
identicalmaxindex = m1;
}
for(i=0;i<nseqs;i++)
{
m1 = ajSeqcvtGetCodeK(cvt,seqcharptr[i][k]);
if(matching[m1] > matching[matchingmaxindex])
matchingmaxindex = m1;
else if(matching[m1] == matching[matchingmaxindex])
if(identical[m1] > identical[matchingmaxindex])
matchingmaxindex = m1;
}
/* plurality check */
m1 = ajSeqcvtGetCodeK(cvt,seqcharptr[highindex][k]);
/* if(matching[m1] >= fplural
&& seqcharptr[highindex][k] != '-')
res = seqcharptr[highindex][k];*/
if(matching[m1] >= fplural)
res = seqcharptr[highindex][k];
if(matching[m1]<= setcase)
res = tolower((int)res);
if(identity) /* if just looking for id's */
{
j = 0;
for(i=0;i<nseqs;i++)
if(matchingmaxindex == ajSeqcvtGetCodeK(cvt,seqcharptr[i][k]))
j++;
if(j<identity)
res = nocon;
}
ajStrAppendK(cons,res);
}
freeptr = (void *) seqcharptr;
AJFREE(freeptr);
AJFREE(matching);
AJFREE(identical);
ajFloatDel(&score);
return;
}
