int main(int argc, char **argv)
{
AjPSeqall seqall;
AjPSeqout seqout;
AjPSeqout junkout;
AjPSeq seq = NULL;
AjPStr exclude = NULL;
AjPStr pattern = NULL;
AjPStr name = NULL;
AjPStr acc = NULL;
embInit("notseq", argc, argv);
seqout = ajAcdGetSeqoutall("outseq");
junkout = ajAcdGetSeqoutall("junkoutseq");
seqall = ajAcdGetSeqall("sequence");
exclude = ajAcdGetString("exclude");
notseq_readfile(exclude, &pattern);
while(ajSeqallNext(seqall, &seq))
{
ajStrAssignS(&name, ajSeqGetNameS(seq));
ajStrAssignS(&acc, ajSeqGetAccS(seq));
if(embMiscMatchPatternDelimC(name, pattern, ",;") ||
embMiscMatchPatternDelimC(acc, pattern, ",;"))
ajSeqoutWriteSeq(junkout, seq);
else
/* no match, so not excluded */
ajSeqoutWriteSeq(seqout, seq);
ajStrSetClear(&name);
ajStrSetClear(&acc);
}
ajSeqoutClose(seqout);
ajSeqoutClose(junkout);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajSeqoutDel(&seqout);
ajSeqoutDel(&junkout);
ajStrDel(&exclude);
ajStrDel(&pattern);
ajStrDel(&name);
ajStrDel(&acc);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPSeqall seqall;
AjPSeqout seqout;
AjPSeq seq = NULL;
AjBool firstonly;
embInit("seqret", argc, argv);
seqout = ajAcdGetSeqoutall("outseq");
seqall = ajAcdGetSeqall("sequence");
firstonly = ajAcdGetBoolean("firstonly");
while(ajSeqallNext(seqall, &seq))
{
ajSeqoutWriteSeq(seqout, seq);
if(firstonly)
break;
}
ajSeqoutClose(seqout);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajSeqoutDel(&seqout);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPSeqout seqout;
AjPSeqall seqall;
AjPSeq seq = NULL;
embInit("seqretallfeat", argc, argv);
seqout = ajAcdGetSeqoutall("outseq");
seqall = ajAcdGetSeqall("sequence");
while (ajSeqallNext(seqall, &seq))
{
ajSeqoutWriteSeq(seqout, seq);
ajSeqTrace(seq);
}
ajSeqoutClose(seqout);
ajFeatTest();
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajSeqoutDel(&seqout);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPSeqall seqall;
AjPSeq a;
AjPSeqout outf;
AjPStr substr;
AjPStr back;
AjPStr gctable;
AjPCod codon = NULL;
ajint gctablenum;
ajint beg;
ajint end;
embInit("backtranambig", argc, argv);
seqall = ajAcdGetSeqall("sequence");
outf = ajAcdGetSeqoutall("outfile");
gctable = ajAcdGetListSingle("table");
ajStrToInt(gctable, &gctablenum);
codon = ajCodNewCodenum(gctablenum);
while(ajSeqallNext(seqall, &a))
{
substr = ajStrNew();
beg = ajSeqGetBegin(a);
end = ajSeqGetEnd(a);
ajStrAssignSubC(&substr,ajSeqGetSeqC(a),beg-1,end-1);
back = ajStrNew();
ajCodBacktranslateAmbig(&back,substr,codon);
ajSeqAssignSeqS (a, back);
ajSeqSetNuc(a);
ajSeqoutWriteSeq(outf,a);
}
ajSeqoutClose(outf);
ajStrDel(&back);
ajStrDel(&substr);
ajSeqoutDel(&outf);
ajCodDel(&codon);
ajStrDel(&gctable);
ajSeqallDel(&seqall);
ajSeqDel(&a);
embExit();
return 0;
}
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;
}
int getorf_acd(int argc, char **argv) {
AjPSeqout seqout;
AjPSeqall seqall;
AjPStr tablestr;
ajuint minsize;
ajuint maxsize;
AjPStr findstr;
AjBool methionine;
AjBool circular;
AjBool reverse;
ajint around;
embInit("getorf", argc, argv);
seqout = ajAcdGetSeqoutall("outseq");
seqall = ajAcdGetSeqall("sequence");
tablestr = ajAcdGetListSingle("table");
minsize = ajAcdGetInt("minsize");
maxsize = ajAcdGetInt("maxsize");
findstr = ajAcdGetListSingle("find");
methionine = ajAcdGetBoolean("methionine");
circular = ajAcdGetBoolean("circular");
reverse = ajAcdGetBoolean("reverse");
around = ajAcdGetInt("flanking");
getorf(seqout, seqall, tablestr, minsize, maxsize, findstr, methionine, circular, reverse, around);
ajSeqoutClose(seqout);
ajSeqallDel(&seqall);
ajSeqoutDel(&seqout);
ajStrDel(&tablestr);
ajStrDel(&findstr);
embExit();
return 0;
}
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)
{
AjPSeqall seqall;
AjPSeqout seqout;
AjPSeq seq;
ajint size;
ajint overlap;
ajint len;
ajint pos;
AjBool addover;
AjBool feature;
AjPStr outseq_name = ajStrNew();
ajint start;
ajint end;
embInit("splitter", argc, argv);
seqout = ajAcdGetSeqoutall("outseq");
seqall = ajAcdGetSeqall("sequence");
size = ajAcdGetInt("size");
overlap = ajAcdGetInt("overlap");
addover = ajAcdGetBoolean("addoverlap");
feature = ajAcdGetBoolean("feature");
while(ajSeqallNext(seqall, &seq))
{
ajSeqTrim(seq);
len = ajSeqGetLen(seq);
pos = 0;
ajStrAssignC(&outseq_name, "");
if (!addover)
{
while(pos+size <= len-1)
{
start = pos;
end = pos+size-1;
splitter_MakeSubSeqName (&outseq_name, seq, start, end);
splitter_ProcessChunk (seqout, seq, start, end,
outseq_name, feature);
pos += size-overlap;
}
}
else
{
while(pos+size+overlap < len-1)
{
start = pos;
end = pos+size+overlap-1;
splitter_MakeSubSeqName (&outseq_name, seq, start, end);
splitter_ProcessChunk (seqout, seq, start, end,
outseq_name, feature);
pos += size;
}
}
splitter_MakeSubSeqName(&outseq_name, seq, pos, len-1);
splitter_ProcessChunk (seqout, seq, pos, len-1,
outseq_name, feature);
}
ajSeqoutClose(seqout);
ajSeqallDel(&seqall);
ajSeqoutDel(&seqout);
ajSeqDel(&seq);
ajStrDel(&outseq_name);
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;
}
int main(int argc, char **argv)
{
AjPSeqout outseq = NULL;
AjPList list = NULL;
AjPSeq seq = NULL;
AjPStr insert = NULL;
AjPStr seqstr = NULL;
AjPStr* seqr = NULL;
AjPFile data = NULL;
ajint start = 0;
ajint length = 0;
ajint amount = 0;
ajint scmax = 0;
ajint extra = 0;
embInit("makeprotseq", argc, argv);
data = ajAcdGetInfile("pepstatsfile");
insert = ajAcdGetString("insert");
start = ajAcdGetInt("start");
length = ajAcdGetInt("length");
amount = ajAcdGetInt("amount");
outseq = ajAcdGetSeqoutall("outseq");
list = ajListstrNew();
/* this is checked by acd
if(amount <=0 || length <= 0)
ajFatal("Amount or length is 0 or less. "
"Unable to create any sequences"); */
/* if insert, make sure sequence is large enough */
if(ajStrGetLen(insert))
{
length -= ajStrGetLen(insert);
/* start= start <= 1 ? 0 : --start; */ /* checked in acd */
start--;
if(length <= 0)
ajFatal("Sequence smaller than inserted part. "
"Unable to create sequences.");
}
/* make the list of AjPStr to be used in sequence creation */
if(data)
{
ajDebug("Distribution datafile '%s' given checking type\n",
ajFileGetPrintnameC(data));
seqstr = ajStrNew();
ajReadlineTrim(data,&seqstr);
if(ajStrFindC(seqstr,"PEPSTATS") == 0)
{
makeprotseq_parse_pepstats(&list,data);
}
else
{
ajWarn("Not pepstats file. Making completely random sequences.");
makeprotseq_default_chars(&list);
}
ajStrDel(&seqstr);
ajFileClose(&data);
}
else
makeprotseq_default_chars(&list);
/* if insert, make sure type is correct */
/* typecheking code is not working, uncomment and test after it is
if(ajStrGetLen(insert))
{
seqstr = ajStrNew();
if(prot)
ajStrAssignC(&seqstr,"pureprotein");
if(!ajSeqTypeCheckS(&insert,seqstr))
ajFatal("Insert not the same sequence type as sequence itself.");
ajStrDel(&seqstr);
} */
/* array allows fast creation of a sequences */
scmax = (ajuint) ajListstrToarray(list,&seqr);
if(!scmax)
ajFatal("No strings in list. No characters to make the sequence.");
ajDebug("Distribution array done.\nscmax '%d', extra '%d', first '%S'\n",
scmax,extra,seqr[0]);
ajRandomSeed();
while(amount-- > 0)
{
seqstr = makeprotseq_random_sequence(seqr,scmax,length);
if(ajStrGetLen(insert))
ajStrInsertS(&seqstr,start,insert);
ajStrFmtLower(&seqstr);
seq = ajSeqNew();
ajSeqAssignSeqS(seq, seqstr);
ajSeqSetProt(seq);
ajSeqoutWriteSeq(outseq, seq);
ajSeqDel(&seq);
ajStrDel(&seqstr);
}
ajSeqoutClose(outseq);
ajSeqoutDel(&outseq);
ajListstrFreeData(&list);
ajStrDel(&insert);
AJFREE(seqr);
embExit();
return 0;
}
