static void splitter_write(AjPSeqout default_seqout,
AjPSeq subseq, const AjPSeq seq)
{
/* set the description of the subsequence */
ajSeqAssignDescS(subseq, ajSeqGetDescS(seq));
/* set the type of the subsequence */
ajSeqType(subseq);
ajSeqoutWriteSeq(default_seqout, subseq);
return;
}
static void extractfeat_WriteOut(AjPSeqout seqout, AjPStr *featstr,
AjBool compall, AjBool sense, ajint firstpos,
ajint lastpos, ajint before, ajint after,
const AjPSeq seq, AjBool remote,
const AjPStr type,
AjBool featinname, const AjPStr describestr)
{
AjPSeq newseq = NULL;
AjPStr name = NULL; /* new name of the sequence */
AjPStr value = NULL; /* string value of start or end position */
AjPStr desc = NULL; /* sequence description */
AjBool forward = sense;
if(compall)
forward = ajFalse;
ajDebug("WriteOut %S_%d_%d [%S] %d all:%B fwd:%B remote:%B\n",
ajSeqGetNameS(seq), firstpos+1, lastpos+1, type,
ajStrGetLen(*featstr), compall, sense, remote);
/* see if there is a sequence to be written out */
if(!ajStrGetLen(*featstr))
{
ajWarn("feature %S_%d_%d [%S] "
"not written out because it has zero length\n",
ajSeqGetNameS(seq), firstpos+1, lastpos+1, type);
ajDebug("feature not written out because it has length=0 "
"(probably first time round)\n");
return;
}
/* see if must abort because there were Remote IDs in the features */
if(remote)
{
ajWarn("feature not written out because it has Remote IDs\n");
ajDebug("feature not written out because it has Remote IDs\n");
return;
}
ajDebug("feature = %d bases\n", ajStrGetLen(*featstr));
/* featstr may be edited, so it is a AjPStr* */
extractfeat_BeforeAfter (seq, featstr, firstpos, lastpos, before,
after, forward);
ajDebug("feature+before/after = %d bases\n", ajStrGetLen(*featstr));
/* set the extracted sequence */
newseq = ajSeqNew();
ajSeqAssignSeqS(newseq, *featstr);
/* create a nice name for the new sequence */
name = ajStrNew();
ajStrAppendS(&name, ajSeqGetNameS(seq));
ajStrAppendC(&name, "_");
value = ajStrNew();
ajStrFromInt(&value, firstpos+1);
ajStrAppendS(&name, value);
ajStrAppendC(&name, "_");
ajStrFromInt(&value, lastpos+1);
ajStrAppendS(&name, value);
/* add the type of feature to the name, if required */
if(featinname)
{
ajStrAppendC(&name, "_");
ajStrAppendS(&name, type);
}
ajSeqAssignNameS(newseq, name);
/* set the sequence description with the 'type' added */
desc = ajStrNew();
ajStrAppendC(&desc, "[");
ajStrAppendS(&desc, type);
ajStrAppendC(&desc, "] ");
if(ajStrGetLen(describestr))
ajStrAppendS(&desc, describestr);
ajStrAppendS(&desc, ajSeqGetDescS(seq));
ajSeqAssignDescS(newseq, desc);
/* set the type */
if(ajSeqIsNuc(seq))
ajSeqSetNuc(newseq);
else
ajSeqSetProt(newseq);
/* write the new sequence */
ajSeqoutWriteSeq(seqout, newseq);
ajSeqDel(&newseq);
ajStrDel(&name);
ajStrDel(&value);
ajStrDel(&desc);
return;
}
int main(int argc, char **argv)
{
AjPSeqout seqout;
AjPSeq seq;
AjPStr name = NULL;
AjPStr desc = NULL;
AjPStr temp = NULL;
AjBool append;
embInit("descseq", argc, argv);
seqout = ajAcdGetSeqout("outseq");
seq = ajAcdGetSeq("sequence");
append = ajAcdGetBoolean("append");
name = ajAcdGetString("name");
desc = ajAcdGetString("description");
/* if appending, then do this */
if(append)
{
/* is there a name? */
if(ajStrGetLen(name))
{
ajStrAssignS(&temp, ajSeqGetNameS(seq));
ajStrAppendS(&temp, name);
ajSeqAssignNameS(seq, temp);
}
/* is there a description? */
if(ajStrGetLen(desc))
{
ajStrAssignS(&temp, ajSeqGetDescS(seq));
ajStrAppendS(&temp, desc);
ajSeqAssignDescS(seq, temp);
}
/* otherwise, just overwrite the existing values */
}
else
{
/* is there a name? */
if(ajStrGetLen(name))
ajSeqAssignNameS(seq, name);
/* is there a description? */
if(ajStrGetLen(desc))
ajSeqAssignDescS(seq, desc);
}
ajSeqoutWriteSeq(seqout, seq);
ajSeqoutClose(seqout);
ajSeqDel(&seq);
ajSeqoutDel(&seqout);
ajStrDel(&name);
ajStrDel(&desc);
ajStrDel(&temp);
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)
{
AjPSeqall seqall;
AjPSeqout seqout;
AjPSeq seq = NULL;
AjPStr str = NULL;
AjPStr desc = NULL;
ajint tail3;
ajint tail5 = 0;
ajint minlength;
ajint mismatches;
AjBool reverse;
AjBool fiveprime;
AjBool cvttolower;
embInit("trimest", argc, argv);
seqall = ajAcdGetSeqall("sequence");
seqout = ajAcdGetSeqoutall("outseq");
minlength = ajAcdGetInt("minlength");
mismatches = ajAcdGetInt("mismatches");
reverse = ajAcdGetBoolean("reverse");
fiveprime = ajAcdGetBoolean("fiveprime");
cvttolower = ajAcdGetToggle("tolower");
str = ajStrNew();
while(ajSeqallNext(seqall, &seq))
{
/* get sequence description */
ajStrAssignS(&desc, ajSeqGetDescS(seq));
/* get positions to cut in 5' poly-T and 3' poly-A tails */
if(fiveprime)
tail5 = trimest_get_tail(seq, 5, minlength, mismatches);
tail3 = trimest_get_tail(seq, 3, minlength, mismatches);
/* get a COPY of the sequence string */
ajStrAssignS(&str, ajSeqGetSeqS(seq));
/* cut off longest of 3' or 5' tail */
if(tail5 > tail3)
{
/* if 5' poly-T tail, then reverse the sequence */
ajDebug("Tail=%d\n", tail5);
if(cvttolower)
trimest_tolower(&str, 0, tail5-1);
else
ajStrKeepRange(&str, tail5, ajSeqGetLen(seq)-1);
ajStrAppendC(&desc, " [poly-T tail removed]");
}
else if(tail3 > tail5)
{
/* remove 3' poly-A tail */
ajDebug("Tail=%d\n", tail3);
if(cvttolower)
trimest_tolower(&str, ajSeqGetLen(seq)-tail3,
ajSeqGetLen(seq));
else
ajStrKeepRange(&str, 0, ajSeqGetLen(seq)-tail3-1);
ajStrAppendC(&desc, " [poly-A tail removed]");
}
/* write sequence out */
ajSeqAssignSeqS(seq, str);
/* reverse complement if poly-T found */
if(tail5 > tail3 && reverse)
{
ajSeqReverseForce(seq);
ajStrAppendC(&desc, " [reverse complement]");
}
/* set description */
ajSeqAssignDescS(seq, desc);
ajSeqoutWriteSeq(seqout, seq);
}
ajSeqoutClose(seqout);
ajStrDel(&str);
ajStrDel(&desc);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajSeqoutDel(&seqout);
embExit();
return 0;
}
