int main(int argc, char **argv) {
embInitPV("kmafft", argc, argv, "KBWS", "1.0.8");
struct soap soap;
struct ns1__mafftInputParams params;
char* jobid;
char* result;
AjPSeqall seqall;
AjPSeq seq;
AjPFile outf;
AjPStr substr;
AjPStr inseq = NULL;
AjPStr strategy;
AjPStr outorder;
float op;
float ep;
AjPStr scorematrix;
AjBool homologs;
AjBool showhomologs;
float threshold;
AjPStr referenceseq;
AjPStr harrplot;
strategy = ajAcdGetString("strategy");
outorder = ajAcdGetString("outorder");
op = ajAcdGetFloat("op");
ep = ajAcdGetFloat("ep");
scorematrix = ajAcdGetString("scorematrix");
homologs = ajAcdGetBoolean("homologs");
showhomologs = ajAcdGetBoolean("showhomologs");
threshold = ajAcdGetFloat("threshold");
referenceseq = ajAcdGetString("referenceseq");
harrplot = ajAcdGetString("harrplot");
seqall = ajAcdGetSeqall("seqall");
outf = ajAcdGetOutfile("outfile");
params.strategy = ajCharNewS(strategy);
params.outorder = ajCharNewS(outorder);
params.op = op;
params.ep = ep;
params.scorematrix = ajCharNewS(scorematrix);
if (homologs) {
params.homologs = xsd__boolean__true_;
} else {
params.homologs = xsd__boolean__false_;
}
if (showhomologs) {
params.showhomologs = xsd__boolean__true_;
} else {
params.showhomologs = xsd__boolean__false_;
}
params.threshold = threshold;
params.referenceseq = ajCharNewS(referenceseq);
params.harrplot = ajCharNewS(harrplot);
AjPStr tmp = NULL;
AjPStr tmpFileName = NULL;
AjPSeqout fil_file;
AjPStr line = NULL; /* if "AjPStr line; -> ajReadline is not success!" */
AjPStr sizestr = NULL;
ajint thissize;
ajint nb = 0;
AjBool are_prot = ajFalse;
ajint size = 0;
AjPFile infile;
tmp = ajStrNewC("fasta");
fil_file = ajSeqoutNew();
tmpFileName = getUniqueFileName();
if( !ajSeqoutOpenFilename(fil_file, tmpFileName) ) {
embExitBad();
}
ajSeqoutSetFormatS(fil_file, tmp);
while (ajSeqallNext(seqall, &seq)) {
if (!nb) {
are_prot = ajSeqIsProt(seq);
}
ajSeqoutWriteSeq(fil_file, seq);
++nb;
}
ajSeqoutClose(fil_file);
ajSeqoutDel(&fil_file);
if (nb < 2) {
ajFatal("Multiple alignments need at least two sequences");
}
infile = ajFileNewInNameS(tmpFileName);
while (ajReadline(infile, &line)) {
ajStrAppendS(&inseq,line);
ajStrAppendC(&inseq,"\n");
}
soap_init(&soap);
char* in0;
in0 = ajCharNewS(inseq);
if ( soap_call_ns1__runMafft( &soap, NULL, NULL, in0, ¶ms, &jobid ) == SOAP_OK ) {
fprintf(stderr,"Jobid: %s\n",jobid);
} else {
soap_print_fault(&soap, stderr);
}
int check = 0;
while ( check == 0 ) {
if ( soap_call_ns1__checkStatus( &soap, NULL, NULL, jobid, &check ) == SOAP_OK ) {
fprintf(stderr,"*");
} else {
soap_print_fault(&soap, stderr);
}
sleep(3);
}
fprintf(stderr,"\n");
if ( soap_call_ns1__getResult( &soap, NULL, NULL, jobid, &result ) == SOAP_OK ) {
substr = ajStrNewC(result);
ajFmtPrintF(outf,"%S\n",substr);
} else {
soap_print_fault(&soap, stderr);
}
ajSysFileUnlinkS(tmpFileName);
soap_destroy(&soap);
soap_end(&soap);
soap_done(&soap);
ajFileClose(&outf);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&substr);
embExit();
return 0;
}
int main(int argc, char **argv) {
embInitPV("kdnapenny", argc, argv, "KBWS", "1.0.8");
struct soap soap;
char* jobid;
char* result;
AjPSeqall seqall;
AjPSeq seq;
AjPFile outf;
AjPStr substr;
AjPStr inseq = NULL;
seqall = ajAcdGetSeqall("seqall");
outf = ajAcdGetOutfile("outfile");
AjPStr tmp = NULL;
AjPStr tmpFileName = NULL;
AjPSeqout fil_file;
AjPStr line = NULL;
AjPStr sizestr = NULL;
ajint thissize = 0;
ajint nb = 0;
AjBool are_prot = ajFalse;
ajint size = 0;
AjPFile infile;
tmp = ajStrNewC("fasta");
fil_file = ajSeqoutNew();
tmpFileName = getUniqueFileName();
if( !ajSeqoutOpenFilename(fil_file, tmpFileName) ) {
embExitBad();
}
ajSeqoutSetFormatS(fil_file, tmp);
while (ajSeqallNext(seqall, &seq)) {
if (!nb) {
are_prot = ajSeqIsProt(seq);
}
ajSeqoutWriteSeq(fil_file, seq);
++nb;
}
ajSeqoutClose(fil_file);
ajSeqoutDel(&fil_file);
if (nb < 2) {
ajFatal("Multiple alignments need at least two sequences");
}
infile = ajFileNewInNameS(tmpFileName);
while (ajReadline(infile, &line)) {
ajStrAppendS(&inseq,line);
ajStrAppendC(&inseq,"\n");
}
soap_init(&soap);
char* in0;
in0 = ajCharNewS(inseq);
if ( soap_call_ns1__runDnapenny( &soap, NULL, NULL, in0, &jobid ) == SOAP_OK ) {
fprintf(stderr,"Jobid: %s\n",jobid);
} else {
soap_print_fault(&soap, stderr);
}
int check = 0;
while ( check == 0 ) {
if ( soap_call_ns1__checkStatus( &soap, NULL, NULL, jobid, &check ) == SOAP_OK ) {
fprintf(stderr,"*");
} else {
soap_print_fault(&soap, stderr);
}
sleep(3);
}
fprintf(stderr, "\n");
if ( soap_call_ns1__getResult( &soap, NULL, NULL, jobid, &result ) == SOAP_OK ) {
substr = ajStrNewC(result);
ajFmtPrintF(outf,"%S\n",substr);
} else {
soap_print_fault(&soap, stderr);
}
ajSysFileUnlinkS(tmpFileName);
soap_destroy(&soap);
soap_end(&soap);
soap_done(&soap);
ajFileClose(&outf);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&substr);
embExit();
return 0;
}
int main(int argc, char **argv) {
// initialize EMBASSY info
embInitPV("kweblogo", argc, argv, "KBWS", "1.0.9");
// soap driver and parameter object
struct soap soap;
struct ns1__weblogoInputParams params;
char* jobid;
AjPSeqall seqall;
AjPSeq seq;
AjPStr substr;
AjPStr inseq = NULL;
// get input sequence
seqall= ajAcdGetSeqall("seqall");
// get/set parameters
params.format = ajCharNewS(ajAcdGetString("format"));
AjPStr tmp= NULL;
AjPStr tmpFileName= NULL;
AjPSeqout fil_file;
AjPStr line= NULL; /* if "AjPStr line; -> ajReadline is not success!" */
AjPStr sizestr= NULL;
ajint thissize;
ajint nb= 0;
AjBool are_prot= ajFalse;
ajint size= 0;
AjPFile infile;
AjPFile goutf;
AjPStr goutfile;
goutfile= ajAcdGetString("goutfile");
tmp= ajStrNewC("fasta");
fil_file= ajSeqoutNew();
tmpFileName= getUniqueFileName();
if(!ajSeqoutOpenFilename(fil_file, tmpFileName)) {
embExitBad();
}
ajSeqoutSetFormatS(fil_file, tmp);
while (ajSeqallNext(seqall, &seq)) {
if (!nb) {
are_prot = ajSeqIsProt(seq);
}
ajSeqoutWriteSeq(fil_file, seq);
++nb;
}
ajSeqoutClose(fil_file);
ajSeqoutDel(&fil_file);
if (nb < 2) {
ajFatal("Multiple alignments need at least two sequences");
}
infile = ajFileNewInNameS(tmpFileName);
while (ajReadline(infile, &line)) {
ajStrAppendS(&inseq,line);
ajStrAppendC(&inseq,"\n");
}
soap_init(&soap);
char* in0;
in0= ajCharNewS(inseq);
if (soap_call_ns1__runWeblogo( &soap, NULL, NULL, in0, ¶ms, &jobid) == SOAP_OK) {
} else {
soap_print_fault(&soap, stderr);
}
int check= 0;
while (check == 0 ) {
if (soap_call_ns1__checkStatus(&soap, NULL, NULL, jobid, &check) == SOAP_OK) {
} else {
soap_print_fault(&soap, stderr);
}
sleep(3);
}
char* image_url;
if (soap_call_ns1__getResult(&soap, NULL, NULL, jobid, &image_url) == SOAP_OK) {
goutf= ajFileNewOutNameS(goutfile);
if (!goutf) {
// can not open image output file
ajFmtError("Problem writing out image file");
embExitBad();
}
if (!gHttpGetBinC(image_url, &goutf)) {
// can not download image file
ajFmtError("Problem downloading image file");
embExitBad();
}
} else {
soap_print_fault(&soap, stderr);
}
// delete temporary multi-fasta sequence file
ajSysFileUnlinkS(tmpFileName);
// destruct SOAP driver
soap_destroy(&soap);
soap_end(&soap);
soap_done(&soap);
// destruct EMBOSS object
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&substr);
// exit
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPSeqall seqall = NULL;
AjPFile dend_outfile = NULL;
AjPStr tmp_dendfilename = NULL;
AjPFile tmp_dendfile = NULL;
AjPStr tmp_aln_outfile = NULL;
AjPSeqset seqset = NULL;
AjPSeqout seqout = NULL;
AjPSeqin seqin = NULL;
AjBool only_dend;
AjBool are_prot = ajFalse;
AjBool do_slow;
AjBool use_dend;
AjPFile dend_file = NULL;
AjPStr dend_filename = NULL;
ajint ktup;
ajint gapw;
ajint topdiags;
ajint window;
AjBool nopercent;
AjPStr pw_matrix = NULL;
AjPStr pw_dna_matrix = NULL;
AjPFile pairwise_matrix = NULL;
float pw_gapc;
float pw_gapv;
AjPStr pwmstr = NULL;
char pwmc = '\0';
AjPStr pwdstr = NULL;
char pwdc = '\0';
AjPStr m1str = NULL;
AjPStr m2str = NULL;
char m1c = '\0';
char m2c = '\0';
AjPStr matrix = NULL;
AjPStr dna_matrix = NULL;
AjPFile ma_matrix = NULL;
float gapc;
float gapv;
AjBool endgaps;
AjBool norgap;
AjBool nohgap;
ajint gap_dist;
ajint maxdiv;
AjPStr hgapres = NULL;
AjPSeqout fil_file = NULL;
AjPSeq seq = NULL;
AjPStr cmd = NULL;
AjPStr tmp = NULL;
AjPStr tmpFilename;
AjPStr line = NULL;
ajint nb = 0;
/* get all the parameters */
embInit("emma", argc, argv);
pwmstr = ajStrNew();
pwdstr = ajStrNew();
m1str = ajStrNew();
m2str = ajStrNew();
seqall = ajAcdGetSeqall("sequence");
seqout = ajAcdGetSeqoutset("outseq");
dend_outfile = ajAcdGetOutfile("dendoutfile");
only_dend = ajAcdGetToggle("onlydend");
use_dend = ajAcdGetToggle("dendreuse");
dend_file = ajAcdGetInfile("dendfile");
if (dend_file)
ajStrAssignS(&dend_filename, ajFileGetPrintnameS(dend_file));
ajFileClose(&dend_file);
do_slow = ajAcdGetToggle("slowalign");
ktup = ajAcdGetInt("ktup");
gapw = ajAcdGetInt("gapw");
topdiags = ajAcdGetInt("topdiags");
window = ajAcdGetInt("window");
nopercent = ajAcdGetBoolean("nopercent");
pw_matrix = ajAcdGetListSingle("pwmatrix");
pwmc = ajStrGetCharFirst(pw_matrix);
if(pwmc=='b')
ajStrAssignC(&pwmstr,"blosum");
else if(pwmc=='p')
ajStrAssignC(&pwmstr,"pam");
else if(pwmc=='g')
ajStrAssignC(&pwmstr,"gonnet");
else if(pwmc=='i')
ajStrAssignC(&pwmstr,"id");
else if(pwmc=='o')
ajStrAssignC(&pwmstr,"own");
pw_dna_matrix = ajAcdGetListSingle("pwdnamatrix");
pwdc = ajStrGetCharFirst(pw_dna_matrix);
if(pwdc=='i')
ajStrAssignC(&pwdstr,"iub");
else if(pwdc=='c')
ajStrAssignC(&pwdstr,"clustalw");
else if(pwdc=='o')
ajStrAssignC(&pwdstr,"own");
pairwise_matrix = ajAcdGetInfile("pairwisedatafile");
pw_gapc = ajAcdGetFloat( "pwgapopen");
pw_gapv = ajAcdGetFloat( "pwgapextend");
matrix = ajAcdGetListSingle( "matrix");
m1c = ajStrGetCharFirst(matrix);
if(m1c=='b')
ajStrAssignC(&m1str,"blosum");
else if(m1c=='p')
ajStrAssignC(&m1str,"pam");
else if(m1c=='g')
ajStrAssignC(&m1str,"gonnet");
else if(m1c=='i')
ajStrAssignC(&m1str,"id");
else if(m1c=='o')
ajStrAssignC(&m1str,"own");
dna_matrix = ajAcdGetListSingle( "dnamatrix");
m2c = ajStrGetCharFirst(dna_matrix);
if(m2c=='i')
ajStrAssignC(&m2str,"iub");
else if(m2c=='c')
ajStrAssignC(&m2str,"clustalw");
else if(m2c=='o')
ajStrAssignC(&m2str,"own");
ma_matrix = ajAcdGetInfile("mamatrixfile");
gapc = ajAcdGetFloat("gapopen");
gapv = ajAcdGetFloat("gapextend");
endgaps = ajAcdGetBoolean("endgaps");
norgap = ajAcdGetBoolean("norgap");
nohgap = ajAcdGetBoolean("nohgap");
gap_dist = ajAcdGetInt("gapdist");
hgapres = ajAcdGetString("hgapres");
maxdiv = ajAcdGetInt("maxdiv");
tmp = ajStrNewC("fasta");
/*
** Start by writing sequences into a unique temporary file
** get file pointer to unique file
*/
fil_file = ajSeqoutNew();
tmpFilename = emma_getUniqueFileName();
if(!ajSeqoutOpenFilename( fil_file, tmpFilename))
embExitBad();
/* Set output format to fasta */
ajSeqoutSetFormatS( fil_file, tmp);
while(ajSeqallNext(seqall, &seq))
{
/*
** Check sequences are all of the same type
** Still to be done
** Write out sequences
*/
if (!nb)
are_prot = ajSeqIsProt(seq);
ajSeqoutWriteSeq(fil_file, seq);
++nb;
}
ajSeqoutClose(fil_file);
if(nb < 2)
ajFatal("Multiple alignments need at least two sequences");
/* Generate clustalw command line */
cmd = ajStrNewS(ajAcdGetpathC("clustalw"));
/* add tmp file containing sequences */
ajStrAppendC(&cmd, " -infile=");
ajStrAppendS(&cmd, tmpFilename);
/* add out file name */
tmp_aln_outfile = emma_getUniqueFileName();
ajStrAppendC(&cmd, " -outfile=");
ajStrAppendS(&cmd, tmp_aln_outfile);
/* calculating just the nj tree or doing full alignment */
if(only_dend)
ajStrAppendC(&cmd, " -tree");
else
if(!use_dend)
ajStrAppendC(&cmd, " -align");
/* Set sequence type from information from acd file */
if(are_prot)
ajStrAppendC(&cmd, " -type=protein");
else
ajStrAppendC(&cmd, " -type=dna");
/*
** set output to MSF format - will read in this file later and output
** user requested format
*/
ajStrAppendC(&cmd, " -output=");
ajStrAppendC(&cmd, "gcg");
/* If going to do pairwise alignment */
if(!use_dend)
{
/* add fast pairwise alignments*/
if(!do_slow)
{
ajStrAppendC(&cmd, " -quicktree");
ajStrAppendC(&cmd, " -ktuple=");
ajStrFromInt(&tmp, ktup);
ajStrAppendS(&cmd, tmp);
ajStrAppendC(&cmd, " -window=");
ajStrFromInt(&tmp, window);
ajStrAppendS(&cmd, tmp);
if(nopercent)
ajStrAppendC(&cmd, " -score=percent");
else
ajStrAppendC(&cmd, " -score=absolute");
ajStrAppendC(&cmd, " -topdiags=");
ajStrFromInt(&tmp, topdiags);
ajStrAppendS(&cmd, tmp);
ajStrAppendC(&cmd, " -pairgap=");
ajStrFromInt(&tmp, gapw);
ajStrAppendS(&cmd, tmp);
}
else
{
if(pairwise_matrix)
{
if(are_prot)
ajStrAppendC(&cmd, " -pwmatrix=");
else
ajStrAppendC(&cmd, " -pwdnamatrix=");
ajStrAppendS(&cmd, ajFileGetPrintnameS(pairwise_matrix));
}
else
{
if(are_prot)
{
ajStrAppendC(&cmd, " -pwmatrix=");
ajStrAppendS(&cmd, pwmstr);
}
else
{
ajStrAppendC(&cmd, " -pwdnamatrix=");
ajStrAppendS(&cmd, pwdstr);
}
}
ajStrAppendC(&cmd, " -pwgapopen=");
ajStrFromFloat(&tmp, pw_gapc, 3);
ajStrAppendS(&cmd, tmp);
ajStrAppendC(&cmd, " -pwgapext=");
ajStrFromFloat(&tmp, pw_gapv, 3);
ajStrAppendS(&cmd, tmp);
}
}
/* Multiple alignments */
/* using existing tree or generating new tree? */
if(use_dend)
{
ajStrAppendC(&cmd, " -usetree=");
ajStrAppendS(&cmd, dend_filename);
}
else
{
/* use tmp file to hold dend file, will read back in later */
tmp_dendfilename = emma_getUniqueFileName();
ajStrAppendC(&cmd, " -newtree=");
ajStrAppendS(&cmd, tmp_dendfilename);
}
if(ma_matrix)
{
if(are_prot)
ajStrAppendC(&cmd, " -matrix=");
else
ajStrAppendC(&cmd, " -pwmatrix=");
ajStrAppendS(&cmd, ajFileGetPrintnameS(ma_matrix));
}
else
{
if(are_prot)
{
ajStrAppendC(&cmd, " -matrix=");
ajStrAppendS(&cmd, m1str);
}
else
{
ajStrAppendC(&cmd, " -dnamatrix=");
ajStrAppendS(&cmd, m2str);
}
}
ajStrAppendC(&cmd, " -gapopen=");
ajStrFromFloat(&tmp, gapc, 3);
ajStrAppendS(&cmd, tmp);
ajStrAppendC(&cmd, " -gapext=");
ajStrFromFloat(&tmp, gapv, 3);
ajStrAppendS(&cmd, tmp);
ajStrAppendC(&cmd, " -gapdist=");
ajStrFromInt(&tmp, gap_dist);
ajStrAppendS(&cmd, tmp);
ajStrAppendC(&cmd, " -hgapresidues=");
ajStrAppendS(&cmd, hgapres);
if(!endgaps)
ajStrAppendC(&cmd, " -endgaps");
if(norgap)
ajStrAppendC(&cmd, " -nopgap");
if(nohgap)
ajStrAppendC(&cmd, " -nohgap");
ajStrAppendC(&cmd, " -maxdiv=");
ajStrFromInt(&tmp, maxdiv);
ajStrAppendS(&cmd, tmp);
/* run clustalw */
/* ajFmtError("..%s..\n\n", ajStrGetPtr( cmd)); */
ajDebug("Executing '%S'\n", cmd);
ajSysExecS(cmd);
/* produce alignment file only if one was produced */
if(!only_dend)
{
/* read in tmp alignment output file to output through EMBOSS output */
seqin = ajSeqinNew();
/*
** add the Usa format to the start of the filename to tell EMBOSS
** format of file
*/
ajStrInsertC(&tmp_aln_outfile, 0, "msf::");
ajSeqinUsa(&seqin, tmp_aln_outfile);
seqset = ajSeqsetNew();
if(ajSeqsetRead(seqset, seqin))
{
ajSeqoutWriteSet(seqout, seqset);
ajSeqoutClose(seqout);
ajSeqinDel(&seqin);
/* remove the Usa from the start of the string */
ajStrCutStart(&tmp_aln_outfile, 5);
}
else
ajFmtError("Problem writing out EMBOSS alignment file\n");
}
/* read in new tmp dend file (if produced) to output through EMBOSS */
if(tmp_dendfilename!=NULL)
{
tmp_dendfile = ajFileNewInNameS( tmp_dendfilename);
if(tmp_dendfile!=NULL){
while(ajReadlineTrim(tmp_dendfile, &line))
ajFmtPrintF(dend_outfile, "%s\n", ajStrGetPtr( line));
ajFileClose(&tmp_dendfile);
ajSysFileUnlinkS(tmp_dendfilename);
}
}
ajSysFileUnlinkS(tmpFilename);
if(!only_dend)
ajSysFileUnlinkS(tmp_aln_outfile);
ajStrDel(&pw_matrix);
ajStrDel(&matrix);
ajStrDel(&pw_dna_matrix);
ajStrDel(&dna_matrix);
ajStrDel(&tmp_dendfilename);
ajStrDel(&dend_filename);
ajStrDel(&tmp_aln_outfile);
ajStrDel(&pwmstr);
ajStrDel(&pwdstr);
ajStrDel(&m1str);
ajStrDel(&m2str);
ajStrDel(&hgapres);
ajStrDel(&cmd);
ajStrDel(&tmp);
ajStrDel(&tmpFilename);
ajStrDel(&line);
ajFileClose(&dend_outfile);
ajFileClose(&tmp_dendfile);
ajFileClose(&dend_file);
ajFileClose(&pairwise_matrix);
ajFileClose(&ma_matrix);
ajSeqallDel(&seqall);
ajSeqsetDel(&seqset);
ajSeqDel(&seq);
ajSeqoutDel(&seqout);
ajSeqoutDel(&fil_file);
ajSeqinDel(&seqin);
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;
}
void embPatternRegexSearch (AjPFeattable ftable, const AjPSeq seq,
const AjPPatternRegex pat, AjBool reverse)
{
ajint pos=0;
ajint off;
ajint len;
AjPFeature sf = NULL;
AjPStr substr = NULL;
AjPStr seqstr = NULL;
AjPStr tmpstr = NULL;
AjPStr tmp = ajStrNew();
AjPRegexp patexp = ajPatternRegexGetCompiled(pat);
ajint adj;
AjBool isreversed;
AjPSeq revseq;
ajint seqlen;
seqlen = ajSeqGetLen(seq);
if(!seqlen)
return;
isreversed = ajSeqIsReversedTrue(seq);
if(isreversed)
seqlen += ajSeqGetOffset(seq);
pos = ajSeqGetBeginTrue(seq);
adj = ajSeqGetEndTrue(seq);
if(!ajStrGetLen(featMotifProt))
ajStrAssignC(&featMotifProt, "SO:0001067");
if(!ajStrGetLen(featMotifNuc))
ajStrAssignC(&featMotifNuc, "SO:0000714");
/*ajDebug("embPatternRegexSearch pos: %d adj: %d reverse: %B\n",
pos, adj, reverse, isreversed);*/
/*ajDebug("seqlen:%d len: %d offset: %d offend: %d begin: %d end: %d\n",
seqlen , ajSeqGetLen(seq), ajSeqGetOffset(seq),
ajSeqGetOffend(seq), ajSeqGetBegin(seq), ajSeqGetEnd(seq));*/
if (reverse)
{
revseq = ajSeqNewSeq(seq);
ajStrAssignSubS(&seqstr, ajSeqGetSeqS(revseq), pos-1, adj-1);
ajSeqstrReverse(&seqstr);
}
ajStrAssignSubS(&seqstr, ajSeqGetSeqS(seq), pos-1, adj-1);
ajStrFmtUpper(&seqstr);
while(ajStrGetLen(seqstr) && ajRegExec(patexp, seqstr))
{
off = ajRegOffset(patexp);
len = ajRegLenI(patexp, 0);
if(off || len)
{
ajRegSubI(patexp, 0, &substr);
ajRegPost(patexp, &tmp);
ajStrAssignS(&seqstr, substr);
ajStrAppendS(&seqstr, tmp);
pos += off;
/*ajDebug("match pos: %d adj: %d len: %d off:%d\n",
pos, adj, len, off);*/
if (reverse)
sf = ajFeatNew(ftable, NULL, featMotifNuc,
adj - pos - len + 2,
adj - pos + 1,
0.0, '-', 0);
else
{
if(ajSeqIsProt(seq) || ajFeattableIsProt(ftable))
sf = ajFeatNewProt(ftable, NULL, featMotifProt,
pos, pos + len - 1,
0.0);
else
sf = ajFeatNew(ftable, NULL, featMotifNuc,
pos, pos + len - 1,
0.0, '.', 0);
}
if(isreversed)
ajFeatReverse(sf, seqlen);
ajFmtPrintS (&tmpstr,"*pat %S: %S",
ajPatternRegexGetName(pat),
ajPatternRegexGetPattern(pat));
ajFeatTagAdd (sf,NULL,tmpstr);
pos += 1;
ajStrCutStart(&seqstr, 1);
}
else
{
pos++;
ajStrCutStart(&seqstr, 1);
}
}
ajStrDel(&tmpstr);
ajStrDel(&tmp);
ajStrDel(&substr);
ajStrDel(&seqstr);
if(reverse)
ajSeqDel(&revseq);
return;
}
int main(int argc, char **argv) {
embInitPV("kclustalw", argc, argv, "KBWS", "1.0.8");
struct soap soap;
struct ns1__clustalwInputParams params;
char* jobid;
char* result;
AjPSeqall seqall;
AjPSeq seq;
AjPFile outf;
AjPFile outf_dnd;
AjPStr substr;
AjPStr inseq = NULL;
AjPStr alignment;
AjPStr output;
AjPStr matrix;
AjPStr outorder;
ajint ktup;
ajint window;
ajint gapopen;
float gapext;
ajint gapdist;
AjBool endgaps;
ajint pairgap;
ajint topdiags;
AjPStr score;
AjBool tossgaps;
AjBool kimura;
AjPStr outputtree;
AjBool tree;
AjBool quicktree;
AjBool align;
AjPStr clustering;
ajint numiter;
AjPStr iteration;
alignment = ajAcdGetString("alignment");
output = ajAcdGetString("output");
matrix = ajAcdGetString("matrix");
outorder = ajAcdGetString("outorder");
ktup = ajAcdGetInt("ktup");
window = ajAcdGetInt("window");
gapopen = ajAcdGetInt("gapopen");
gapext = ajAcdGetFloat("gapext");
gapdist = ajAcdGetInt("gapdist");
endgaps = ajAcdGetBoolean("endgaps");
pairgap = ajAcdGetInt("pairgap");
topdiags = ajAcdGetInt("topdiags");
score = ajAcdGetString("score");
tossgaps = ajAcdGetBoolean("tossgaps");
kimura = ajAcdGetBoolean("kimura");
outputtree = ajAcdGetString("outputtree");
tree = ajAcdGetBoolean("tree");
quicktree = ajAcdGetBoolean("quicktree");
align = ajAcdGetBoolean("align");
clustering = ajAcdGetString("clustering");
numiter = ajAcdGetInt("numiter");
iteration = ajAcdGetString("iteration");
seqall = ajAcdGetSeqall("seqall");
outf = ajAcdGetOutfile("outfile");
outf_dnd = ajAcdGetOutfile("dndoutfile");
params.alignment = ajCharNewS(alignment);
params.output = ajCharNewS(output);
params.matrix = ajCharNewS(matrix);
params.outorder = ajCharNewS(outorder);
params.ktup = ktup;
params.window = window;
params.gapopen = gapopen;
params.gapext = gapext;
params.gapdist = gapdist;
if (endgaps) {
params.endgaps = xsd__boolean__true_;
} else {
params.endgaps = xsd__boolean__false_;
}
params.pairgap = pairgap;
params.topdiags = topdiags;
params.score = ajCharNewS(score);
if (tossgaps) {
params.tossgaps = xsd__boolean__true_;
} else {
params.tossgaps = xsd__boolean__false_;
}
if (kimura) {
params.kimura = xsd__boolean__true_;
} else {
params.kimura = xsd__boolean__false_;
}
params.outputtree = ajCharNewS(outputtree);
if (tree) {
params.tree = xsd__boolean__true_;
} else {
params.tree = xsd__boolean__false_;
}
if (quicktree) {
params.quicktree = xsd__boolean__true_;
} else {
params.quicktree = xsd__boolean__false_;
}
if (align) {
params.align = xsd__boolean__true_;
} else {
params.align = xsd__boolean__false_;
}
params.clustering = ajCharNewS(clustering);
params.numiter = numiter;
params.iteration = ajCharNewS(iteration);
AjPStr tmp = NULL;
AjPStr tmpFileName = NULL;
AjPSeqout fil_file;
AjPStr line = NULL; /* if "AjPStr line; -> ajReadline is not success!" */
AjPStr sizestr = NULL;
ajint thissize;
ajint nb = 0;
AjBool are_prot = ajFalse;
ajint size = 0;
AjPFile infile;
tmp = ajStrNewC("fasta");
fil_file = ajSeqoutNew();
tmpFileName = getUniqueFileName();
if( !ajSeqoutOpenFilename(fil_file, tmpFileName) ) {
embExitBad();
}
ajSeqoutSetFormatS(fil_file, tmp);
while (ajSeqallNext(seqall, &seq)) {
if (!nb) {
are_prot = ajSeqIsProt(seq);
}
ajSeqoutWriteSeq(fil_file, seq);
++nb;
}
ajSeqoutClose(fil_file);
ajSeqoutDel(&fil_file);
if (nb < 2) {
ajFatal("Multiple alignments need at least two sequences");
}
infile = ajFileNewInNameS(tmpFileName);
while (ajReadline(infile, &line)) {
ajStrAppendS(&inseq,line);
ajStrAppendC(&inseq,"\n");
}
soap_init(&soap);
char* in0;
in0 = ajCharNewS(inseq);
if ( soap_call_ns1__runClustalw( &soap, NULL, NULL, in0, ¶ms, &jobid ) == SOAP_OK ) {
fprintf(stderr,"Jobid: %s\n",jobid);
} else {
soap_print_fault(&soap, stderr);
}
int check = 0;
while ( check == 0 ) {
if ( soap_call_ns1__checkStatus( &soap, NULL, NULL, jobid, &check ) == SOAP_OK ) {
fprintf(stderr,"*");
} else {
soap_print_fault(&soap, stderr);
}
sleep(3);
}
fprintf(stderr,"\n");
char* type;
type = "out";
if(soap_call_ns1__getMultiResult( &soap, NULL, NULL, jobid, type, &result )== SOAP_OK) {
substr = ajStrNewC(result);
fprintf(stdout, "%s\n", ajStrGetPtr(substr));
} else {
soap_print_fault(&soap, stderr);
}
type = "aln";
if(soap_call_ns1__getMultiResult( &soap, NULL, NULL, jobid, type, &result )== SOAP_OK) {
substr = ajStrNewC(result);
ajFmtPrintF(outf,"%S\n",substr);
} else {
soap_print_fault(&soap, stderr);
}
type = "dnd";
if(soap_call_ns1__getMultiResult( &soap, NULL, NULL, jobid, type, &result )== SOAP_OK) {
substr = ajStrNewC(result);
ajFmtPrintF(outf_dnd,"%S\n",substr);
} else {
soap_print_fault(&soap, stderr);
}
ajSysFileUnlinkS(tmpFileName);
soap_destroy(&soap);
soap_end(&soap);
soap_done(&soap);
ajFileClose(&outf_dnd);
ajFileClose(&outf);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&substr);
embExit();
return 0;
}
