void embPatlistRegexSearch (AjPFeattable ftable, const AjPSeq seq,
AjPPatlistRegex plist, AjBool reverse)
{
AjPPatternRegex patreg = NULL;
AjPRegexp compPat;
AjPStr tmp = NULL;
ajStrAssignS(&tmp,ajSeqGetNameS(seq));
ajDebug ("embPatlistSearchSequence: Searching '%S' for patterns\n",tmp);
while (ajPatlistRegexGetNext(plist,&patreg))
{
compPat = ajPatternRegexGetCompiled(patreg);
if (!compPat)
{
ajPatlistRegexRemoveCurrent(plist);
continue;
}
embPatternRegexSearch(ftable,seq,patreg,reverse);
ajDebug("end loop\n");
}
/* ajDebug ("embPatlistSearchListRegex: Done search '%S'\n",tmp); */
ajPatlistRegexRewind(plist);
ajStrDel(&tmp);
return;
}
void embPatlistSeqSearch (AjPFeattable ftable, const AjPSeq seq,
AjPPatlistSeq plist, AjBool reverse)
{
AjPPatternSeq patseq = NULL;
AjPPatComp compPat;
ajDebug ("embPatlistSearchListSeq: Searching '%S' for %d patterns\n",
ajSeqGetNameS(seq), ajPatlistSeqGetSize(plist));
while (ajPatlistSeqGetNext(plist,&patseq))
{
compPat = ajPatternSeqGetCompiled(patseq);
if (!compPat && !embPatternSeqCompile(patseq))
{
ajPatlistSeqRemoveCurrent(plist);
continue;
}
embPatternSeqSearch(ftable,seq,patseq,reverse);
ajDebug("end loop\n");
}
ajPatlistSeqRewind(plist);
return;
}
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;
}
static void splitter_MakeSubSeqName (AjPStr * name_ptr,
const AjPSeq seq, ajuint start,
ajuint end)
{
AjPStr value = ajStrNew();
/* create a nice name for the subsequence */
ajStrAssignS(name_ptr, ajSeqGetNameS(seq));
ajStrAppendC(name_ptr, "_");
ajStrFromUint(&value, ajSeqGetBegin(seq)+start);
ajStrAppendS(name_ptr, value);
ajStrAppendC(name_ptr, "-");
ajStrFromUint(&value, ajSeqGetBegin(seq)+end);
ajStrAppendS(name_ptr, value);
ajStrDel(&value);
}
int main(int argc, char **argv)
{
AjPSeq seq = NULL;
AjPFile outf = NULL;
embInitPV("myseq", argc, argv, "myemboss",VERSION);
seq = ajAcdGetSeq("sequence");
outf = ajAcdGetOutfile("outfile");
ajFmtPrintF(outf, "Sequence properties\n");
ajFmtPrintF(outf, "===================\n");
ajFmtPrintF(outf, "Name: %S\n", ajSeqGetNameS(seq));
ajFmtPrintF(outf, "Usa: %S\n", ajSeqGetUsaS(seq));
ajFmtPrintF(outf, "Length: %d\n", ajSeqGetLen(seq));
ajFileClose(&outf);
embExit();
return 0;
}
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;
}
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[])
{
embInitPV("goligomersearch", argc, argv, "GEMBASSY", "1.0.3");
AjPSeqall seqall;
AjPSeq seq;
AjPStr inseq = NULL;
AjPStr oligomer = NULL;
AjPStr restid = NULL;
AjPStr seqid = NULL;
AjPStr base = NULL;
AjPStr url = NULL;
AjPStr _return = NULL;
AjPStr tmpname = NULL;
AjPSeqout tmpout = NULL;
AjPFilebuff tmp = NULL;
AjPStr line = NULL;
AjPFile outfile = NULL;
seqall = ajAcdGetSeqall("sequence");
oligomer = ajAcdGetString("oligomer");
_return = ajAcdGetSelectSingle("return");
outfile = ajAcdGetOutfile("outfile");
base = ajStrNewC("rest.g-language.org");
gAssignUniqueName(&tmpname);
ajStrAppendC(&tmpname, ".fasta");
while(ajSeqallNext(seqall, &seq))
{
inseq = NULL;
tmpout = ajSeqoutNew();
if(!ajSeqoutOpenFilename(tmpout, tmpname))
{
embExitBad();
}
ajSeqoutSetFormatS(tmpout,ajStrNewC("fasta"));
ajSeqoutWriteSeq(tmpout, seq);
ajSeqoutClose(tmpout);
ajSeqoutDel(&tmpout);
ajFmtPrintS(&url, "http://%S/upload/upl.pl", base);
gFilePostSS(url, tmpname, &restid);
ajStrDel(&url);
ajSysFileUnlinkS(tmpname);
ajStrAssignS(&seqid, ajSeqGetAccS(seq));
if(ajStrGetLen(seqid) == 0)
{
ajStrAssignS(&seqid, ajSeqGetNameS(seq));
}
if(ajStrGetLen(seqid) == 0)
{
ajWarn("No valid header information\n");
}
url = ajStrNew();
ajFmtPrintS(&url, "http://%S/%S/oligomer_search/%S/return=%S",
base, restid, oligomer, _return);
if(!gFilebuffURLS(url, &tmp))
{
ajDie("Failed to download result from:\n%S\n", url);
}
ajBuffreadLine(tmp, &line);
ajStrRemoveSetC(&line, "\n");
ajFmtPrintF(outfile, "Sequence: %S Oligomer: %S Return: %S\n",
seqid, oligomer, line);
ajStrDel(&url);
ajStrDel(&restid);
ajStrDel(&seqid);
ajStrDel(&inseq);
}
ajFileClose(&outfile);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&base);
ajStrDel(&oligomer);
embExit();
return 0;
}
void embPatternSeqSearch (AjPFeattable ftable, const AjPSeq seq,
const AjPPatternSeq pat, AjBool reverse)
{
const void *tidy;
ajuint hits;
ajuint i;
AjPPatComp pattern;
EmbPMatMatch m = NULL;
AjPFeature sf = NULL;
AjPSeq revseq = NULL;
AjPList list = ajListNew();
AjPStr seqstr = ajStrNew();
AjPStr seqname = ajStrNew();
AjPStr tmp = ajStrNew();
ajint adj;
ajint begin;
AjBool isreversed;
ajint seqlen;
seqlen = ajSeqGetLen(seq);
if(!seqlen)
return;
isreversed = ajSeqIsReversedTrue(seq);
if(isreversed)
seqlen += ajSeqGetOffset(seq);
begin = ajSeqGetBeginTrue(seq);
adj = ajSeqGetEndTrue(seq);
if(!ajStrGetLen(featMotifProt))
ajStrAssignC(&featMotifProt, "SO:0001067");
if(!ajStrGetLen(featMotifNuc))
ajStrAssignC(&featMotifNuc, "SO:0000714");
ajStrAssignS(&seqname,ajSeqGetNameS(seq));
pattern = ajPatternSeqGetCompiled(pat);
if (reverse)
{
revseq = ajSeqNewSeq(seq);
ajStrAssignSubS(&seqstr, ajSeqGetSeqS(revseq),
begin-1,adj-1);
ajSeqstrReverse(&seqstr);
}
else
ajStrAssignSubS(&seqstr, ajSeqGetSeqS(seq),
begin-1,adj-1);
ajStrFmtUpper(&seqstr);
/*ajDebug("seqlen:%d len: %d offset: %d offend: %d begin: %d end: %d\n"
"'%S'\n",
seqlen , ajSeqGetLen(seq), ajSeqGetOffset(seq),
ajSeqGetOffend(seq), ajSeqGetBegin(seq), ajSeqGetEnd(seq),
seqstr);*/
ajDebug("embPatternSeqSearch '%S' protein: %B reverse: %B\n",
pattern->pattern, pat->Protein, reverse);
embPatFuzzSearchII(pattern,begin,seqname,seqstr,list,
ajPatternSeqGetMismatch(pat),&hits,&tidy);
ajDebug ("embPatternSeqSearch: found %d hits\n",hits);
if(!reverse)
ajListReverse(list);
for(i=0;i<hits;++i)
{
ajListPop(list,(void **)&m);
if (reverse)
sf = ajFeatNew(ftable, NULL, featMotifNuc,
adj - m->start - m->len + begin + 1,
adj - m->start + begin,
0.0, '-', 0);
else
{
if(ajSeqIsProt(seq) || ajFeattableIsProt(ftable))
sf = ajFeatNewProt(ftable, NULL, featMotifProt,
m->start,
m->start + m->len - 1,
0.0);
else
sf = ajFeatNew(ftable, NULL, featMotifNuc,
m->start,
m->start + m->len - 1,
0.0, '.', 0);
}
if(isreversed)
ajFeatReverse(sf, seqlen);
/*
ajUser("isrev: %B reverse: %B begin: %d adj: %d "
"start: %d len: %d seqlen: %d %d..%d '%c'\n",
isreversed, reverse, begin, adj, m->start, m->len, seqlen,
sf->Start, sf->End, sf->Strand);
*/
ajFeatSetScore(sf, (float) (m->len - m->mm));
ajFmtPrintS(&tmp, "*pat %S: %S",
ajPatternSeqGetName(pat),
ajPatternSeqGetPattern(pat));
ajFeatTagAdd(sf,NULL,tmp);
if(m->mm)
{
ajFmtPrintS(&tmp, "*mismatch %d", m->mm);
ajFeatTagAdd(sf, NULL, tmp);
}
embMatMatchDel(&m);
}
ajStrDel(&seqname);
ajStrDel(&seqstr);
ajStrDel(&tmp);
ajListFree(&list);
if (reverse)
ajSeqDel(&revseq);
return;
}
int main(int argc, char **argv)
{
/* Global details */
AjBool explain_flag;
AjBool file_flag;
AjPStr* task;
AjBool do_primer;
AjBool do_hybrid;
ajint num_return;
ajint first_base_index;
/* "Sequence" Input Tags */
AjPSeqall sequence;
AjPRange included_region;
AjPRange target;
AjPRange excluded_region;
AjPStr left_input;
AjPStr right_input;
/* Primer details */
AjBool pick_anyway;
AjPFile mispriming_library;
float max_mispriming;
float pair_max_mispriming;
ajint gc_clamp;
ajint opt_size;
ajint min_size;
ajint max_size;
float opt_tm;
float min_tm;
float max_tm;
float max_diff_tm;
float opt_gc_percent;
float min_gc;
float max_gc;
float salt_conc;
float dna_conc;
ajint num_ns_accepted;
float self_any;
float self_end;
ajint max_poly_x;
/* Sequence Quality. These are not (yet) implemented */
/*
AjPFile sequence_quality;
ajint min_quality;
ajint min_end_quality;
ajint quality_range_min;
ajint quality_range_max;
*/
/* Product details */
ajint product_opt_size;
AjPRange product_size_range;
float product_opt_tm;
float product_min_tm;
float product_max_tm;
/* Objective Function Penalty Weights for Primers */
float max_end_stability;
/* these are not (yet) implemented */
/*
float inside_penalty;
float outside_penalty;
*/
/* Primer penalties */
/* these are not (yet) implemented */
/* Internal Oligo "Sequence" Input Tags */
AjPRange internal_oligo_excluded_region;
/* Internal Oligo "Global" Input Tags */
AjPStr internal_oligo_input;
ajint internal_oligo_opt_size;
ajint internal_oligo_min_size;
ajint internal_oligo_max_size;
float internal_oligo_opt_tm;
float internal_oligo_min_tm;
float internal_oligo_max_tm;
float internal_oligo_opt_gc_percent;
float internal_oligo_min_gc;
float internal_oligo_max_gc;
float internal_oligo_salt_conc;
float internal_oligo_dna_conc;
float internal_oligo_self_any;
float internal_oligo_self_end;
ajint internal_oligo_max_poly_x;
AjPFile internal_oligo_mishyb_library;
float internal_oligo_max_mishyb;
/*
ajint internal_oligo_min_quality;
*/
/* Internal Oligo penalties */
/* these are not (yet) implemented */
/* EMBOSS-wrapper-specific stuff */
AjPFile outfile;
/* other variables */
AjPStr result = NULL;
AjPStr strand = NULL;
AjPStr substr = NULL;
AjPSeq seq = NULL;
ajint begin = 0;
ajint end;
FILE* stream;
AjPStr taskstr = NULL;
const AjPStr program = NULL;
/* pipe variables */
int *pipeto; /* pipe to feed the exec'ed program input */
int *pipefrom; /* pipe to get the exec'ed program output */
embInit("eprimer3", argc, argv);
/* Global details */
explain_flag = ajAcdGetBoolean("explainflag");
file_flag = ajAcdGetBoolean("fileflag");
task = ajAcdGetList("task");
do_primer = ajAcdGetToggle("primer");
do_hybrid = ajAcdGetToggle("hybridprobe");
num_return = ajAcdGetInt("numreturn");
first_base_index = ajAcdGetInt("firstbaseindex");
/* "Sequence" Input Tags */
sequence = ajAcdGetSeqall("sequence");
included_region = ajAcdGetRange("includedregion");
target = ajAcdGetRange("targetregion");
excluded_region = ajAcdGetRange("excludedregion");
left_input = ajAcdGetString("forwardinput");
right_input = ajAcdGetString("reverseinput");
/* Primer details */
pick_anyway = ajAcdGetBoolean("pickanyway");
mispriming_library = ajAcdGetInfile("mispriminglibraryfile");
max_mispriming = ajAcdGetFloat("maxmispriming");
pair_max_mispriming = ajAcdGetFloat("pairmaxmispriming");
gc_clamp = ajAcdGetInt("gcclamp");
opt_size = ajAcdGetInt("osize");
min_size = ajAcdGetInt("minsize");
max_size = ajAcdGetInt("maxsize");
opt_tm = ajAcdGetFloat("otm");
min_tm = ajAcdGetFloat("mintm");
max_tm = ajAcdGetFloat("maxtm");
max_diff_tm = ajAcdGetFloat("maxdifftm");
opt_gc_percent = ajAcdGetFloat("ogcpercent");
min_gc = ajAcdGetFloat("mingc");
max_gc = ajAcdGetFloat("maxgc");
salt_conc = ajAcdGetFloat("saltconc");
dna_conc = ajAcdGetFloat("dnaconc");
num_ns_accepted = ajAcdGetInt("numnsaccepted");
self_any = ajAcdGetFloat("selfany");
self_end = ajAcdGetFloat("selfend");
max_poly_x = ajAcdGetInt("maxpolyx");
AJCNEW0(pipeto,2);
AJCNEW0(pipefrom,2);
/* Sequence Quality */
/* these are not (yet) implemented */
/*
sequence_quality = ajAcdGetInfile("sequencequality");
min_quality = ajAcdGetInt("minquality");
min_end_quality = ajAcdGetInt("minendquality");
quality_range_min = ajAcdGetInt("qualityrangemin");
quality_range_max = ajAcdGetInt("qualityrangemax");
*/
/* Product details */
product_opt_size = ajAcdGetInt("psizeopt");
product_size_range = ajAcdGetRange("prange");
product_opt_tm = ajAcdGetFloat("ptmopt");
product_min_tm = ajAcdGetFloat("ptmmin");
product_max_tm = ajAcdGetFloat("ptmmax");
/* Objective Function Penalty Weights for Primers */
max_end_stability = ajAcdGetFloat("maxendstability");
/* these are not (yet) implemented */
/*
inside_penalty = ajAcdGetFloat("insidepenalty");
outside_penalty = ajAcdGetFloat("outsidepenalty");
*/
/* Primer penalties */
/* these are not (yet) implemented */
/* Internal Oligo "Sequence" Input Tags */
internal_oligo_excluded_region = ajAcdGetRange("oexcludedregion");
internal_oligo_input = ajAcdGetString("oligoinput");
/* Internal Oligo "Global" Input Tags */
internal_oligo_opt_size = ajAcdGetInt("osizeopt");
internal_oligo_min_size = ajAcdGetInt("ominsize");
internal_oligo_max_size = ajAcdGetInt("omaxsize");
internal_oligo_opt_tm = ajAcdGetFloat("otmopt");
internal_oligo_min_tm = ajAcdGetFloat("otmmin");
internal_oligo_max_tm = ajAcdGetFloat("otmmax");
internal_oligo_opt_gc_percent = ajAcdGetFloat("ogcopt");
internal_oligo_min_gc = ajAcdGetFloat("ogcmin");
internal_oligo_max_gc = ajAcdGetFloat("ogcmax");
internal_oligo_salt_conc = ajAcdGetFloat("osaltconc");
internal_oligo_dna_conc = ajAcdGetFloat("odnaconc");
internal_oligo_self_any = ajAcdGetFloat("oanyself");
internal_oligo_self_end = ajAcdGetFloat("oendself");
internal_oligo_max_poly_x = ajAcdGetInt("opolyxmax");
internal_oligo_mishyb_library = ajAcdGetInfile("mishyblibraryfile");
internal_oligo_max_mishyb = ajAcdGetFloat("omishybmax");
/*
internal_oligo_min_quality = ajAcdGetInt("oligominquality");
*/
/* Internal Oligo penalties */
/* these are not (yet) implemented */
/* EMBOSS-wrapper-specific stuff */
outfile = ajAcdGetOutfile("outfile");
ajStrRemoveWhite(&left_input);
ajStrRemoveWhite(&right_input);
/*
** OK - we will now try to do a separate fork-exec for each sequence.
*/
result = ajStrNew();
while(ajSeqallNext(sequence, &seq))
{
program = ajAcdGetpathC("primer3_core");
if(!ajSysExecRedirectC(ajStrGetPtr(program),&pipeto,&pipefrom))
ajFatal("eprimer3: Could not exec primer3_core");
stream = eprimer3_start_write(pipeto[1]);
/* send primer3 Primer "Global" parameters */
eprimer3_send_bool(stream, "PRIMER_EXPLAIN_FLAG", explain_flag);
eprimer3_send_bool(stream, "PRIMER_FILE_FLAG", file_flag);
if(do_hybrid)
{
if(!ajStrCmpC(task[0], "1"))
ajStrAssignC(&taskstr, "pick_pcr_primers_and_hyb_probe");
else if(!ajStrCmpC(task[0], "2"))
ajStrAssignC(&taskstr, "pick_left_only");
else if(!ajStrCmpC(task[0], "3"))
ajStrAssignC(&taskstr, "pick_right_only");
else if(!ajStrCmpC(task[0], "4"))
ajStrAssignC(&taskstr, "pick_hyb_probe_only");
if (!do_primer)
ajStrAssignC(&taskstr, "pick_hyb_probe_only");
}
else
{
if(!ajStrCmpC(task[0], "1"))
ajStrAssignC(&taskstr, "pick_pcr_primers");
else if(!ajStrCmpC(task[0], "2"))
ajStrAssignC(&taskstr, "pick_left_only");
else if(!ajStrCmpC(task[0], "3"))
ajStrAssignC(&taskstr, "pick_right_only");
else if(!ajStrCmpC(task[0], "4"))
ajStrAssignC(&taskstr, "pick_hyb_probe_only");
}
eprimer3_send_string(stream, "PRIMER_TASK", taskstr);
eprimer3_send_int(stream, "PRIMER_NUM_RETURN", num_return);
eprimer3_send_int(stream, "PRIMER_FIRST_BASE_INDEX",
first_base_index);
eprimer3_send_bool(stream, "PRIMER_PICK_ANYWAY", pick_anyway);
/* mispriming library may not have been specified */
if(mispriming_library)
eprimer3_send_stringC(stream, "PRIMER_MISPRIMING_LIBRARY",
ajFileGetPrintnameC(mispriming_library));
eprimer3_send_float(stream, "PRIMER_MAX_MISPRIMING",
max_mispriming);
eprimer3_send_float(stream, "PRIMER_PAIR_MAX_MISPRIMING",
pair_max_mispriming);
eprimer3_send_int(stream, "PRIMER_GC_CLAMP", gc_clamp);
eprimer3_send_int(stream, "PRIMER_OPT_SIZE", opt_size);
eprimer3_send_int(stream, "PRIMER_MIN_SIZE", min_size);
eprimer3_send_int(stream, "PRIMER_MAX_SIZE", max_size);
eprimer3_send_float(stream, "PRIMER_OPT_TM", opt_tm);
eprimer3_send_float(stream, "PRIMER_MIN_TM", min_tm);
eprimer3_send_float(stream, "PRIMER_MAX_TM", max_tm);
eprimer3_send_float(stream, "PRIMER_MAX_DIFF_TM", max_diff_tm);
eprimer3_send_float(stream, "PRIMER_OPT_GC_PERCENT",
opt_gc_percent);
eprimer3_send_float(stream, "PRIMER_MIN_GC", min_gc);
eprimer3_send_float(stream, "PRIMER_MAX_GC", max_gc);
eprimer3_send_float(stream, "PRIMER_SALT_CONC", salt_conc);
eprimer3_send_float(stream, "PRIMER_DNA_CONC", dna_conc);
eprimer3_send_int(stream, "PRIMER_NUM_NS_ACCEPTED",
num_ns_accepted);
eprimer3_send_float(stream, "PRIMER_SELF_ANY", self_any);
eprimer3_send_float(stream, "PRIMER_SELF_END", self_end);
eprimer3_send_int(stream, "PRIMER_MAX_POLY_X", max_poly_x);
eprimer3_send_int(stream, "PRIMER_PRODUCT_OPT_SIZE",
product_opt_size);
eprimer3_send_range2(stream, "PRIMER_PRODUCT_SIZE_RANGE",
product_size_range);
eprimer3_send_float(stream, "PRIMER_PRODUCT_OPT_TM",
product_opt_tm);
eprimer3_send_float(stream, "PRIMER_PRODUCT_MIN_TM",
product_min_tm);
eprimer3_send_float(stream, "PRIMER_PRODUCT_MAX_TM",
product_max_tm);
eprimer3_send_float(stream, "PRIMER_MAX_END_STABILITY",
max_end_stability);
/* send primer3 Internal Oligo "Global" parameters */
eprimer3_send_int(stream, "PRIMER_INTERNAL_OLIGO_OPT_SIZE",
internal_oligo_opt_size);
eprimer3_send_int(stream, "PRIMER_INTERNAL_OLIGO_MIN_SIZE",
internal_oligo_min_size);
eprimer3_send_int(stream, "PRIMER_INTERNAL_OLIGO_MAX_SIZE",
internal_oligo_max_size);
eprimer3_send_float(stream, "PRIMER_INTERNAL_OLIGO_OPT_TM",
internal_oligo_opt_tm);
eprimer3_send_float(stream, "PRIMER_INTERNAL_OLIGO_MIN_TM",
internal_oligo_min_tm);
eprimer3_send_float(stream, "PRIMER_INTERNAL_OLIGO_MAX_TM",
internal_oligo_max_tm);
eprimer3_send_float(stream, "PRIMER_INTERNAL_OLIGO_OPT_GC_PERCENT",
internal_oligo_opt_gc_percent);
eprimer3_send_float(stream, "PRIMER_INTERNAL_OLIGO_MIN_GC",
internal_oligo_min_gc);
eprimer3_send_float(stream, "PRIMER_INTERNAL_OLIGO_MAX_GC",
internal_oligo_max_gc);
eprimer3_send_float(stream, "PRIMER_INTERNAL_OLIGO_SALT_CONC",
internal_oligo_salt_conc);
eprimer3_send_float(stream, "PRIMER_INTERNAL_OLIGO_DNA_CONC",
internal_oligo_dna_conc);
eprimer3_send_float(stream, "PRIMER_INTERNAL_OLIGO_SELF_ANY",
internal_oligo_self_any);
eprimer3_send_float(stream, "PRIMER_INTERNAL_OLIGO_SELF_END",
internal_oligo_self_end);
eprimer3_send_int(stream, "PRIMER_INTERNAL_OLIGO_MAX_POLY_X",
internal_oligo_max_poly_x);
/*
** internal oligo mishybridising library may not have been
** specified
*/
if(internal_oligo_mishyb_library)
eprimer3_send_stringC(stream,
"PRIMER_INTERNAL_OLIGO_MISHYB_LIBRARY",
ajFileGetPrintnameC(internal_oligo_mishyb_library));
eprimer3_send_float(stream, "PRIMER_INTERNAL_OLIGO_MAX_MISHYB",
internal_oligo_max_mishyb);
/*
** Start sequence-specific stuff
*/
begin = ajSeqallGetseqBegin(sequence) - 1;
end = ajSeqallGetseqEnd(sequence) - 1;
strand = ajSeqGetSeqCopyS(seq);
ajStrFmtUpper(&strand);
ajStrAssignSubC(&substr,ajStrGetPtr(strand), begin, end);
/* send flags to turn on using optimal product size */
eprimer3_send_float(stream, "PRIMER_PAIR_WT_PRODUCT_SIZE_GT",
(float)0.05);
eprimer3_send_float(stream, "PRIMER_PAIR_WT_PRODUCT_SIZE_LT",
(float)0.05);
/* send primer3 Primer "Sequence" parameters */
eprimer3_send_string(stream, "SEQUENCE", substr);
/* if no ID name, use the USA */
if(ajStrMatchC(ajSeqGetNameS(seq),""))
eprimer3_send_string(stream, "PRIMER_SEQUENCE_ID",
ajSeqGetUsaS(seq));
else
eprimer3_send_string(stream, "PRIMER_SEQUENCE_ID",
ajSeqGetNameS(seq));
eprimer3_send_range(stream, "INCLUDED_REGION", included_region,
begin);
eprimer3_send_range(stream, "TARGET", target, begin);
eprimer3_send_range(stream, "EXCLUDED_REGION", excluded_region,
begin);
eprimer3_send_string(stream, "PRIMER_LEFT_INPUT", left_input);
eprimer3_send_string(stream, "PRIMER_RIGHT_INPUT", right_input);
/* send primer3 Internal Oligo "Sequence" parameters */
eprimer3_send_range(stream,
"PRIMER_INTERNAL_OLIGO_EXCLUDED_REGION",
internal_oligo_excluded_region, begin);
eprimer3_send_string(stream, "PRIMER_INTERNAL_OLIGO_INPUT",
internal_oligo_input);
/* end the primer3 input sequence record with a '=' */
eprimer3_send_end(stream);
/* and close the ouput pipe stream */
eprimer3_end_write(stream);
/* read the primer3 output */
eprimer3_read(pipefrom[0], &result);
eprimer3_report(outfile, result, num_return, begin);
ajStrSetClear(&result);
#ifndef WIN32
close(pipeto[1]);
close(pipefrom[0]);
#endif
} /* end of sequence loop */
ajStrDel(&result);
ajSeqDel(&seq);
ajStrDel(&strand);
ajStrDel(&substr);
ajFileClose(&outfile);
ajStrDel(&taskstr);
ajStrDelarray(&task);
ajSeqallDel(&sequence);
ajSeqDel(&seq);
ajRangeDel(&included_region);
ajRangeDel(&target);
ajRangeDel(&excluded_region);
ajRangeDel(&product_size_range);
ajRangeDel(&internal_oligo_excluded_region);
ajStrDel(&left_input);
ajStrDel(&right_input);
ajStrDel(&internal_oligo_input);
AJFREE(pipeto);
AJFREE(pipefrom);
ajFileClose(&mispriming_library);
embExit();
return 0;
}
int main(int argc, char *argv[])
{
embInitPV("ggcsi", argc, argv, "GEMBASSY", "1.0.1");
struct soap soap;
struct ns1__gcsiInputParams params;
AjPSeqall seqall;
AjPSeq seq;
AjPStr inseq = NULL;
AjPStr seqid = NULL;
ajint window = 0;
AjBool at = 0;
AjBool purine = 0;
AjBool keto = 0;
AjBool pval = 0;
AjPStr version = NULL;
AjBool accid = ajFalse;
AjPStr tmp = NULL;
AjPStr parse = NULL;
AjPStr gcsi = NULL;
AjPStr sa = NULL;
AjPStr dist = NULL;
AjPStr z = NULL;
AjPStr p = NULL;
AjPStrTok handle = NULL;
char *in0;
char *result;
AjPFile outf = NULL;
seqall = ajAcdGetSeqall("sequence");
window = ajAcdGetInt("window");
at = ajAcdGetBoolean("at");
purine = ajAcdGetBoolean("purine");
keto = ajAcdGetBoolean("keto");
pval = ajAcdGetBoolean("pval");
version = ajAcdGetSelectSingle("gcsi");
accid = ajAcdGetBoolean("accid");
outf = ajAcdGetOutfile("outfile");
params.window = window;
params.at = 0;
params.purine = 0;
params.keto = 0;
params.p = 0;
ajStrToInt(version, &(params.version));
if(at)
params.at = 1;
if(purine)
params.purine = 1;
if(keto)
params.keto = 1;
if(pval)
params.p = 1;
while(ajSeqallNext(seqall, &seq))
{
soap_init(&soap);
inseq = NULL;
ajStrAppendC(&inseq, ">");
ajStrAppendS(&inseq, ajSeqGetNameS(seq));
ajStrAppendC(&inseq, "\n");
ajStrAppendS(&inseq, ajSeqGetSeqS(seq));
ajStrAssignS(&seqid, ajSeqGetAccS(seq));
in0 = ajCharNewS(inseq);
if (soap_call_ns1__gcsi(
&soap,
NULL,
NULL,
in0,
¶ms,
&result
) == SOAP_OK)
{
tmp = ajStrNew();
parse = ajStrNew();
gcsi = ajStrNew();
sa = ajStrNew();
dist = ajStrNew();
z = ajStrNew();
p = ajStrNew();
ajStrAssignC(&tmp, result);
ajStrExchangeCC(&tmp, "<", "\n");
ajStrExchangeCC(&tmp, ">", "\n");
handle = ajStrTokenNewC(tmp, "\n");
while (ajStrTokenNextParse(&handle, &parse))
{
if (ajStrIsFloat(parse))
{
if(!ajStrGetLen(gcsi))
ajStrAssignS(&gcsi, parse);
else if(!ajStrGetLen(sa))
ajStrAssignS(&sa, parse);
else if(!ajStrGetLen(dist))
ajStrAssignS(&dist, parse);
else if(!ajStrGetLen(z))
ajStrAssignS(&z, parse);
else if(!ajStrGetLen(p))
ajStrAssignS(&p, parse);
}
}
tmp = ajFmtStr("Sequence: %S GCSI: %S SA: %S DIST: %S",
seqid, gcsi, sa, dist);
if(pval)
tmp = ajFmtStr("%S Z: %S P: %S", tmp, z, p);
ajFmtPrintF(outf, "%S\n", tmp);
ajStrDel(&tmp);
ajStrDel(&parse);
ajStrDel(&gcsi);
ajStrDel(&sa);
ajStrDel(&dist);
ajStrDel(&z);
ajStrDel(&p);
}
else
{
soap_print_fault(&soap, stderr);
}
soap_destroy(&soap);
soap_end(&soap);
soap_done(&soap);
AJFREE(in0);
ajStrDel(&inseq);
}
ajFileClose(&outf);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&seqid);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPList sigin = NULL; /* Signature input file names. */
AjPStr signame = NULL; /* Name of signature file. */
AjPFile sigf = NULL; /* Signature input file. */
EmbPSignature sig = NULL; /* Signature. */
AjPList siglist = NULL; /* List of signatures. */
AjIList sigiter = NULL; /* Iterator for siglist. */
AjBool sigok = ajFalse; /* True if signature processed ok. */
EmbPHit hit = NULL; /* Hit to store signature-sequence match. */
AjPList hits = NULL; /* List of hits */
AjPList ligands = NULL; /* List of top-scoring ligands. */
AjPSeqall database=NULL; /* Protein sequences to match signature
against. */
AjPSeq seq = NULL; /* Current sequence. */
AjPMatrixf sub =NULL; /* Residue substitution matrix. */
float gapo =0.0; /* Gap insertion penalty. */
float gape =0.0; /* Gap extension penalty. */
AjPStr nterm=NULL; /* Holds N-terminal matching options from
acd. */
ajint ntermi=0; /* N-terminal option as int. */
AjPFile hitsf =NULL; /* Hits output file.
sequence matches. */
AjPDirout hitsdir=NULL; /* Directory of hits files (output). */
AjPFile alignf =NULL; /* Alignment output file. */
AjPDirout aligndir=NULL; /* Directory of alignment files (output). */
AjPFile resultsf =NULL; /* Results file (output). */
AjPDirout resultsdir=NULL; /* Directory of results files (output). */
AjPStr mode = NULL; /* Mode, 1: Patch score mode, 2:
Site score mode. */
ajint modei = 0; /* Selected mode as integer. */
SigPLighit lighit = NULL;
embInitPV("sigscanlig", argc, argv, "SIGNATURE",VERSION);
/* GET VALUES FROM ACD */
sigin = ajAcdGetDirlist("siginfilesdir");
database = ajAcdGetSeqall("dbseqall");
sub = ajAcdGetMatrixf("sub");
gapo = ajAcdGetFloat("gapo");
gape = ajAcdGetFloat("gape");
nterm = ajAcdGetListSingle("nterm");
hitsdir = ajAcdGetOutdir("hitsoutdir");
aligndir = ajAcdGetOutdir("alignoutdir");
resultsdir = ajAcdGetOutdir("resultsoutdir");
mode = ajAcdGetListSingle("mode");
/*Assign N-terminal matching option etc. */
ajFmtScanS(nterm, "%d", &ntermi);
modei = (ajint) ajStrGetCharFirst(mode)-48;
/* READ & PROCESS SIGNATURES */
siglist = ajListNew();
while(ajListPop(sigin, (void **) &signame))
{
/* Read signature files, compile signatures and populate list. */
sigok = ajFalse;
if((sigf = ajFileNewInNameS(signame)))
if((sig = embSignatureReadNew(sigf)))
if(embSignatureCompile(&sig, gapo, gape, sub))
{
sigok=ajTrue;
ajListPushAppend(siglist, sig);
/*
ajFmtPrint("Id: %S\nDomid: %S\nLigid: %S\nns: %d\n"
"sn: %d\nnp: %d\npn: %d\nminpatch: %d\n"
"maxgap: %d\n",
sig->Id, sig->Domid, sig->Ligid, sig->ns,
sig->sn, sig->np, sig->pn, sig->minpatch,
sig->maxgap); */
}
if(!sigok)
{
ajWarn("Could not process %S", signame);
embSignatureDel(&sig);
ajFileClose(&sigf);
ajStrDel(&signame);
continue;
}
ajFileClose(&sigf);
ajStrDel(&signame);
}
ajListFree(&sigin);
/* ALIGN EACH QUERY SEQUENCE TO LIST OF SIGNATURE */
while(ajSeqallNext(database, &seq))
{
/* Do sequence-signature alignment and save results */
hits = ajListNew();
sigiter = ajListIterNew(siglist);
while((sig = (EmbPSignature) ajListIterGet(sigiter)))
{
if(embSignatureAlignSeq(sig, seq, &hit, ntermi))
{
hit->Sig = sig;
ajListPushAppend(hits, hit);
hit=NULL; /* To force reallocation by embSignatureAlignSeq */
}
/* There has to be a hit for each signature for correct
generation of the LHF by sigscanlig_WriteFasta. So push
an empty hit if necessary. 'hit'=NULL forces
reallocation by embSignatureAlignSeq. */
/*
else
{
hit = embHitNew();
ajListPushAppend(hits, hit);
hit=NULL;
}
*/
}
ajListIterDel(&sigiter);
/* Rank-order the list of hits by score */
ajListSort(hits, embMatchinvScore);
/* Write ligand hits & alignment files (output) */
hitsf = ajFileNewOutNameDirS(ajSeqGetNameS(seq), hitsdir);
alignf = ajFileNewOutNameDirS(ajSeqGetNameS(seq), aligndir);
resultsf = ajFileNewOutNameDirS(ajSeqGetNameS(seq), resultsdir);
/* if((!sigscanlig_WriteFasta(hitsf, siglist, hits)))
ajFatal("Bad args to sigscanlig_WriteFasta"); */
if((!sigscanlig_WriteFasta(hitsf, hits)))
ajFatal("Bad args to sigscanlig_WriteFasta");
if((!sigscanlig_SignatureAlignWriteBlock(alignf, hits)))
ajFatal("Bad args to sigscanlig_SignatureAlignWriteBlock");
/* if((!sigscanlig_SignatureAlignWriteBlock(alignf, siglist, hits)))
ajFatal("Bad args to sigscanlig_SignatureAlignWriteBlock"); */
/* Sort list of hits by ligand type and site number.
Process list of ligands and print out. */
ajListSortTwo(hits, embMatchLigid, embMatchSN);
if(modei==1)
ligands = sigscanlig_score_ligands_patch(hits);
else if(modei==2)
ligands = sigscanlig_score_ligands_site(hits);
else
ajFatal("Unrecognised mode");
sigscanlig_WriteResults(ligands, resultsf);
ajFileClose(&hitsf);
ajFileClose(&alignf);
ajFileClose(&resultsf);
/* Memory management */
while(ajListPop(hits, (void **) &hit))
embHitDel(&hit);
ajListFree(&hits);
while(ajListPop(ligands, (void **) &lighit))
sigscanlig_LigHitDel(&lighit);
ajListFree(&ligands);
}
/* MEMORY MANAGEMENT */
while(ajListPop(siglist, (void **) &sig))
embSignatureDel(&sig);
ajListFree(&siglist);
ajSeqallDel(&database);
ajMatrixfDel(&sub);
ajStrDel(&nterm);
ajDiroutDel(&hitsdir);
ajDiroutDel(&aligndir);
ajDiroutDel(&resultsdir);
ajStrDel(&mode);
embExit();
return 0;
}
int main(int argc, char *argv[])
{
embInitPV("gseqinfo", argc, argv, "GEMBASSY", "1.0.1");
struct soap soap;
AjPSeqall seqall;
AjPSeq seq;
AjPStr inseq = NULL;
AjPStr seqid = NULL;
AjPStr tmp = NULL;
AjPStr parse = NULL;
AjPStr numA = NULL;
AjPStr numT = NULL;
AjPStr numG = NULL;
AjPStr numC = NULL;
AjPStrTok handle = NULL;
ajint n;
char *in0;
char *result;
AjBool show = 0;
AjPFile outf = NULL;
seqall = ajAcdGetSeqall("sequence");
outf = ajAcdGetOutfile("outfile");
while(ajSeqallNext(seqall, &seq))
{
soap_init(&soap);
inseq = NULL;
ajStrAppendC(&inseq, ">");
ajStrAppendS(&inseq, ajSeqGetNameS(seq));
ajStrAppendC(&inseq, "\n");
ajStrAppendS(&inseq, ajSeqGetSeqS(seq));
ajStrAssignS(&seqid, ajSeqGetAccS(seq));
in0 = ajCharNewS(inseq);
if(soap_call_ns1__seqinfo(
&soap,
NULL,
NULL,
in0,
&result
) == SOAP_OK)
{
tmp = ajStrNewC(result);
ajStrExchangeCC(&tmp, "<", "\n");
ajStrExchangeCC(&tmp, ">", "\n");
handle = ajStrTokenNewC(tmp, "\n");
while(ajStrTokenNextParse(handle, &parse))
{
if(ajStrIsInt(parse))
if(!numA)
numA = ajStrNewS(parse);
else if(!numT)
numT = ajStrNewS(parse);
else if(!numG)
numG = ajStrNewS(parse);
else if(!numC)
numC = ajStrNewS(parse);
}
if(show)
ajFmtPrint("Sequence: %S A: %S T: %S G: %S C: %S\n",
seqid, numA, numT, numG, numC);
else
ajFmtPrintF(outf, "Sequence: %S A: %S T: %S G: %S C: %S\n",
seqid, numA, numT, numG, numC);
}
else
{
soap_print_fault(&soap, stderr);
}
soap_destroy(&soap);
soap_end(&soap);
soap_done(&soap);
AJFREE(in0);
ajStrDel(&inseq);
}
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&seqid);
embExit();
return 0;
}
int main(int argc, char *argv[])
{
embInitPV("gldabias", argc, argv, "GEMBASSY", "1.0.1");
AjPSeqall seqall;
AjPSeq seq;
AjPStr inseq = NULL;
ajint coefficients = 0;
AjPStr variable = NULL;
AjBool accid = ajFalse;
AjPStr restid = NULL;
AjPStr seqid = NULL;
AjPStr base = NULL;
AjPStr url = NULL;
AjPFile tmpfile = NULL;
AjPStr tmpname = NULL;
AjPFilebuff tmp = NULL;
AjPStr line = NULL;
AjPFile outf = NULL;
seqall = ajAcdGetSeqall("sequence");
coefficients = ajAcdGetInt("coefficients");
variable = ajAcdGetSelectSingle("variable");
accid = ajAcdGetBoolean("accid");
outf = ajAcdGetOutfile("outfile");
base = ajStrNewC("rest.g-language.org");
gAssignUniqueName(&tmpname);
while(ajSeqallNext(seqall, &seq))
{
inseq = NULL;
if(!accid)
{
if(gFormatGenbank(seq, &inseq))
{
tmpfile = ajFileNewOutNameS(tmpname);
if(!tmpfile)
{
ajDie("Output file (%S) open error\n", tmpname);
}
ajFmtPrintF(tmpfile, "%S", inseq);
ajFileClose(&tmpfile);
ajFmtPrintS(&url, "http://%S/upload/upl.pl", base);
gFilePostSS(url, tmpname, &restid);
ajStrDel(&url);
ajSysFileUnlinkS(tmpname);
}
else
{
ajDie("Sequence does not have features\n"
"Proceeding with sequence accession ID\n");
accid = ajTrue;
}
}
if(accid)
{
ajStrAssignS(&restid, ajSeqGetAccS(seq));
if(!ajStrGetLen(restid))
{
ajStrAssignS(&restid, ajSeqGetNameS(seq));
}
if(!ajStrGetLen(restid))
{
ajDie("No valid header information\n");
}
}
ajStrAssignS(&seqid, ajSeqGetAccS(seq));
url = ajStrNew();
ajFmtPrintS(&url, "http://%S/%S/lda_bias/coefficients=%d/variable=%S",
base, restid, coefficients, variable);
if(!gFilebuffURLS(url, &tmp))
{
ajDie("Failed to download result from:\n%S\n", url);
}
ajBuffreadLine(tmp, &line);
ajStrRemoveSetC(&line, "\n");
ajFmtPrintF(outf, "Sequence: %S LDA-BIAS: %S\n", seqid, line);
ajStrDel(&url);
ajStrDel(&inseq);
}
ajFileClose(&outf);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&seqid);
embExit();
return 0;
}
int main(int argc, char *argv[])
{
embInitPV("ggcskew", argc, argv, "GEMBASSY", "1.0.3");
AjPSeqall seqall;
AjPSeq seq;
AjPStr inseq = NULL;
AjBool accid = ajFalse;
AjPStr restid = NULL;
AjPStr seqid = NULL;
AjPStr base = NULL;
AjPStr url = NULL;
AjPStr tmpname = NULL;
AjPSeqout tmpout = NULL;
ajint window = 0;
ajint slide = 0;
AjBool cumulative = 0;
AjBool at = 0;
AjBool purine = 0;
AjBool keto = 0;
AjBool plot = 0;
AjPFile outf = NULL;
AjPFilebuff buff = NULL;
AjPGraph mult = NULL;
gPlotParams gpp;
AjPStr title = NULL;
seqall = ajAcdGetSeqall("sequence");
window = ajAcdGetInt("window");
slide = ajAcdGetInt("slide");
cumulative = ajAcdGetBoolean("cumulative");
at = ajAcdGetBoolean("at");
purine = ajAcdGetBoolean("purine");
keto = ajAcdGetBoolean("keto");
plot = ajAcdGetToggle("plot");
outf = ajAcdGetOutfile("outfile");
mult = ajAcdGetGraphxy("graph");
base = ajStrNewC("rest.g-language.org");
gAssignUniqueName(&tmpname);
ajStrAppendC(&tmpname, ".fasta");
while(ajSeqallNext(seqall, &seq))
{
tmpout = ajSeqoutNew();
if(!ajSeqoutOpenFilename(tmpout, tmpname))
{
embExitBad();
}
ajSeqoutSetFormatS(tmpout,ajStrNewC("fasta"));
ajSeqoutWriteSeq(tmpout, seq);
ajSeqoutClose(tmpout);
ajSeqoutDel(&tmpout);
ajFmtPrintS(&url, "http://%S/upload/upl.pl", base);
gFilePostSS(url, tmpname, &restid);
ajStrDel(&url);
ajSysFileUnlinkS(tmpname);
ajStrAssignS(&seqid, ajSeqGetAccS(seq));
if(ajStrGetLen(seqid) == 0)
{
ajStrAssignS(&seqid, ajSeqGetNameS(seq));
}
if(ajStrGetLen(seqid) == 0)
{
ajWarn("No valid header information\n");
}
url = ajStrNew();
ajFmtPrintS(&url, "http://%S/%S/gcskew/window=%d/slide=%d/cumulative=%d/"
"at=%d/purine=%d/keto=%d/output=f/", base, restid, window,
slide, cumulative, at, purine, keto);
if(plot)
{
title = ajStrNew();
ajStrAppendC(&title, argv[0]);
ajStrAppendC(&title, " of ");
ajStrAppendS(&title, seqid);
gpp.title = ajStrNewS(title);
gpp.xlab = ajStrNewC("location");
gpp.ylab = ajStrNewC("GC skew");
if(!gFilebuffURLS(url, &buff))
{
ajDie("File downloading error from:\n%S\n", url);
}
if(!gPlotFilebuff(buff, mult, &gpp))
{
ajDie("Error in plotting\n");
}
AJFREE(gpp.title);
AJFREE(gpp.xlab);
AJFREE(gpp.ylab);
ajStrDel(&title);
ajFilebuffDel(&buff);
}
else
{
ajFmtPrintF(outf, "Sequence: %S\n", seqid);
if(!gFileOutURLS(url, &outf))
{
ajDie("File downloading error from:\n%S\n", url);
}
}
ajStrDel(&url);
ajStrDel(&restid);
ajStrDel(&seqid);
}
ajFileClose(&outf);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&base);
embExit();
return 0;
}
static void extractfeat_BeforeAfter(const AjPSeq seq, AjPStr * featstr,
ajint firstpos, ajint lastpos,
ajint before, ajint after,
AjBool sense)
{
ajint start;
ajint end;
ajint featlen;
ajint len;
/*
** There is now:
** A complete set of joined features in featstr.
** 'sense' is FALSE if any feature was reverse sense (ignore 'compall'
** in this routine).
** 'firstpos' and 'lastpos' set to the first and last positions
** of the feature
*/
/*
** get start and end positions to truncate featstr at or to
** extract from seq
*/
/* do negative values of before/after */
featlen = ajStrGetLen(*featstr)-1;
start = 0;
end = featlen;
if(before < 0) /* negative, so before end */
start = end + before+1;
if(after < 0) /* negative, so after start */
end = start - after-1;
if(end < start)
{
ajWarn("Extraction region end less than start for %S [%d-%d]",
ajSeqGetNameS(seq), firstpos+1, lastpos+1);
return;
}
/*
** truncate the featstr
** if start or end are past start/end of featstr, use 0 or featlen
*/
if(before < 0 || after < 0)
{
ajDebug("truncating featstr to %d-%d\n",
start < 0 ? 0 : start, end>featlen ? featlen : end);
ajDebug("featstr len=%d bases\n", ajStrGetLen(*featstr));
ajStrKeepRange(featstr, start<0 ? 0 : start, end>featlen ? featlen :end);
ajDebug("featstr len=%d bases\n", ajStrGetLen(*featstr));
}
/*
** add surrounding sequence if past 0/featlen when before/after
** are negative
*/
if(start < 0)
{
ajDebug("start < 0\n");
len = -start;
if(sense)
extractfeat_GetRegionPad(seq, featstr, firstpos-len,
firstpos-1, sense, ajTrue);
else
extractfeat_GetRegionPad(seq, featstr, lastpos+1,
lastpos+len, sense, ajTrue);
}
if(end > featlen)
{
/* NB use the original length of featstr */
ajDebug("end > featlen\n");
len = end-featlen;
ajDebug("len=%d, end=%d\n", len, end);
if(sense)
extractfeat_GetRegionPad(seq, featstr, lastpos+1,
lastpos+len, sense, ajFalse);
else
extractfeat_GetRegionPad(seq, featstr, firstpos-len,
firstpos-1, sense, ajFalse);
}
/* add surrounding sequence if have positive values of before/after */
if(before > 0)
{
ajDebug("before > 0\n");
if(sense)
{
ajDebug("get Before firstpos=%d\n", firstpos);
extractfeat_GetRegionPad(seq, featstr, firstpos-before,
firstpos-1, sense, ajTrue);
}
else
{
ajDebug("get Before (reverse sense) lastpos=%d\n", lastpos);
extractfeat_GetRegionPad(seq, featstr, lastpos+1, lastpos+before,
sense, ajTrue);
}
}
if(after > 0)
{
ajDebug("after > 0\n");
if(sense)
{
ajDebug("get After lastpos=%d\n", lastpos);
extractfeat_GetRegionPad(seq, featstr, lastpos+1, lastpos+after,
sense, ajFalse);
}
else
{
ajDebug("get After (reverse sense) firstpos=%d\n", firstpos);
extractfeat_GetRegionPad(seq, featstr, firstpos-after,
firstpos-1, sense, ajFalse);
}
}
return;
}
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)
{
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[])
{
embInitPV("gbasezvalue", argc, argv, "GEMBASSY", "1.0.3");
AjPSeqall seqall;
AjPSeq seq;
AjPStr inseq = NULL;
AjPStr position = NULL;
ajint limit = 0;
ajint PatLen = 0;
ajint upstream = 0;
ajint downstream = 0;
AjBool accid = ajFalse;
AjPStr restid = NULL;
AjPStr seqid = NULL;
AjPStr base = NULL;
AjPStr url = NULL;
AjPFile tmpfile = NULL;
AjPStr tmpname = NULL;
AjPFile outf = NULL;
seqall = ajAcdGetSeqall("sequence");
position = ajAcdGetSelectSingle("position");
limit = ajAcdGetInt("limit");
PatLen = ajAcdGetInt("patlen");
upstream = ajAcdGetInt("upstream");
downstream = ajAcdGetInt("downstream");
accid = ajAcdGetBoolean("accid");
outf = ajAcdGetOutfile("outfile");
base = ajStrNewC("rest.g-language.org");
gAssignUniqueName(&tmpname);
while(ajSeqallNext(seqall, &seq))
{
inseq = NULL;
if(!accid)
{
if(gFormatGenbank(seq, &inseq))
{
tmpfile = ajFileNewOutNameS(tmpname);
if(!tmpfile)
{
ajDie("Output file (%S) open error\n", tmpname);
}
ajFmtPrintF(tmpfile, "%S", inseq);
ajFileClose(&tmpfile);
ajFmtPrintS(&url, "http://%S/upload/upl.pl", base);
gFilePostSS(url, tmpname, &restid);
ajStrDel(&url);
ajSysFileUnlinkS(tmpname);
}
else
{
ajWarn("Sequence does not have features\n"
"Proceeding with sequence accession ID\n");
accid = ajTrue;
}
}
ajStrAssignS(&seqid, ajSeqGetAccS(seq));
if(ajStrGetLen(seqid) == 0)
{
ajStrAssignS(&seqid, ajSeqGetNameS(seq));
}
if(ajStrGetLen(seqid) == 0)
{
ajWarn("No valid header information\n");
}
if(accid)
{
ajStrAssignS(&restid, seqid);
if(ajStrGetLen(seqid) == 0)
{
ajDie("Cannot proceed without header with -accid\n");
}
if(!gValID(seqid))
{
ajDie("Invalid accession ID:%S, exiting\n", seqid);
}
}
url = ajStrNew();
ajFmtPrintS(&url, "http://%S/%S/base_z_value/position=%S/PatLen=%d"
"upstream=%d/downstream=%d/limit=%d/output=f/tag=gene",
base, restid, position, PatLen, upstream, downstream, limit);
ajFmtPrintF(outf, "Sequence: %S\n", seqid);
if(!gFileOutURLS(url, &outf))
{
ajDie("Failed to download result from:\n%S\n", url);
}
ajStrDel(&url);
ajStrDel(&restid);
ajStrDel(&seqid);
ajStrDel(&inseq);
}
ajFileClose(&outf);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&base);
ajStrDel(&position);
embExit();
return 0;
}
int main(int argc, char *argv[])
{
embInitPV("genret", argc, argv, "GEMBASSY", "1.0.3");
AjPSeqall seqall;
AjPSeq seq = NULL;
AjPStr inseq = NULL;
AjPStr gene = NULL;
AjPStr access = NULL;
AjBool accid = ajTrue;
AjPStr argument = NULL;
AjPFile outfile = NULL;
AjPStr seqid = NULL;
AjPStr restid = NULL;
AjBool valid = ajFalse;
AjBool isseq = ajFalse;
AjBool isgbk = ajFalse;
AjPFilebuff buff = NULL;
AjPFile tmpfile = NULL;
AjPStr tmpname = NULL;
AjPStr regexstr = NULL;
AjPStrTok token = NULL;
AjPRegexp regex = NULL;
AjPStr url = NULL;
AjPStr base = NULL;
AjPStr head = NULL;
AjPStr line = NULL;
seqall = ajAcdGetSeqall("sequence");
access = ajAcdGetString("access");
gene = ajAcdGetString("gene");
argument = ajAcdGetString("argument");
accid = ajAcdGetBoolean("accid");
outfile = ajAcdGetOutfile("outfile");
if(
ajStrMatchC(access, "translation") ||
ajStrMatchC(access, "get_exon") ||
ajStrMatchC(access, "get_exons") ||
ajStrMatchC(access, "get_cdsseq") ||
ajStrMatchC(access, "get_gbkseq") ||
ajStrMatchC(access, "get_geneseq") ||
ajStrMatchC(access, "get_intron") ||
ajStrMatchC(access, "getseq") ||
ajStrMatchC(access, "seq") ||
ajStrMatchC(access, "around_startcodon") ||
ajStrMatchC(access, "around_stopcodon") ||
ajStrMatchC(access, "before_startcodon") ||
ajStrMatchC(access, "before_stopcodon") ||
ajStrMatchC(access, "after_startcodon") ||
ajStrMatchC(access, "after_stopcodon")
)
{
isseq = ajTrue;
}
else if(ajStrMatchC(access, "annotate") ||
ajStrMatchC(access, "output"))
{
isgbk = ajTrue;
}
else
{
ajFmtPrintF(outfile, "gene,%S\n", access);
}
base = ajStrNewC("rest.g-language.org");
ajStrExchangeCC(&argument, " ", "/");
ajStrExchangeCC(&argument, ",", "/");
ajStrExchangeCC(&argument, "\t", "/");
ajStrExchangeCC(&argument, "\r", "/");
ajStrExchangeCC(&argument, "\n", "/");
if(ajStrMatchC(gene, "*"))
{
ajStrInsertK(&gene, 0, '.');
}
if(ajStrPrefixC(gene, "@") || ajStrPrefixC(gene, "list::"))
{
ajStrExchangeCC(&gene, "@", "");
ajStrExchangeCC(&gene, "list::", "");
ajStrAssignS(&tmpname, gene);
tmpfile = ajFileNewInNameS(tmpname);
if(!tmpfile)
{
ajDie("List file (%S) open error\n", tmpname);
}
gene = ajStrNew();
while(ajReadline(tmpfile, &line))
{
ajStrAppendS(&gene, line);
}
ajFileClose(&tmpfile);
ajStrDel(&tmpname);
ajStrDel(&line);
}
tmpname = ajStrNew();
gAssignUniqueName(&tmpname);
while(ajSeqallNext(seqall, &seq))
{
inseq = ajStrNew();
if(!accid)
{
if(gFormatGenbank(seq, &inseq))
{
tmpfile = ajFileNewOutNameS(tmpname);
if(!tmpfile)
{
ajDie("Output file (%S) open error\n", tmpname);
}
ajFmtPrintF(tmpfile, "%S", inseq);
ajFileClose(&tmpfile);
ajFmtPrintS(&url, "http://%S/upload/upl.pl", base);
gFilePostSS(url, tmpname, &restid);
ajStrDel(&url);
ajSysFileUnlinkS(tmpname);
}
else
{
ajWarn("Sequence does not have features\n"
"Proceeding with sequence accession ID\n");
accid = ajTrue;
}
}
ajStrAssignS(&seqid, ajSeqGetAccS(seq));
if(ajStrGetLen(seqid) == 0)
{
ajStrAssignS(&seqid, ajSeqGetNameS(seq));
}
if(ajStrGetLen(seqid) == 0)
{
ajWarn("No valid header information\n");
}
if(accid)
{
ajStrAssignS(&restid, seqid);
if(ajStrGetLen(seqid) == 0)
{
ajDie("Cannot proceed without header with -accid\n");
}
if(!gValID(seqid))
{
ajDie("Invalid accession ID:%S, exiting\n", seqid);
}
}
url = ajStrNew();
if(isgbk)
{
ajFmtPrintS(&url, "http://%S/%S/%S", base, restid, access);
}
else
{
ajFmtPrintS(&url, "http://%S/%S/*/%S/%S", base, restid, access, argument);
}
if(!gFilebuffURLS(url, &buff))
{
ajDie("GET error from %S\n", url);
}
while(ajBuffreadLine(buff, &line))
{
if(isgbk){
ajFmtPrintF(outfile, "%S", line);
continue;
}
ajStrRemoveLastNewline(&line);
regex = ajRegCompC("^>");
if(ajRegExec(regex, line))
{
head = ajStrNew();
ajStrAssignS(&head, line);
ajStrTrimStartC(&head, ">");
valid = ajFalse;
token = ajStrTokenNewC(ajStrNewS(gene), " ,\t\r\n");
while(ajStrTokenNextParse(token, ®exstr))
{
if(ajStrGetLen(regexstr))
{
regex = ajRegComp(regexstr);
if(ajRegExec(regex, line))
{
valid = ajTrue;
if(ajStrIsAlnum(regexstr))
{
ajStrExchangeSC(&gene, regexstr, "");
}
}
ajRegFree(®ex);
}
}
}
else
{
if(valid)
{
if(isseq)
{
ajStrFmtWrap(&line, 60);
ajFmtPrintF(outfile, ">%S\n%S\n", head, line);
}
else
{
ajFmtPrintF(outfile, "%S,%S\n", head, line);
}
valid = ajFalse;
}
}
}
ajFileClose(&outfile);
ajStrDel(&restid);
ajStrDel(&seqid);
ajStrDel(&inseq);
}
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&access);
ajStrDel(&gene);
embExit();
}
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[])
{
embInitPV("gpalindrome", argc, argv, "GEMBASSY", "1.0.3");
struct soap soap;
struct ns1__palindromeInputParams params;
AjPSeqall seqall;
AjPSeq seq;
AjPStr inseq = NULL;
AjPStr seqid = NULL;
ajint shortest = 0;
ajint loop = 0;
AjBool gtmatch = 0;
char *in0;
char *result;
AjPFile outf = NULL;
seqall = ajAcdGetSeqall("sequence");
shortest = ajAcdGetInt("shortest");
loop = ajAcdGetInt("loop");
gtmatch = ajAcdGetBoolean("gtmatch");
outf = ajAcdGetOutfile("outfile");
params.shortest = shortest;
params.loop = loop;
params.gtmatch = gtmatch;
params.output = "f";
while(ajSeqallNext(seqall, &seq))
{
soap_init(&soap);
inseq = NULL;
ajStrAppendC(&inseq, ">");
ajStrAppendS(&inseq, ajSeqGetNameS(seq));
ajStrAppendC(&inseq, "\n");
ajStrAppendS(&inseq, ajSeqGetSeqS(seq));
ajStrAssignS(&seqid, ajSeqGetAccS(seq));
in0 = ajCharNewS(inseq);
if(soap_call_ns1__palindrome(
&soap,
NULL,
NULL,
in0,
¶ms,
&result
) == SOAP_OK)
{
ajFmtPrintF(outf, "Sequence: %S\n", seqid);
if(!gFileOutURLC(result, &outf))
{
ajDie("File downloading error from:\n%s\n", result);
embExitBad();
}
}
else
{
soap_print_fault(&soap, stderr);
}
soap_destroy(&soap);
soap_end(&soap);
soap_done(&soap);
AJFREE(in0);
ajStrDel(&inseq);
}
ajFileClose(&outf);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&seqid);
embExit();
return 0;
}
int main(int argc, char *argv[])
{
embInitPV("gdeltagcskew", argc, argv, "GEMBASSY", "1.0.3");
AjPSeqall seqall;
AjPSeq seq;
AjPStr inseq = NULL;
AjBool at = 0;
AjBool purine = 0;
AjBool keto = 0;
AjPStr method = 0;
AjBool accid = ajFalse;
AjPStr restid = NULL;
AjPStr seqid = NULL;
AjPStr base = NULL;
AjPStr url = NULL;
AjPFile tmpfile = NULL;
AjPStr tmpname = NULL;
AjPFilebuff tmp = NULL;
AjPStr line = NULL;
AjPFile outf = NULL;
seqall = ajAcdGetSeqall("sequence");
at = ajAcdGetBoolean("at");
purine = ajAcdGetBoolean("purine");
keto = ajAcdGetBoolean("keto");
method = ajAcdGetSelectSingle("method");
accid = ajAcdGetBoolean("accid");
outf = ajAcdGetOutfile("outfile");
base = ajStrNewC("rest.g-language.org");
gAssignUniqueName(&tmpname);
while(ajSeqallNext(seqall, &seq))
{
inseq = NULL;
if(!accid)
{
if(gFormatGenbank(seq, &inseq))
{
tmpfile = ajFileNewOutNameS(tmpname);
if(!tmpfile)
{
ajDie("Output file (%S) open error\n", tmpname);
}
ajFmtPrintF(tmpfile, "%S", inseq);
ajFileClose(&tmpfile);
ajFmtPrintS(&url, "http://%S/upload/upl.pl", base);
gFilePostSS(url, tmpname, &restid);
ajStrDel(&url);
ajSysFileUnlinkS(tmpname);
}
else
{
ajWarn("Sequence does not have features\n"
"Proceeding with sequence accession ID\n");
accid = ajTrue;
}
}
ajStrAssignS(&seqid, ajSeqGetAccS(seq));
if(ajStrGetLen(seqid) == 0)
{
ajStrAssignS(&seqid, ajSeqGetNameS(seq));
}
if(ajStrGetLen(seqid) == 0)
{
ajWarn("No valid header information\n");
}
if(accid)
{
ajStrAssignS(&restid, seqid);
if(ajStrGetLen(seqid) == 0)
{
ajDie("Cannot proceed without header with -accid\n");
}
if(!gValID(seqid))
{
ajDie("Invalid accession ID:%S, exiting\n", seqid);
}
}
url = ajStrNew();
ajFmtPrintS(&url, "http://%S/%S/delta_gcskew/", base, restid);
if(!gFilebuffURLS(url, &tmp))
{
ajDie("Failed to download result from:\n%S\n", url);
}
ajBuffreadLine(tmp, &line);
ajStrRemoveSetC(&line, "\n");
ajFmtPrintF(outf, "Sequence: %S DELTA-GCskew %S\n", seqid, line);
ajStrDel(&url);
ajStrDel(&restid);
ajStrDel(&seqid);
ajStrDel(&inseq);
}
ajFileClose(&outf);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&base);
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[])
{
embInitPV("gbaseinformationcontent", argc, argv, "GEMBASSY", "1.0.1");
AjPSeqall seqall;
AjPSeq seq;
AjPStr inseq = NULL;
AjPStr position = 0;
ajint PatLen = 0;
ajint upstream = 0;
ajint downstream = 0;
AjBool accid = ajFalse;
AjPStr restid = NULL;
AjPStr seqid = NULL;
AjPStr base = NULL;
AjPStr url = NULL;
AjPFile tmpfile = NULL;
AjPStr tmpname = NULL;
AjBool plot = 0;
AjPFile outf = NULL;
AjPFilebuff buff = NULL;
AjPGraph mult = NULL;
gPlotParams gpp;
AjPStr title = NULL;
seqall = ajAcdGetSeqall("sequence");
position = ajAcdGetSelectSingle("position");
PatLen = ajAcdGetInt("patlen");
upstream = ajAcdGetInt("upstream");
downstream = ajAcdGetInt("downstream");
accid = ajAcdGetBoolean("accid");
plot = ajAcdGetToggle("plot");
outf = ajAcdGetOutfile("outfile");
mult = ajAcdGetGraphxy("graph");
base = ajStrNewC("rest.g-language.org");
gAssignUniqueName(&tmpname);
while(ajSeqallNext(seqall, &seq))
{
inseq = NULL;
if(!accid)
{
if(gFormatGenbank(seq, &inseq))
{
gAssignUniqueName(&tmpname);
tmpfile = ajFileNewOutNameS(tmpname);
if(!tmpfile)
{
ajFmtError("Output file (%S) open error\n", tmpname);
embExitBad();
}
ajFmtPrintF(tmpfile, "%S", inseq);
ajFileClose(&tmpfile);
ajFmtPrintS(&url, "http://%S/upload/upl.pl", base);
gFilePostSS(url, tmpname, &restid);
ajStrDel(&url);
ajSysFileUnlinkS(tmpname);
}
else
{
ajFmtError("Sequence does not have features\n"
"Proceeding with sequence accession ID\n");
accid = ajTrue;
}
}
if(accid)
{
ajStrAssignS(&seqid, ajSeqGetAccS(seq));
if(!ajStrGetLen(seqid))
{
ajStrAssignS(&seqid, ajSeqGetNameS(seq));
}
if(!ajStrGetLen(seqid))
{
ajFmtError("No valid header information\n");
embExitBad();
}
ajStrAssignS(&restid, seqid);
}
ajStrAssignS(&seqid, ajSeqGetAccS(seq));
url = ajStrNew();
ajFmtPrintS(&url, "http://%S/%S/base_information_content/position=%S/"
"PatLen=%d/upstream=%d/downstream=%d/output=f/tag=gene",
base, restid, position, PatLen, upstream, downstream);
if(plot)
{
title = ajStrNew();
ajStrAppendC(&title, argv[0]);
ajStrAppendC(&title, " of ");
ajStrAppendS(&title, seqid);
gpp.title = ajStrNewS(title);
gpp.xlab = ajStrNewC("position");
gpp.ylab = ajStrNewC("information content");
if(!gFilebuffURLS(url, &buff))
{
ajDie("File downloading error from:\n%S\n", url);
}
if(!gPlotFilebuff(buff, mult, &gpp))
{
ajDie("Error in plotting\n");
}
AJFREE(gpp.title);
AJFREE(gpp.xlab);
AJFREE(gpp.ylab);
ajStrDel(&title);
ajFilebuffDel(&buff);
}
else
{
ajFmtPrintF(outf, "Sequence: %S\n", seqid);
if(!gFileOutURLS(url, &outf))
{
ajDie("File downloading error from:\n%S\n", url);
}
}
}
ajFileClose(&outf);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&seqid);
ajStrDel(&position);
embExit();
return 0;
}
int main(int argc, char *argv[])
{
embInitPV("gcircularmap", argc, argv, "GEMBASSY", "1.0.1");
struct soap soap;
struct ns1__circular_USCOREmapInputParams params;
AjPSeqall seqall;
AjPSeq seq;
AjPStr inseq = NULL;
AjPStr seqid = NULL;
AjBool accid = ajFalse;
AjPFile outf = NULL;
AjPStr filename = NULL;
AjPStr outfname = NULL;
AjPStr format = NULL;
ajint i;
char *in0;
char *result;
seqall = ajAcdGetSeqall("sequence");
filename = ajAcdGetString("goutfile");
accid = ajAcdGetBoolean("accid");
format = ajAcdGetString("format");
params.gmap = 0;
i = 0;
while(ajSeqallNext(seqall, &seq))
{
soap_init(&soap);
soap.send_timeout = 0;
soap.recv_timeout = 0;
inseq = NULL;
ajStrAssignS(&seqid, ajSeqGetAccS(seq));
if(!ajStrGetLen(seqid))
ajStrAssignS(&seqid, ajSeqGetNameS(seq));
if(!ajStrGetLen(seqid))
{
ajWarn("No valid header information\n");
}
if(accid || !gFormatGenbank(seq, &inseq))
{
if(!accid)
ajWarn("Sequence does not have features\n"
"Proceeding with sequence accession ID:%S\n", seqid);
if(!gValID(seqid))
{
ajDie("Invalid accession ID:%S, exiting\n", seqid);
}
ajStrAssignS(&inseq, seqid);
}
in0 = ajCharNewS(inseq);
if(soap_call_ns1__circular_USCOREmap(
&soap,
NULL,
NULL,
in0,
¶ms,
&result
) == SOAP_OK)
{
++i;
outfname = ajStrNewS(ajFmtStr("%S.%d.%S",
filename,
i,
format));
outf = ajFileNewOutNameS(outfname);
if(!outf)
{
ajDie("File open error\n");
}
if(!ajStrMatchC(format, "svg"))
{
if(!gHttpConvertC(result, &outf, ajStrNewC("svg"), format))
{
ajDie("File downloading error from:\n%s\n", result);
}
else
{
ajFmtPrint("Created %S\n", outfname);
}
}
else
{
if(!gHttpGetBinC(result, &outf))
{
ajDie("File downloading error from:\n%s\n", result);
}
else
{
ajFmtPrint("Created %S\n", outfname);
}
}
ajStrDel(&outfname);
}
else
{
soap_print_fault(&soap, stderr);
}
soap_destroy(&soap);
soap_end(&soap);
soap_done(&soap);
AJFREE(in0);
ajStrDel(&inseq);
}
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&seqid);
ajStrDel(&filename);
embExit();
return 0;
}
int main(int argc, char *argv[])
{
embInitPV("gp2", argc, argv, "GEMBASSY", "1.0.1");
AjPSeqall seqall;
AjPSeq seq;
AjPStr inseq = NULL;
AjBool accid = ajFalse;
AjPStr restid = NULL;
AjPStr seqid = NULL;
AjPStr base = NULL;
AjPStr url = NULL;
AjPFile tmpfile = NULL;
AjPStr tmpname = NULL;
AjPFile outf = NULL;
seqall = ajAcdGetSeqall("sequence");
accid = ajAcdGetBoolean("accid");
outf = ajAcdGetOutfile("outfile");
base = ajStrNewC("rest.g-language.org");
gAssignUniqueName(&tmpname);
while(ajSeqallNext(seqall, &seq))
{
inseq = NULL;
if(!accid)
{
if(gFormatGenbank(seq, &inseq))
{
tmpfile = ajFileNewOutNameS(tmpname);
if(!tmpfile)
{
ajDie("Output file (%S) open error\n", tmpname);
}
ajFmtPrintF(tmpfile, "%S", inseq);
ajFileClose(&tmpfile);
ajFmtPrintS(&url, "http://%S/upload/upl.pl", base);
gFilePostSS(url, tmpname, &restid);
ajStrDel(&url);
ajSysFileUnlinkS(tmpname);
}
else
{
ajDie("Sequence does not have features\n"
"Proceeding with sequence accession ID\n");
accid = ajTrue;
}
}
if(accid)
{
ajStrAssignS(&restid, ajSeqGetAccS(seq));
if(!ajStrGetLen(restid))
{
ajStrAssignS(&restid, ajSeqGetNameS(seq));
}
if(!ajStrGetLen(restid))
{
ajDie("No valid header information\n");
}
}
ajStrAssignS(&seqid, ajSeqGetAccS(seq));
url = ajStrNew();
ajFmtPrintS(&url, "http://%S/%S/P2/output=f/tag=gene", base, restid);
ajFmtPrintF(outf, "Sequence: %S\n", seqid);
if(!gFileOutURLS(url, &outf))
{
ajDie("Failed to download result from:\n%S\n", url);
}
ajStrDel(&url);
ajStrDel(&inseq);
}
ajFileClose(&outf);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&seqid);
embExit();
return 0;
}
int main(int argc, char *argv[])
{
embInitPV("ggeneskew", argc, argv, "GEMBASSY", "1.0.3");
AjPSeqall seqall;
AjPSeq seq;
AjPStr inseq = NULL;
ajint window = 0;
ajint slide = 0;
AjBool cumulative = ajFalse;
AjBool gc3 = ajFalse;
AjPStr basetype = NULL;
AjBool accid = ajFalse;
AjPStr restid = NULL;
AjPStr seqid = NULL;
AjPStr base = NULL;
AjPStr url = NULL;
AjPFile tmpfile = NULL;
AjPStr tmpname = NULL;
AjBool plot = 0;
AjPFile outf = NULL;
AjPFilebuff buff = NULL;
AjPGraph mult = NULL;
gPlotParams gpp;
AjPStr title = NULL;
seqall = ajAcdGetSeqall("sequence");
window = ajAcdGetInt("window");
slide = ajAcdGetInt("slide");
cumulative = ajAcdGetBoolean("cumulative");
gc3 = ajAcdGetBoolean("gctri");
basetype = ajAcdGetSelectSingle("base");
accid = ajAcdGetBoolean("accid");
plot = ajAcdGetToggle("plot");
outf = ajAcdGetOutfile("outfile");
mult = ajAcdGetGraphxy("graph");
if(ajStrMatchC(base, "none"))
basetype = ajStrNewC("");
base = ajStrNewC("rest.g-language.org");
gAssignUniqueName(&tmpname);
while(ajSeqallNext(seqall, &seq))
{
inseq = NULL;
if(!accid)
{
if(gFormatGenbank(seq, &inseq))
{
gAssignUniqueName(&tmpname);
tmpfile = ajFileNewOutNameS(tmpname);
if(!tmpfile)
{
ajFmtError("Output file (%S) open error\n", tmpname);
embExitBad();
}
ajFmtPrintF(tmpfile, "%S", inseq);
ajFileClose(&tmpfile);
ajFmtPrintS(&url, "http://%S/upload/upl.pl", base);
gFilePostSS(url, tmpname, &restid);
ajStrDel(&url);
ajSysFileUnlinkS(tmpname);
}
else
{
ajFmtError("Sequence does not have features\n"
"Proceeding with sequence accession ID\n");
accid = ajTrue;
}
}
ajStrAssignS(&seqid, ajSeqGetAccS(seq));
if(ajStrGetLen(seqid) == 0)
{
ajStrAssignS(&seqid, ajSeqGetNameS(seq));
}
if(ajStrGetLen(seqid) == 0)
{
ajWarn("No valid header information\n");
}
if(accid)
{
ajStrAssignS(&restid, seqid);
if(ajStrGetLen(seqid) == 0)
{
ajDie("Cannot proceed without header with -accid\n");
}
if(!gValID(seqid))
{
ajDie("Invalid accession ID:%S, exiting\n", seqid);
}
}
url = ajStrNew();
ajFmtPrintS(&url, "http://%S/%S/geneskew/window=%d/slide=%d/"
"cumulative=%d/gc3=%d/base=%S/output=f/tag=gene",
base, restid, window, slide, cumulative, gc3, basetype);
if(plot)
{
title = ajStrNew();
ajStrAppendC(&title, argv[0]);
ajStrAppendC(&title, " of ");
ajStrAppendS(&title, seqid);
gpp.title = ajStrNewS(title);
gpp.xlab = ajStrNewC("gene skew");
gpp.ylab = ajStrNewC("bp");
if(!gFilebuffURLS(url, &buff))
{
ajDie("File downloading error from:\n%S\n", url);
}
if(!gPlotFilebuff(buff, mult, &gpp))
{
ajDie("Error in plotting\n");
}
AJFREE(gpp.title);
AJFREE(gpp.xlab);
AJFREE(gpp.ylab);
ajStrDel(&title);
ajFilebuffDel(&buff);
}
else
{
ajFmtPrintF(outf, "Sequence: %S\n", seqid);
if(!gFileOutURLS(url, &outf))
{
ajDie("File downloading error from:\n%S\n", url);
}
}
ajStrDel(&url);
ajStrDel(&restid);
ajStrDel(&seqid);
ajStrDel(&inseq);
}
ajFileClose(&outf);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&base);
embExit();
return 0;
}
int main(int argc, char **argv)
{
ajint begin, end;
AjPSeqall seqall;
AjPSeq seq;
EmbPShow ss;
AjPFile outfile;
AjPStr tablename;
ajint table;
AjPRange uppercase;
AjPRange highlight;
AjBool threeletter;
AjBool numberseq;
AjBool nameseq;
ajint width;
ajint length;
ajint margin;
AjBool description;
ajint offset;
AjBool html;
AjPStr descriptionline;
ajint orfminsize;
AjPTrn trnTable;
AjBool translation;
AjBool reverse;
AjBool cutlist;
AjBool flat;
EmbPMatMatch mm = NULL;
AjPStr *framelist;
AjBool frames[6]; /* frames to be translated 1 to 3, -1 to -3 */
/* stuff for tables and lists of enzymes and hits */
ajint default_mincuts = 1;
ajint default_maxcuts = 2000000000;
AjPTable hittable; /* enzyme hits */
/* stuff lifted from Alan's 'restrict.c' */
AjPStr enzymes = NULL;
ajint mincuts;
ajint maxcuts;
ajint sitelen;
AjBool single;
AjBool blunt;
AjBool sticky;
AjBool ambiguity;
AjBool plasmid;
AjBool commercial;
AjBool limit;
AjBool methyl;
AjPFile enzfile = NULL;
AjPFile equfile = NULL;
AjPFile methfile = NULL;
AjPTable retable = NULL;
ajint hits;
AjPList restrictlist = NULL;
embInit("remap", argc, argv);
seqall = ajAcdGetSeqall("sequence");
outfile = ajAcdGetOutfile("outfile");
tablename = ajAcdGetListSingle("table");
uppercase = ajAcdGetRange("uppercase");
highlight = ajAcdGetRange("highlight");
threeletter = ajAcdGetBoolean("threeletter");
numberseq = ajAcdGetBoolean("number");
width = ajAcdGetInt("width");
length = ajAcdGetInt("length");
margin = ajAcdGetInt("margin");
nameseq = ajAcdGetBoolean("name");
description = ajAcdGetBoolean("description");
offset = ajAcdGetInt("offset");
html = ajAcdGetBoolean("html");
orfminsize = ajAcdGetInt("orfminsize");
translation = ajAcdGetBoolean("translation");
reverse = ajAcdGetBoolean("reverse");
cutlist = ajAcdGetBoolean("cutlist");
flat = ajAcdGetBoolean("flatreformat");
framelist = ajAcdGetList("frame");
/* restriction enzyme stuff */
mincuts = ajAcdGetInt("mincuts");
maxcuts = ajAcdGetInt("maxcuts");
sitelen = ajAcdGetInt("sitelen");
single = ajAcdGetBoolean("single");
blunt = ajAcdGetBoolean("blunt");
sticky = ajAcdGetBoolean("sticky");
ambiguity = ajAcdGetBoolean("ambiguity");
plasmid = ajAcdGetBoolean("plasmid");
commercial = ajAcdGetBoolean("commercial");
limit = ajAcdGetBoolean("limit");
enzymes = ajAcdGetString("enzymes");
methfile = ajAcdGetDatafile("mfile");
methyl = ajAcdGetBoolean("methylation");
if(!blunt && !sticky)
ajFatal("Blunt/Sticky end cutters shouldn't both be disabled.");
/* get the number of the genetic code used */
ajStrToInt(tablename, &table);
trnTable = ajTrnNewI(table);
/* read the local file of enzymes names */
remap_read_file_of_enzyme_names(&enzymes);
/* get the frames to be translated */
remap_GetFrames(framelist, frames);
while(ajSeqallNext(seqall, &seq))
{
/* get begin and end positions */
begin = ajSeqGetBegin(seq)-1;
end = ajSeqGetEnd(seq)-1;
/* do the name and description */
if(nameseq)
{
if(html)
ajFmtPrintF(outfile, "<H2>%S</H2>\n",
ajSeqGetNameS(seq));
else
ajFmtPrintF(outfile, "%S\n", ajSeqGetNameS(seq));
}
if(description)
{
/*
** wrap the description line at the width of the sequence
** plus margin
*/
if(html)
ajFmtPrintF(outfile, "<H3>%S</H3>\n",
ajSeqGetDescS(seq));
else
{
descriptionline = ajStrNew();
ajStrAssignS(&descriptionline, ajSeqGetDescS(seq));
ajStrFmtWrap(&descriptionline, width+margin);
ajFmtPrintF(outfile, "%S\n", descriptionline);
ajStrDel(&descriptionline);
}
}
/* get the restriction cut sites */
/*
** most of this is lifted from the program 'restrict.c' by Alan
** Bleasby
*/
if(single)
maxcuts=mincuts=1;
retable = ajTablestrNew(EQUGUESS);
enzfile = ajDatafileNewInNameC(ENZDATA);
if(!enzfile)
ajFatal("Cannot locate enzyme file. Run REBASEEXTRACT");
if(limit)
{
equfile = ajDatafileNewInNameC(EQUDATA);
if(!equfile)
limit = ajFalse;
else
remap_read_equiv(&equfile, &retable, commercial);
}
ajFileSeek(enzfile, 0L, 0);
restrictlist = ajListNew();
/* search for hits, but don't use mincuts and maxcuts criteria yet */
hits = embPatRestrictMatch(seq, begin+1, end+1, enzfile, methfile,
enzymes, sitelen,plasmid, ambiguity,
default_mincuts, default_maxcuts, blunt,
sticky, commercial, methyl,
restrictlist);
ajDebug("Remap found %d hits\n", hits);
if(hits)
{
/* this bit is lifted from printHits */
embPatRestrictRestrict(restrictlist, hits, !limit,
ajFalse);
if(limit)
remap_RestrictPreferred(restrictlist,retable);
}
ajFileClose(&enzfile);
ajFileClose(&methfile);
/*
** Remove those violating the mincuts and maxcuts
** criteria, but save them in hittable for printing out later.
** Keep a count of how many hits each enzyme gets in hittable.
*/
hittable = ajTablestrNewCase(TABLEGUESS);
remap_RemoveMinMax(restrictlist, hittable, mincuts, maxcuts);
/* make the Show Object */
ss = embShowNew(seq, begin, end, width, length, margin, html, offset);
if(html)
ajFmtPrintF(outfile, "<PRE>");
/* create the format to display */
embShowAddBlank(ss);
embShowAddRE(ss, 1, restrictlist, plasmid, flat);
embShowAddSeq(ss, numberseq, threeletter, uppercase, highlight);
if(!numberseq)
embShowAddTicknum(ss);
embShowAddTicks(ss);
if(reverse)
{
embShowAddComp(ss, numberseq);
embShowAddRE(ss, -1, restrictlist, plasmid, flat);
}
if(translation)
{
if(reverse)
embShowAddBlank(ss);
if(frames[0])
embShowAddTran(ss, trnTable, 1, threeletter,
numberseq, NULL, orfminsize,
AJFALSE, AJFALSE, AJFALSE, AJFALSE);
if(frames[1])
embShowAddTran(ss, trnTable, 2, threeletter,
numberseq, NULL, orfminsize,
AJFALSE, AJFALSE, AJFALSE, AJFALSE);
if(frames[2])
embShowAddTran(ss, trnTable, 3, threeletter,
numberseq, NULL, orfminsize,
AJFALSE, AJFALSE, AJFALSE, AJFALSE);
if(reverse)
{
embShowAddTicks(ss);
if(frames[5])
embShowAddTran(ss, trnTable, -3, threeletter,
numberseq, NULL, orfminsize,
AJFALSE, AJFALSE, AJFALSE, AJFALSE);
if(frames[4])
embShowAddTran(ss, trnTable, -2, threeletter,
numberseq, NULL, orfminsize,
AJFALSE, AJFALSE, AJFALSE, AJFALSE);
if(frames[3])
embShowAddTran(ss, trnTable, -1, threeletter,
numberseq, NULL, orfminsize,
AJFALSE, AJFALSE, AJFALSE, AJFALSE);
}
}
embShowPrint(outfile, ss);
/* display a list of the Enzymes that cut and don't cut */
if(cutlist)
{
remap_CutList(outfile, hittable,
limit, html, mincuts, maxcuts);
remap_NoCutList(outfile, hittable, html, enzymes, blunt,
sticky, sitelen, commercial, ambiguity,
limit, retable);
}
/* add a gratuitous newline at the end of the sequence */
ajFmtPrintF(outfile, "\n");
/* tidy up */
embShowDel(&ss);
while(ajListPop(restrictlist,(void **)&mm))
embMatMatchDel(&mm);
ajListFree(&restrictlist);
remap_DelTable(&hittable);
ajTablestrFree(&retable);
}
ajTrnDel(&trnTable);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajFileClose(&outfile);
ajStrDel(&tablename);
ajStrDel(&enzymes);
ajStrDelarray(&framelist);
ajRangeDel(&uppercase);
ajRangeDel(&highlight);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPSeq seq = NULL;
AjPReport report = NULL;
AjPFeattable feat=NULL;
AjPStr sstr = NULL;
const AjPStr sname = NULL;
AjPStr revcomp = NULL;
ajint RStotal;
AjPStr enzymes = NULL; /* string for RE selection */
AjPList relist = NULL;
ajint begin;
ajint end;
ajint radj;
ajint start;
AjBool sshow;
AjBool tshow;
AjBool allmut;
AjPList results1 = NULL; /* for forward strand */
AjPList results2 = NULL; /* for reverse strand */
AjPList shits;
AjPList nshits;
AjPStr tailstr = NULL;
embInit("silent", argc, argv);
seq = ajAcdGetSeq("sequence");
enzymes = ajAcdGetString("enzymes");
sshow = ajAcdGetBoolean("sshow");
tshow = ajAcdGetBoolean("tshow");
allmut = ajAcdGetBoolean("allmut");
report = ajAcdGetReport ("outfile");
shits = ajListNew();
nshits = ajListNew();
/*calling function to read in RE info*/
RStotal = silent_restr_read(&relist,enzymes);
begin = ajSeqGetBegin(seq); /* returns the seq start posn, or 1
if no start has been set */
end = ajSeqGetEnd(seq); /* returns the seq end posn, or seq
length if no end has been set */
radj=begin+end+1; /* posn adjustment for complementary
strand */
ajStrAssignSubC(&sstr,ajSeqGetSeqC(seq),--begin,--end);
ajStrFmtUpper(&sstr);
sname = ajSeqGetNameS(seq);
ajStrAssignC(&revcomp,ajStrGetPtr(sstr));
ajSeqstrReverse(&revcomp);
start = begin+1;
feat = ajFeattableNewDna(ajSeqGetNameS(seq));
if(sshow)
{
silent_fmt_sequence("SEQUENCE", sstr,&tailstr,start,ajTrue);
}
results1 = silent_mismatch(sstr,relist,&tailstr,sname,RStotal,begin,radj,
ajFalse,end,tshow);
silent_split_hits(&results1,&shits,&nshits,allmut);
ajReportSetHeaderC(report,
"KEY:\n"
"EnzymeName: Enzyme name\n"
"RS-Pattern: Restriction enzyme recognition site "
"pattern\n"
"Base-Posn: Position of base to be mutated\n"
"AAs: Amino acid. Original sequence(.)After mutation\n"
"Silent: Yes for unchanged amino acid\n"
"Mutation: The base mutation to perform\n\n"
"Creating silent and non-silent mutations\n");
silent_fmt_hits(shits,feat, ajTrue, ajFalse);
if(allmut)
{
silent_fmt_hits(nshits,feat, ajFalse, ajFalse);
}
if(sshow)
{
silent_fmt_sequence("REVERSE SEQUENCE", revcomp,&tailstr,start,ajTrue);
}
results2 = silent_mismatch(revcomp,relist,&tailstr,
sname,RStotal,begin,radj,
ajTrue,end,tshow);
silent_split_hits(&results2,&shits,&nshits,allmut);
silent_fmt_hits(shits,feat, ajTrue, ajTrue);
if(allmut)
{
silent_fmt_hits(nshits,feat, ajFalse, ajTrue);
}
ajReportSetStatistics(report, 1, ajSeqGetLenTrimmed(seq));
ajReportSetTailS(report, tailstr);
(void) ajReportWrite (report,feat,seq);
ajFeattableDel(&feat);
ajStrDel(&revcomp);
ajStrDel(&enzymes);
ajListFree(&results1);
ajListFree(&results2);
ajListFree(&shits);
ajListFree(&nshits);
ajReportClose(report);
ajReportDel(&report);
ajSeqDel(&seq);
ajStrDel(&sstr);
silent_relistdel(&relist);
ajStrDel(&tailstr);
embExit();
return 0;
}
