int main(int argc, char **argv)
{
/* Variable Declarations */
AjPSeqset seqset = NULL;
AjPSeqout seqout = NULL;
AjBool bigfirst;
ajuint nseqs;
ajuint i;
/* ACD File Processing */
embInit("sizeseq", argc, argv);
seqset = ajAcdGetSeqset("sequences");
bigfirst = ajAcdGetBoolean("descending");
seqout = ajAcdGetSeqoutall("outseq");
/* Application logic */
ajSeqsetSortLen(seqset);
nseqs = ajSeqsetGetSize(seqset);
if(bigfirst)
{
for(i=nseqs; i>0; i--)
ajSeqoutWriteSeq(seqout, ajSeqsetGetseqSeq(seqset,i-1));
}
else
{
for(i=0; i<nseqs; i++)
ajSeqoutWriteSeq(seqout, ajSeqsetGetseqSeq(seqset,i));
}
/* Memory management and exit */
ajSeqsetDel(&seqset);
ajSeqoutClose(seqout);
ajSeqoutDel(&seqout);
embExit();
return 0;
}
/* @funcstatic skipredundant_SeqsetToList **************************************
**
** Builds a list of sequences from a sequence set.
** The sequences are NOT copied (only a reference is pushed onto the list)
**
** @param [u] list [AjPList] List
** @param [w] seqset [AjPSeqset] Sequence set
** @return [AjBool] True on success
******************************************************************************/
static AjBool skipredundant_SeqsetToList (AjPList list, AjPSeqset seqset)
{
ajint n = 0;
ajint x = 0;
EmbPDmxNrseq seq_tmp = NULL; /* Temp. pointer for making seq_list. */
if(!list || !seqset)
return ajFalse;
n = ajSeqsetGetSize(seqset);
for(x=0; x<n; x++)
{
seq_tmp = embDmxNrseqNew(ajSeqsetGetseqSeq(seqset, x));
ajListPushAppend(list, seq_tmp);
seq_tmp = NULL;
}
return ajTrue;
}
static int infoalign_Getrefseq(const AjPStr refseq, const AjPSeqset seqset)
{
ajint i;
const AjPSeq seq;
for(i=0; i<(ajint)ajSeqsetGetSize(seqset); i++)
{
seq = ajSeqsetGetseqSeq(seqset, i);
if(!ajStrCmpS(ajSeqGetNameS(seq), refseq))
return i;
}
/* not a name of a sequence, so it must be a number */
if(!ajStrToInt(refseq, &i))
ajFatal("Reference sequence is not a sequence ID or a number: %S",
refseq);
if(i < 0 || i > (ajint) ajSeqsetGetSize(seqset))
ajFatal("Reference sequence number < 0 or > number "
"of input sequences: %d", i);
return i-1;
}
int main(int argc, char **argv)
{
/* Variable Declarations */
AjPSeqset seqset = NULL;
AjPMatrixf fmat = NULL;
float thresh;
float threshlow;
float threshup;
float gapopen;
float gapextend;
AjPSeqout seqout = NULL;
AjPSeqout seqoutred = NULL;
AjPStr mode = NULL;
ajint moden;
ajuint i;
/* toggle "feature" from ACD not retrieved ... no need */
const AjPSeq seq = NULL;
AjPList list = NULL; /* List for redundancy removal. */
AjPUint keep = NULL; /* 1: Sequence in list was non-redundant,
0: redundant. */
ajuint nseq = 0; /* No. seqs. in list. */
ajint nseqnr = 0; /* No. non-redundant seqs. in list. */
/* ACD File Processing */
embInit("skipredundant", argc, argv);
seqset = ajAcdGetSeqset("sequences");
mode = ajAcdGetListSingle("mode");
fmat = ajAcdGetMatrixf("datafile");
thresh = ajAcdGetFloat("threshold");
threshlow = ajAcdGetFloat("minthreshold");
threshup = ajAcdGetFloat("maxthreshold");
gapopen = ajAcdGetFloat("gapopen");
gapextend = ajAcdGetFloat("gapextend");
seqout = ajAcdGetSeqoutall("outseq");
seqoutred = ajAcdGetSeqoutall("redundantoutseq");
/* Application logic */
list = ajListNew();
skipredundant_SeqsetToList(list, seqset);
keep = ajUintNew();
ajStrToInt(mode, &moden);
if(moden == 1)
/* Remove redundancy at a single threshold % sequence similarity */
{
if((!embDmxSeqNR(list, &keep, &nseqnr, fmat, gapopen,
gapextend, thresh, ajFalse)))
ajFatal("embDmxSeqNR unexpected failure!");
}
else if (moden == 2)
/* 2: Remove redundancy outside a range of acceptable threshold % similarity */
{
if((!embDmxSeqNRRange(list, &keep, &nseqnr, fmat, gapopen,
gapextend, threshlow, threshup, ajFalse)))
ajFatal("embDmxSeqNRRange unexpected failure!");
}
else
ajFatal("Invalid mode (not 1 or 2) which should never occur (check ACD file!)");
nseq = ajSeqsetGetSize(seqset);
for(i=0; i<nseq; i++)
{
seq = ajSeqsetGetseqSeq(seqset, i);
if(ajUintGet(keep, i))
ajSeqoutWriteSeq(seqout, seq);
else if(seqoutred)
ajSeqoutWriteSeq(seqoutred, seq);
}
/* Memory management and exit */
ajSeqsetDel(&seqset);
ajMatrixfDel(&fmat);
ajStrDel(&mode);
ajSeqoutClose(seqout);
ajSeqoutDel(&seqout);
if(seqoutred)
{
ajSeqoutClose(seqoutred);
ajSeqoutDel(&seqoutred);
}
skipredundant_ClearList(list);
ajListFree(&list);
ajUintDel(&keep);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPSeqset seq1;
AjPSeqset seq2;
AjPFile list;
ajint n1;
ajint n2;
ajint *lengths1;
ajint *lengths2;
ajuint *order1;
ajuint *order2;
ajint *hits1;
ajint *hits2;
ajint curr1;
ajint curr2;
ajint tmp1;
ajint tmp2 = 0;
ajint i;
AjPStr operator;
ajint OperatorCode=0;
embInit("listor", argc, argv);
seq1 = ajAcdGetSeqset("firstsequences");
seq2 = ajAcdGetSeqset("secondsequences");
list = ajAcdGetOutfile("outfile");
operator = ajAcdGetListSingle("operator");
/* get the operator value */
switch(ajStrGetCharFirst(operator))
{
case 'O':
OperatorCode = L_OR;
break;
case 'A':
OperatorCode = L_AND;
break;
case 'X':
OperatorCode = L_XOR;
break;
case 'N':
OperatorCode = L_NOT;
break;
default:
ajFatal("Invalid operator type: %S", operator);
embExitBad();
}
/* get the order of seqset 1 by length */
n1 = ajSeqsetGetSize(seq1);
/* lengths of seq1 entries */
lengths1 = AJCALLOC0(n1, sizeof(ajint));
/* seq1 entries which match seq2 */
hits1 = AJCALLOC0(n1, sizeof(ajint));
/* seq1 entries in length order */
order1 = AJCALLOC0(n1, sizeof(ajint));
for(i=0; i<n1; i++)
{
lengths1[i] = ajSeqGetLen(ajSeqsetGetseqSeq(seq1, i));
order1[i] = i;
hits1[i] = -1;
}
ajSortIntIncI(lengths1, order1, n1);
/* get the order of seqset 2 by length */
n2 = ajSeqsetGetSize(seq2);
lengths2 = AJCALLOC0(n2, sizeof(ajint));
hits2 = AJCALLOC0(n2, sizeof(ajint));
order2 = AJCALLOC0(n2, sizeof(ajint));
for(i=0; i<n2; i++)
{
lengths2[i] = ajSeqGetLen(ajSeqsetGetseqSeq(seq2, i));
order2[i] = i;
hits2[i] = -1;
}
ajSortIntIncI(lengths2, order2, n2);
/*
** go down the two sequence sets, by size order, looking for identical
**lengths
*/
curr1 = 0;
curr2 = 0;
while(curr1 < n1 && curr2 < n2)
{
if(lengths1[order1[curr1]] < lengths2[order2[curr2]])
/* seq1 is shorter - increment curr1 index */
curr1++;
else if(lengths1[order1[curr1]] > lengths2[order2[curr2]])
/* seq2 is shorter - increment curr2 index */
curr2++;
else
{
/* identical lengths - check all seq1/seq2 entries of this len */
for(tmp1=curr1; tmp1<n1
&& lengths1[order1[tmp1]] == lengths2[order2[curr2]]; tmp1++)
for(tmp2=curr2; tmp2<n2 && lengths2[order2[tmp2]] ==
lengths2[order2[curr2]]; tmp2++)
/* check to see if the sequences are identical */
if(!ajStrCmpCaseS(ajSeqGetSeqS(ajSeqsetGetseqSeq(seq1,
order1[tmp1])),
ajSeqGetSeqS(ajSeqsetGetseqSeq(seq2,
order2[tmp2]))))
{
hits1[order1[tmp1]] = order2[tmp2];
hits2[order2[tmp2]] = order1[tmp1];
}
curr1 = tmp1;
curr2 = tmp2;
}
}
/* output the required entries to the list file */
listor_Output(list, OperatorCode, seq1, seq2, hits1, hits2, n1, n2);
AJFREE(lengths1);
AJFREE(lengths2);
AJFREE(order1);
AJFREE(order2);
AJFREE(hits1);
AJFREE(hits2);
ajFileClose(&list);
ajStrDel(&operator);
ajSeqsetDel(&seq1);
ajSeqsetDel(&seq2);
embExit();
return 0;
}
static void listor_Write(AjPFile list, const AjPSeqset seqset, ajint i)
{
ajFmtPrintF(list, "%S\n", ajSeqGetUsaS(ajSeqsetGetseqSeq(seqset, i)));
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 nucseq; /* input nucleic sequences */
AjPSeqset protseq; /* input aligned protein sequences */
AjPSeqout seqout;
AjPSeq nseq; /* next nucleic sequence to align */
const AjPSeq pseq; /* next protein sequence use in alignment */
AjPTrn trnTable;
AjPSeq pep; /* translation of nseq */
AjPStr tablelist;
ajint table;
AjPSeqset outseqset; /* set of aligned nucleic sequences */
ajint proteinseqcount = 0;
AjPStr degapstr = NULL;
/* used to check if it matches with START removed */
AjPStr degapstr2 = NULL;
AjPStr codon = NULL; /* holds temporary codon to check if is START */
char aa; /* translated putative START codon */
ajint type; /* returned type of the putative START codon */
/* start position of guide protein in translation */
ajlong pos = 0;
AjPSeq newseq = NULL; /* output aligned nucleic sequence */
ajint frame;
embInit("tranalign", argc, argv);
nucseq = ajAcdGetSeqall("asequence");
protseq = ajAcdGetSeqset("bsequence");
tablelist = ajAcdGetListSingle("table");
seqout = ajAcdGetSeqoutset("outseq");
outseqset = ajSeqsetNew();
degapstr = ajStrNew();
/* initialise the translation table */
ajStrToInt(tablelist, &table);
trnTable = ajTrnNewI(table);
ajSeqsetFill(protseq);
while(ajSeqallNext(nucseq, &nseq))
{
if((pseq = ajSeqsetGetseqSeq(protseq, proteinseqcount++)) == NULL)
ajErr("No guide protein sequence available for "
"nucleic sequence %S",
ajSeqGetNameS(nseq));
ajDebug("Aligning %S and %S\n",
ajSeqGetNameS(nseq), ajSeqGetNameS(pseq));
/* get copy of pseq string with no gaps */
ajStrAssignS(°apstr, ajSeqGetSeqS(pseq));
ajStrRemoveGap(°apstr);
/*
** for each translation frame look for subset of pep that
** matches pseq
*/
for(frame = 1; frame <4; frame++)
{
ajDebug("trying frame %d\n", frame);
pep = ajTrnSeqOrig(trnTable, nseq, frame);
degapstr2 = ajStrNew();
ajStrAssignRef(°apstr2, degapstr);
pos = ajStrFindCaseS(ajSeqGetSeqS(pep), degapstr);
/*
** we might have a START codon that should be translated as 'M'
** we need to check if there is a match after a possible START
** codon
*/
if(pos == -1 && ajStrGetLen(degapstr) > 1 &&
(ajStrGetPtr(degapstr)[0] == 'M' ||
ajStrGetPtr(degapstr)[0] == 'm'))
{
/* see if pep minus the first character is a match */
ajStrCutStart(°apstr2, 1);
pos = ajStrFindCaseS(ajSeqGetSeqS(pep), degapstr2);
/*
** pos is >= 1 if we have a match that is after the first
** residue
*/
if(pos >= 1)
{
/* point back at the putative START Methionine */
pos--;
/* test if first codon is a START */
codon = ajStrNew();
ajStrAssignSubS(&codon, ajSeqGetSeqS(nseq),
(pos*3)+frame-1, (pos*3)+frame+2);
type = ajTrnCodonstrTypeS(trnTable, codon, &aa);
if(type != 1)
{
/* first codon is not a valid START, force a mismatch */
pos = -1;
}
ajStrDel(&codon);
}
else
{
/* force 'pos == 0' to be treated as a mismatch */
pos = -1;
}
}
ajStrDel(°apstr2);
ajSeqDel(&pep);
if(pos != -1)
break;
}
if(pos == -1)
ajErr("Guide protein sequence %S not found in nucleic sequence %S",
ajSeqGetNameS(pseq), ajSeqGetNameS(nseq));
else
{
ajDebug("got a match with frame=%d\n", frame);
/* extract the coding region of nseq with gaps */
newseq = ajSeqNew();
ajSeqSetNuc(newseq);
ajSeqAssignNameS(newseq, ajSeqGetNameS(nseq));
ajSeqAssignDescS(newseq, ajSeqGetDescS(nseq));
tranalign_AddGaps(newseq, nseq, pseq, (pos*3)+frame-1);
/* output the gapped nucleic sequence */
ajSeqsetApp(outseqset, newseq);
ajSeqDel(&newseq);
}
ajStrRemoveWhiteExcess(°apstr);
}
ajSeqoutWriteSet(seqout, outseqset);
ajSeqoutClose(seqout);
ajTrnDel(&trnTable);
ajSeqsetDel(&outseqset);
ajStrDel(°apstr);
ajStrDel(°apstr2);
ajSeqallDel(&nucseq);
ajSeqDel(&nseq);
ajSeqoutDel(&seqout);
ajSeqsetDel(&protseq);
ajStrDel(&tablelist);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPSeqset seqset = NULL;
AjPStr refseq; /* input name/number of reference sequence */
ajint nrefseq; /* numeric reference sequence */
AjPMatrix matrix; /* scoring matrix structure */
ajint **sub; /* integer scoring matrix */
AjPSeqCvt cvt = 0; /* conversion table for scoring matrix */
float identity;
ajint ident;
float fplural;
AjPStr cons;
AjPSeq consensus;
const AjPSeq ref;
const AjPSeq seq;
ajuint i;
AjBool html;
AjBool doheader;
AjBool dousa;
AjBool doname;
AjBool doseqlength;
AjBool doalignlength;
AjBool dogaps;
AjBool dogapcount;
AjBool doidcount;
AjBool dosimcount;
AjBool dodifcount;
AjBool dochange;
AjBool dodesc;
AjBool dowt;
ajint seqlength;
ajint alignlength;
ajint gaps;
ajint gapcount;
ajint idcount;
ajint simcount;
ajint difcount;
float change;
AjPFile outfile;
const AjPStr usa;
const AjPStr name;
AjPStr altusa; /* default name when the real name
is not known */
AjPStr altname;
AjPStr xxx = NULL;
embInit("infoalign", argc, argv);
seqset = ajAcdGetSeqset("sequence");
refseq = ajAcdGetString("refseq");
matrix = ajAcdGetMatrix("matrix");
ajSeqsetFill(seqset);
outfile = ajAcdGetOutfile("outfile");
html = ajAcdGetBoolean("html");
doheader = ajAcdGetBoolean("heading");
dousa = ajAcdGetBoolean("usa");
doname = ajAcdGetBoolean("name");
doseqlength = ajAcdGetBoolean("seqlength");
doalignlength = ajAcdGetBoolean("alignlength");
dogaps = ajAcdGetBoolean("gaps");
dogapcount = ajAcdGetBoolean("gapcount");
doidcount = ajAcdGetBoolean("idcount");
dosimcount = ajAcdGetBoolean("simcount");
dodifcount = ajAcdGetBoolean("diffcount");
dochange = ajAcdGetBoolean("change");
dodesc = ajAcdGetBoolean("description");
dowt = ajAcdGetBoolean("weight");
/* consensus parameters */
fplural = ajAcdGetFloat("plurality");
identity = ajAcdGetFloat("identity");
cons = ajStrNew();
consensus = ajSeqNew();
altusa = ajStrNewC("-");
altname = ajStrNewC("-");
/* get conversion table and scoring matrix */
cvt = ajMatrixGetCvt(matrix);
sub = ajMatrixGetMatrix(matrix);
/* get the number of the reference sequence */
nrefseq = infoalign_Getrefseq(refseq, seqset);
/* change the % plurality to the fraction of absolute total weight */
fplural = ajSeqsetGetTotweight(seqset) * fplural / 100;
/*
** change the % identity to the number of identical sequences at a
** position required for consensus
*/
ident = ajSeqsetGetSize(seqset) * (ajint)identity / 100;
/* get the consensus sequence */
embConsCalc(seqset, matrix, ajSeqsetGetSize(seqset), ajSeqsetGetLen(seqset),
fplural, 0.0, ident, ajFalse, &cons);
ajSeqAssignSeqS(consensus, cons);
ajSeqAssignNameS(consensus,(xxx=ajStrNewC("Consensus")));
/* get the reference sequence */
if(nrefseq == -1)
ref = consensus;
else
ref = ajSeqsetGetseqSeq(seqset, nrefseq);
/* start the HTML table */
if(html)
ajFmtPrintF(outfile,"<table border cellpadding=4 bgcolor="
"\"#FFFFF0\">\n");
/* print the header information */
if(doheader)
{
/* start the HTML table title line and output the Name header */
if(html)
ajFmtPrintF(outfile, "<tr>");
else
ajFmtPrintF(outfile, "%s", "# ");
if(dousa)
{
if(html)
ajFmtPrintF(outfile, "<th>USA</th>");
else
ajFmtPrintF(outfile, "%-16s", "USA");
}
if(doname)
{
if(html)
ajFmtPrintF(outfile, "<th>Name</th>");
else
ajFmtPrintF(outfile, "%-12s", "Name");
}
if(doseqlength)
{
if(html)
ajFmtPrintF(outfile, "<th>Sequence Length</th>");
else
ajFmtPrintF(outfile, "SeqLen\t");
}
if(doalignlength)
{
if(html)
ajFmtPrintF(outfile, "<th>Aligned Length</th>");
else
ajFmtPrintF(outfile, "AlignLen\t");
}
if(dogaps)
{
if(html)
ajFmtPrintF(outfile, "<th>Gaps</th>");
else
ajFmtPrintF(outfile, "Gaps\t");
}
if(dogapcount)
{
if(html)
ajFmtPrintF(outfile, "<th>Gap Length</th>");
else
ajFmtPrintF(outfile, "GapLen\t");
}
if(doidcount)
{
if(html)
ajFmtPrintF(outfile, "<th>Identity</th>");
else
ajFmtPrintF(outfile, "Ident\t");
}
if(dosimcount)
{
if(html)
ajFmtPrintF(outfile, "<th>Similarity</th>");
else
ajFmtPrintF(outfile, "Similar\t");
}
if(dodifcount)
{
if(html)
ajFmtPrintF(outfile, "<th>Difference</th>");
else
ajFmtPrintF(outfile, "Differ\t");
}
if(dochange)
{
if(html)
ajFmtPrintF(outfile, "<th>%% Change</th>");
else
ajFmtPrintF(outfile, "%% Change\t");
}
if(dowt)
{
if(html)
ajFmtPrintF(outfile, "<th>Weight</th>");
else
ajFmtPrintF(outfile, "Weight\t");
}
if(dodesc)
{
if(html)
ajFmtPrintF(outfile, "<th>Description</th>");
else
ajFmtPrintF(outfile, "Description");
}
/* end the HTML table title line */
if(html)
ajFmtPrintF(outfile, "</tr>\n");
else
ajFmtPrintF(outfile, "\n");
}
for(i=0; i<ajSeqsetGetSize(seqset); i++)
{
seq = ajSeqsetGetseqSeq(seqset, i);
/* get the usa ('-' if unknown) */
usa = ajSeqGetUsaS(seq);
if(ajStrGetLen(usa) == 0)
usa = altusa;
/* get the name ('-' if unknown) */
name = ajSeqGetNameS(seq);
if(ajStrGetLen(name) == 0)
name = altname;
/* get the stats from the comparison to the reference sequence */
infoalign_Compare(ref, seq, sub, cvt, &seqlength, &alignlength,
&gaps, &gapcount, &idcount, &simcount,
&difcount, &change);
/* start table line */
if(html)
ajFmtPrintF(outfile, "<tr>");
if(dousa)
infoalign_OutputStr(outfile, usa, html,
(dodesc || dowt || dochange ||
dodifcount || dosimcount ||
doidcount || dogapcount || dogaps ||
doseqlength || doalignlength || doname), 18);
if(doname)
infoalign_OutputStr(outfile, name, html,
(dodesc || dowt || dochange ||
dodifcount || dosimcount ||
doidcount || dogapcount || dogaps ||
doseqlength || doalignlength), 14);
if(doseqlength)
infoalign_OutputInt(outfile, seqlength, html,
(dodesc || dowt || dochange ||
dodifcount || dosimcount ||
doidcount || dogapcount ||
dogaps || doalignlength));
if(doalignlength)
infoalign_OutputInt(outfile, alignlength, html,
(dodesc || dowt || dochange ||
dodifcount || dosimcount ||
doidcount || dogapcount || dogaps));
if(dogaps)
infoalign_OutputInt(outfile, gaps, html,
(dodesc || dowt || dochange ||
dodifcount || dosimcount ||
doidcount || dogapcount));
if(dogapcount)
infoalign_OutputInt(outfile, gapcount, html,
(dodesc || dowt || dochange ||
dodifcount || dosimcount ||
doidcount));
if(doidcount)
infoalign_OutputInt(outfile, idcount, html,
(dodesc || dowt || dochange ||
dodifcount || dosimcount));
if(dosimcount)
infoalign_OutputInt(outfile, simcount, html,
(dodesc || dowt || dochange ||
dodifcount));
if(dodifcount)
infoalign_OutputInt(outfile, difcount, html,
(dodesc || dowt || dochange));
if(dochange)
infoalign_OutputFloat(outfile, change, html, (dodesc || dowt) );
if(dowt)
infoalign_OutputFloat(outfile, ajSeqsetGetseqWeight(seqset,i), html,
dodesc);
if(dodesc)
infoalign_OutputStr(outfile, ajSeqGetDescS(seq), html, ajFalse,
NOLIMIT);
/* end table line */
if(html)
ajFmtPrintF(outfile, "</tr>\n");
else
ajFmtPrintF(outfile, "\n");
}
/* end the HTML table */
if(html)
ajFmtPrintF(outfile, "</table>\n");
ajFileClose(&outfile);
/* tidy up */
ajStrDel(&altusa);
ajStrDel(&altname);
ajStrDel(&xxx);
ajSeqDel(&consensus);
ajSeqsetDel(&seqset);
ajStrDel(&refseq);
ajMatrixDel(&matrix);
ajStrDel(&cons);
embExit();
return 0;
}
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[])
{
char *string;
char *structure=NULL;
char *cstruc=NULL;
char *ns_bases=NULL;
char *c;
int n_seq;
int i;
int length;
int sym;
int endgaps = 0;
int mis = 0;
double min_en;
double real_en;
double sfact = 1.07;
int pf = 0;
int istty;
char *AS[MAX_NUM_NAMES]; /* aligned sequences */
char *names[MAX_NUM_NAMES]; /* sequence names */
AjPSeqset seq = NULL;
AjPFile confile = NULL;
AjPFile alifile = NULL;
AjPFile paramfile = NULL;
AjPFile outf = NULL;
AjPFile essfile = NULL;
AjPFile dotfile = NULL;
AjPStr constring = NULL;
float eT = 0.;
AjBool eGU;
AjBool eclose;
AjBool lonely;
AjPStr ensbases = NULL;
AjBool etloop;
AjPStr eenergy = NULL;
char ewt = '\0';
float escale = 0.;
AjPStr edangles = NULL;
char edangle = '\0';
ajint len;
AjPSeq tseq = NULL;
AjPStr tname = NULL;
int circ = 0;
int doAlnPS = 0;
int doColor = 0;
embInitPV("vrnaalifoldpf",argc,argv,"VIENNA",VERSION);
constring = ajStrNew();
seq = ajAcdGetSeqset("sequence");
confile = ajAcdGetInfile("constraintfile");
paramfile = ajAcdGetInfile("paramfile");
eT = ajAcdGetFloat("temperature");
eGU = ajAcdGetBoolean("gu");
eclose = ajAcdGetBoolean("closegu");
lonely = ajAcdGetBoolean("lp");
ensbases = ajAcdGetString("nsbases");
etloop = ajAcdGetBoolean("tetraloop");
eenergy = ajAcdGetListSingle("energy");
escale = ajAcdGetFloat("scale");
edangles = ajAcdGetListSingle("dangles");
mis = !!ajAcdGetBoolean("most");
endgaps = !!ajAcdGetBoolean("endgaps");
nc_fact = (double) ajAcdGetFloat("nspenalty");
cv_fact = (double) ajAcdGetFloat("covariance");
outf = ajAcdGetOutfile("outfile");
essfile = ajAcdGetOutfile("ssoutfile");
alifile = ajAcdGetOutfile("alignoutfile");
circ = !!ajAcdGetBoolean("circular");
doColor = !!ajAcdGetBoolean("colour");
dotfile = ajAcdGetOutfile("dotoutfile");
do_backtrack = 1;
pf = 1;
string = NULL;
istty = 0;
dangles = 2;
temperature = (double) eT;
noGU = (eGU) ? 0 : 1;
no_closingGU = (eclose) ? 0 : 1;
noLonelyPairs = (lonely) ? 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++;
}
}
if(alifile)
doAlnPS = 1;
if(confile)
vienna_GetConstraints(confile,&constring);
n_seq = ajSeqsetGetSize(seq);
if(n_seq > MAX_NUM_NAMES - 1)
ajFatal("[e]RNAalifold is restricted to %d sequences\n",
MAX_NUM_NAMES - 1);
if (n_seq==0)
ajFatal("No sequences found");
for(i=0;i<n_seq;++i)
{
tseq = (AjPSeq) ajSeqsetGetseqSeq(seq,i);
ajSeqGapStandard(tseq, '-');
tname = (AjPStr) ajSeqsetGetseqNameS(seq,i);
len = ajSeqGetLen(tseq);
AS[i] = (char *) space(len+1);
names[i] = (char *) space(ajStrGetLen(tname)+1);
strcpy(AS[i],ajSeqGetSeqC(tseq));
strcpy(names[i],ajStrGetPtr(tname));
}
AS[n_seq] = NULL;
names[n_seq] = NULL;
if (endgaps)
for (i=0; i<n_seq; i++)
mark_endgaps(AS[i], '~');
length = (int) strlen(AS[0]);
structure = (char *) space((unsigned) length+1);
if(confile)
{
fold_constrained = 1;
strcpy(structure,ajStrGetPtr(constring));
}
if (circ && noLonelyPairs)
ajWarn(
"warning, depending on the origin of the circular sequence, "
"some structures may be missed when using -noLP\n"
"Try rotating your sequence a few times\n");
if (circ)
min_en = circalifold((const char **)AS, structure);
else
min_en = alifold(AS, structure);
{
int i;
double s=0;
extern int eos_debug;
eos_debug=-1; /* shut off warnings about nonstandard pairs */
for (i=0; AS[i]!=NULL; i++)
if (circ)
s += energy_of_circ_struct(AS[i], structure);
else
s += energy_of_struct(AS[i], structure);
real_en = s/i;
}
string = (mis) ?
consens_mis((const char **) AS) : consensus((const char **) AS);
ajFmtPrintF(outf,"%s\n%s", string, structure);
ajFmtPrintF(outf," (%6.2f = %6.2f + %6.2f) \n", min_en, real_en,
min_en-real_en );
if (length<=2500) {
char **A;
A = annote(structure, (const char**) AS);
if (doColor)
(void) PS_rna_plot_a(string, structure, essfile, A[0], A[1]);
else
(void) PS_rna_plot_a(string, structure, essfile, NULL, A[1]);
free(A[0]); free(A[1]);free(A);
} else
ajWarn("INFO: structure too long, not doing xy_plot\n");
if (doAlnPS)
PS_color_aln(structure, alifile, AS, names);
{ /* free mfe arrays but preserve base_pair for PS_dot_plot */
struct bond *bp;
bp = base_pair; base_pair = space(16);
free_alifold_arrays(); /* free's base_pair */
free_alipf_arrays();
base_pair = bp;
}
if (pf) {
double energy, kT;
pair_info *pi;
char * mfe_struc;
mfe_struc = strdup(structure);
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_alipf_fold(length); */
if (confile)
strncpy(structure, ajStrGetPtr(constring), length+1);
energy = (circ) ? alipf_circ_fold(AS, structure, &pi) : alipf_fold(AS, structure, &pi);
if (do_backtrack) {
ajFmtPrintF(outf,"%s", structure);
ajFmtPrintF(outf," [%6.2f]\n", energy);
}
if ((istty)||(!do_backtrack))
ajFmtPrintF(outf," free energy of ensemble = %6.2f kcal/mol\n", energy);
ajFmtPrintF(outf," frequency of mfe structure in ensemble %g\n",
exp((energy-min_en)/kT));
if (do_backtrack) {
FILE *aliout;
cpair *cp;
short *ptable; int k;
ptable = make_pair_table(mfe_struc);
ajFmtPrintF(outf,"\n# Alignment section\n\n");
aliout = ajFileGetFileptr(outf);
fprintf(aliout, "%d sequences; length of alignment %d\n",
n_seq, length);
fprintf(aliout, "alifold output\n");
for (k=0; pi[k].i>0; k++) {
pi[k].comp = (ptable[pi[k].i] == pi[k].j) ? 1:0;
print_pi(pi[k], aliout);
}
fprintf(aliout, "%s\n", structure);
free(ptable);
cp = make_color_pinfo(pi);
(void) PS_color_dot_plot(string, cp, dotfile);
free(cp);
free(mfe_struc);
free(pi);
}
}
if (cstruc!=NULL) free(cstruc);
free(base_pair);
(void) fflush(stdout);
free(string);
free(structure);
for (i=0; AS[i]; i++) {
free(AS[i]); free(names[i]);
}
ajSeqsetDel(&seq);
ajStrDel(&constring);
ajStrDel(&eenergy);
ajStrDel(&edangles);
ajStrDel(&ensbases);
ajFileClose(&confile);
ajFileClose(¶mfile);
ajFileClose(&outf);
ajFileClose(&essfile);
ajFileClose(&alifile);
ajFileClose(&dotfile);
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;
}
void emboss_copy(AjPSeqset seqset, char ***retseqs, AINFO *info)
{
ajint n;
ajint maxlen;
ajint len;
char **seqs;
const AjPSeq seq = NULL;
ajint i=0;
const AjPStr fmt=NULL;
const char *p=NULL;
char c='\0';
/*
char *q=NULL;
AjPSelexseq sqdata=NULL;
AjPSelexdata sdata=NULL;
*/
ajint cnt=0;
info->name = NULL;
info->rf=NULL;
info->cs=NULL;
info->desc=NULL;
info->acc=NULL;
info->au=NULL;
info->flags=0;
AjPStr tmpstr = NULL;
ajSeqsetFill(seqset);
fmt = ajSeqsetGetFormat(seqset);
n = ajSeqsetGetSize(seqset);
ajSeqsetFmtUpper(seqset);
maxlen = ajSeqsetGetLen(seqset);
/* First allocate and copy sequences */
AJCNEW0(seqs,n);
for(i=0; i<n; ++i)
{
seqs[i] = ajCharNewRes(maxlen+1);
strcpy(seqs[i],ajSeqGetSeqC(ajSeqsetGetseqSeq(seqset,i)));
}
info->sqinfo = (SQINFO *) calloc (sizeof(SQINFO), n);
for(i=0; i<n; ++i)
{
info->sqinfo[i].flags = 0;
strcpy(info->sqinfo[i].name,"");
strcpy(info->sqinfo[i].id,"");
strcpy(info->sqinfo[i].acc,"");
strcpy(info->sqinfo[i].desc,"");
info->sqinfo[i].len = 0;
info->sqinfo[i].start = 0;
info->sqinfo[i].stop = 0;
info->sqinfo[i].olen = 0;
info->sqinfo[i].type = 0;
info->sqinfo[i].ss = NULL;
info->sqinfo[i].sa =NULL;
}
AJCNEW0(info->wgt,n);
for(i=0; i<n; ++i)
{
info->sqinfo[i].flags = 0;
info->wgt[i] = ajSeqsetGetseqWeight(seqset,i);
}
info->nseq = n;
info->alen = maxlen;
for(i=0; i<n; ++i)
{
seq = ajSeqsetGetseqSeq(seqset,i);
if((len=ajStrGetLen(ajSeqGetNameS(seq))))
{
if(len>= SQINFO_NAMELEN)
len = SQINFO_NAMELEN - 1;
ajStrAssignSubS(&tmpstr, ajSeqGetNameS(seq), 0, len);
strcpy(info->sqinfo[i].id,ajStrGetPtr(tmpstr));
info->sqinfo[i].flags |= SQINFO_ID;
strcpy(info->sqinfo[i].name,ajStrGetPtr(tmpstr));
info->sqinfo[i].flags |= SQINFO_NAME;
}
if((len=ajStrGetLen(ajSeqGetAccS(seq))))
{
if(len>= SQINFO_NAMELEN)
len = SQINFO_NAMELEN - 1;
ajStrAssignSubS(&tmpstr, ajSeqGetAccS(seq), 0, len);
strcpy(info->sqinfo[i].acc,ajStrGetPtr(tmpstr));
info->sqinfo[i].flags |= SQINFO_ACC;
}
}
seq = ajSeqsetGetseqSeq(seqset,0);
info->cs = ajCharNewS(ajSeqGetSeqS(seq));
info->name = ajCharNewS(ajSeqGetNameS(seq));
info->acc = ajCharNewS(ajSeqGetAccS(seq));
info->desc = ajCharNewS(ajSeqGetDescS(seq));
info->rf = ajCharNewS(ajSeqGetSeqS(seq));
/*
info->rf = ajCharNewS(seq);
len = ajStrGetLen(seq->Selexdata->name);
info->name = ajCharNewRes(len+1);
strcpy(info->name,ajStrGetPtr(seq->Selexdata->name));
len = ajStrGetLen(seq->Selexdata->de);
info->desc = ajCharNewRes(len+1);
sdata = seq->Selexdata;
strcpy(info->desc,ajStrGetPtr(sdata->de));
len = ajStrGetLen(sdata->ac);
info->acc = ajCharNewRes(len+1);
strcpy(info->acc,ajStrGetPtr(sdata->ac));
len = ajStrGetLen(sdata->au);
info->au = ajCharNewRes(len+1);
strcpy(info->au,ajStrGetPtr(sdata->au));
if(sdata->tc[0] || sdata->tc[1])
{
info->flags |= AINFO_TC;
info->tc1 = sdata->tc[0];
info->tc2 = sdata->tc[1];
}
if(sdata->nc[0] || sdata->nc[1])
{
info->flags |= AINFO_NC;
info->nc1 = sdata->nc[0];
info->nc2 = sdata->nc[1];
}
if(sdata->ga[0] || sdata->ga[1])
{
info->flags |= AINFO_GA;
info->ga1 = sdata->ga[0];
info->ga2 = sdata->ga[1];
}
for(i=0;i<n;++i)
{
seq = ajSeqsetGetseqSeq(seqset,i);
sqdata = seq->Selexdata->sq;
if((len=ajStrGetLen(sqdata->name)))
{
if(len<64)
strcpy(info->sqinfo[i].name,ajStrGetPtr(sqdata->name));
else
strncpy(info->sqinfo[i].name,ajStrGetPtr(sqdata->name),63);
info->sqinfo[i].name[63]='\0';
info->sqinfo[i].flags |= SQINFO_NAME;
}
/ *
if((len=ajStrGetLen(sqdata->id)))
{
if(len<64)
strcpy(info->sqinfo[i].id,ajStrGetPtr(sqdata->id));
else
strncpy(info->sqinfo[i]->id,ajStrGetPtr(sqdata->id),63);
info->sqinfo[i].id[63]='\0';
info->sqinfo[i].flags |= SQINFO_ID;
}
* /
strcpy(info->sqinfo[i].id,info->sqinfo[i].name);
info->sqinfo[i].flags |= SQINFO_ID;
if((len=ajStrGetLen(sqdata->ac)))
{
if(len<64)
strcpy(info->sqinfo[i].acc,ajStrGetPtr(sqdata->ac));
else
strncpy(info->sqinfo[i].acc,ajStrGetPtr(sqdata->ac),63);
info->sqinfo[i].acc[63]='\0';
info->sqinfo[i].flags |= SQINFO_ACC;
}
if((len=ajStrGetLen(sqdata->de)))
{
if(len<127)
strcpy(info->sqinfo[i].desc,ajStrGetPtr(sqdata->de));
else
strncpy(info->sqinfo[i].desc,ajStrGetPtr(sqdata->de),127);
info->sqinfo[i].desc[127]='\0';
info->sqinfo[i].flags |= SQINFO_DESC;
}
if(sqdata->start || sqdata->stop || sqdata ->len)
{
info->sqinfo[i].start = sqdata->start;
info->sqinfo[i].stop = sqdata->stop;
info->sqinfo[i].olen = sqdata->len;
info->sqinfo[i].flags |= SQINFO_START;
info->sqinfo[i].flags |= SQINFO_STOP;
info->sqinfo[i].flags |= SQINFO_OLEN;
}
if(ajStrGetLen(seq->Selexdata->ss))
{
info->sqinfo[i].ss = ajCharNewRes(maxlen+1);
p = ajStrGetPtr(seq->Selexdata->ss);
q = info->sqinfo[i].ss;
while((c==*p))
{
if(c=='.' || c==' ' || c=='_' || c=='-')
*q++ = c;
++p;
}
*q = '\0';
info->sqinfo[i].flags |= SQINFO_SS;
}
}
}
/ *
}
*/
for(i=0; i<n; ++i)
{
info->sqinfo[i].type = kOtherSeq;
if(ajSeqsetIsDna(seqset))
info->sqinfo[i].type = kDNA;
if(ajSeqsetIsRna(seqset))
info->sqinfo[i].type = kRNA;
if(ajSeqsetIsProt(seqset))
info->sqinfo[i].type = kAmino;
info->sqinfo[i].flags |= SQINFO_TYPE;
seq = ajSeqsetGetseqSeq(seqset,i);
p = ajSeqGetSeqC(seq);
cnt = 0;
while((c=*p))
{
if(!(c=='.' || c==' ' || c=='_' || c=='-' || c=='~'))
++cnt;
++p;
}
info->sqinfo[i].len = cnt;
info->sqinfo[i].flags |= SQINFO_LEN;
}
*retseqs = seqs;
ajStrDel(&tmpstr);
return;
}
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;
}