/* @func embPatternSeqCompile *************************************************
**
** Adds compiled pattern into AjPPattern.
**
** @param [w] pat [AjPPatternSeq] Pattern for compiling
** @return [AjBool] True, if compilation succeeded
** @@
******************************************************************************/
AjBool embPatternSeqCompile (AjPPatternSeq pat)
{
AjPPatComp embpat;
AjBool embType;
AjPStr pattern = NULL;
ajStrAssignS(&pattern,ajPatternSeqGetPattern(pat));
ajStrFmtUpper(&pattern);
ajDebug("embPatlistSeqCompile: name %S, pattern %S\n",
ajPatternSeqGetName(pat),pattern);
embpat = ajPatCompNew();
if (ajPatternSeqGetProtein(pat))
embType=ajTrue;
else
embType=ajFalse;
if (!embPatGetTypeII(embpat,pattern,
ajPatternSeqGetMismatch(pat),embType))
{
ajDebug("embPatlistSeqCompile: Illegal pattern %S: '%S'\n",
ajPatternSeqGetName(pat),ajPatternSeqGetPattern(pat));
ajPatCompDel(&embpat);
ajStrDel(&pattern);
return ajFalse;
}
embPatCompileII(embpat,ajPatternSeqGetMismatch(pat));
ajPatternSeqSetCompiled(pat,embpat);
ajStrDel(&pattern);
return ajTrue;
}
int main(int argc, char **argv)
{
/* Variable Declarations */
AjPFile outf;
AjPStr code = NULL;
char code1;
ajuint i;
ajuint iend;
/* ACD File Processing */
embInit("infobase", argc, argv);
code = ajAcdGetString("code");
outf = ajAcdGetOutfile("outfile");
/* Application logic */
ajStrFmtUpper(&code);
iend = ajStrGetLen(code);
ajFmtPrintF(outf, "%4s %-10s %-10s %s\n",
"Code", "Ambiguity", "Complement", "Mnemonic");
for(i=0;i<iend;i++)
{
code1=ajStrGetCharPos(code,i);
if(ajBaseExistsChar(code1))
{
ajFmtPrintF(outf, "%-4c %-10S %-10c %S\n",
code1, ajBaseGetCodes(code1),
ajBaseAlphacharComp(code1),
ajBaseGetMnemonic(code1));
}
else
{
ajFmtPrintF(outf, "%-4c %-10s %-10c %s\n",
code1, ".",
'.',
"invalid");
}
}
/* Memory management and exit */
ajStrDel(&code);
ajFileClose(&outf);
embExit();
return 0;
}
static AjBool dbiblast_parseId(const AjPStr line, AjPFile * alistfile,
AjBool systemsort, AjPStr const * fields,
ajint* maxFieldLen,
ajuint* countfield,
AjPStr* myid,
AjPList * myfdl)
{
static AjPRegexp idexp = NULL;
static AjBool reset = AJTRUE;
(void) alistfile;
(void) systemsort;
(void) maxFieldLen;
(void) countfield;
(void) myfdl;
if(!fields)
{
reset = ajTrue;
return ajFalse;
}
if(reset)
{
reset = ajFalse;
}
if(!idexp)
idexp = ajRegCompC("^([^ ]+)");
if(!ajRegExec(idexp, line))
return ajFalse;
ajRegSubI(idexp, 1, myid);
ajStrFmtUpper(myid);
ajDebug("parseId '%S'\n", *myid);
return ajTrue;
}
static AjBool dbifasta_ParseFasta(AjPFile libr, ajint* dpos,
ajint* maxFieldLen, ajuint* countfield,
AjPRegexp idexp,
ajuint usertype, AjPFile* alistfile,
AjBool systemsort, AjPStr const * fields)
{
char* fd;
ajlong ipos;
static AjPStr tstr = NULL;
static ajint numFields;
static ajint accfield = -1;
static ajint desfield = -1;
static ajint svnfield = -1;
static AjBool reset = AJTRUE;
ajuint type = usertype;
if(!fields)
{
reset = ajTrue;
accfield = svnfield = desfield = -1;
return ajFalse;
}
if(reset)
{
numFields = 0;
while(fields[numFields])
{
if(ajStrMatchCaseC(fields[numFields], "acc"))
accfield=numFields;
else if(ajStrMatchCaseC(fields[numFields], "sv"))
svnfield=numFields;
else if(ajStrMatchCaseC(fields[numFields], "des"))
desfield=numFields;
else
ajWarn("EMBL parsing unknown field '%S' ignored",
fields[numFields]);
numFields++;
}
reset = ajFalse;
}
if(!dbifastaGWrdexp)
dbifastaGWrdexp = ajRegCompC("([A-Za-z0-9]+)");
if(!tstr)
tstr = ajStrNew();
*dpos = (ajint) ajFileResetPos(libr); /* Lossy cast */
ajReadline(libr, &dbifastaGRline);
if(!ajStrGetLen(dbifastaGRline))
return ajFalse;
if(!ajRegExec(idexp,dbifastaGRline))
{
ajStrDelStatic(&dbifastaGTmpAc);
type = FASTATYPE_SIMPLE;
idexp = dbifastaGIdexp;
if(!ajRegExec(idexp, dbifastaGRline))
{
ajFatal("Unrecognised ID line format: %S", dbifastaGRline);
return ajFalse;
}
ajWarn("Invalid ID line for selected format: %S", dbifastaGRline);
}
/*
** each case needs to set id, tmpac, tmpsv, tmpdes
** using empty values if they are not found
*/
ajStrAssignC(&dbifastaGTmpSv, "");
ajStrAssignC(&dbifastaGTmpGi, "");
ajStrAssignC(&dbifastaGTmpDb, "");
ajStrAssignC(&dbifastaGTmpDes, "");
ajStrAssignC(&dbifastaGTmpAc, "");
ajStrAssignC(&dbifastaGTmpId, "");
switch(type)
{
case FASTATYPE_SIMPLE:
ajRegSubI(idexp,2,&dbifastaGTmpId);
ajStrAssignS(&dbifastaGTmpAc,dbifastaGTmpId);
ajRegPost(idexp, &dbifastaGTmpDes);
break;
case FASTATYPE_DBID:
ajRegSubI(idexp,1,&dbifastaGTmpId);
ajStrAssignS(&dbifastaGTmpAc,dbifastaGTmpId);
ajRegPost(idexp, &dbifastaGTmpDes);
break;
case FASTATYPE_GCGID:
ajRegSubI(idexp,1,&dbifastaGTmpId);
ajStrAssignS(&dbifastaGTmpAc,dbifastaGTmpId);
ajRegPost(idexp, &dbifastaGTmpDes);
break;
case FASTATYPE_NCBI:
if(!ajSeqParseNcbi(dbifastaGRline, &dbifastaGTmpId, &dbifastaGTmpAc,
&dbifastaGTmpSv, &dbifastaGTmpGi, &dbifastaGTmpDb,
&dbifastaGTmpDes))
{
ajStrDelStatic(&dbifastaGTmpAc);
return ajFalse;
}
break;
case FASTATYPE_GCGIDACC:
ajRegSubI(idexp,1,&dbifastaGTmpId);
ajRegSubI(idexp,2,&dbifastaGTmpAc);
ajRegPost(idexp, &dbifastaGTmpDes);
break;
case FASTATYPE_GCGACCID:
ajRegSubI(idexp,1,&dbifastaGTmpAc);
ajRegSubI(idexp,2,&dbifastaGTmpId);
ajRegPost(idexp, &dbifastaGTmpDes);
break;
case FASTATYPE_IDACC:
ajRegSubI(idexp,1,&dbifastaGTmpId);
ajRegSubI(idexp,2,&dbifastaGTmpAc);
ajRegPost(idexp, &dbifastaGTmpDes);
break;
case FASTATYPE_ACCID:
ajRegSubI(idexp,1,&dbifastaGTmpAc);
ajRegSubI(idexp,2,&dbifastaGTmpId);
ajRegPost(idexp, &dbifastaGTmpDes);
break;
default:
ajStrDelStatic(&dbifastaGTmpAc);
return ajFalse;
}
ajStrFmtUpper(&dbifastaGTmpId);
ajStrFmtUpper(&dbifastaGTmpAc);
if(accfield >= 0)
embDbiMaxlen(&dbifastaGTmpAc, &maxFieldLen[accfield]);
if(svnfield >= 0)
{
embDbiMaxlen(&dbifastaGTmpSv, &maxFieldLen[svnfield]);
embDbiMaxlen(&dbifastaGTmpGi, &maxFieldLen[svnfield]);
}
if(systemsort)
{
if(accfield >= 0 && ajStrGetLen(dbifastaGTmpAc))
{
countfield[accfield]++;
ajFmtPrintF(alistfile[accfield], "%S %S\n",
dbifastaGTmpId, dbifastaGTmpAc);
}
if(svnfield >= 0 && ajStrGetLen(dbifastaGTmpSv))
{
countfield[svnfield]++;
ajFmtPrintF(alistfile[svnfield], "%S %S\n",
dbifastaGTmpId, dbifastaGTmpSv);
}
if(svnfield >= 0 && ajStrGetLen(dbifastaGTmpGi))
{
countfield[svnfield]++;
ajFmtPrintF(alistfile[svnfield], "%S %S\n",
dbifastaGTmpId, dbifastaGTmpGi);
}
if(desfield >= 0 && ajStrGetLen(dbifastaGTmpDes))
while(ajRegExec(dbifastaGWrdexp, dbifastaGTmpDes))
{
ajRegSubI(dbifastaGWrdexp, 1, &dbifastaGTmpFd);
embDbiMaxlen(&dbifastaGTmpFd, &maxFieldLen[desfield]);
ajStrFmtUpper(&dbifastaGTmpFd);
ajDebug("++des '%S' tmpdes '%S\n",
dbifastaGTmpFd, dbifastaGTmpDes);
countfield[desfield]++;
ajFmtPrintF(alistfile[desfield], "%S %S\n",
dbifastaGTmpId, dbifastaGTmpFd);
ajRegPost(dbifastaGWrdexp, &dbifastaGTmpDes);
}
}
else
{
if(accfield >= 0 && ajStrGetLen(dbifastaGTmpAc))
{
fd = ajCharNewS(dbifastaGTmpAc);
ajListPushAppend(dbifastaGFdl[accfield],fd);
countfield[accfield]++;
}
if(svnfield >= 0 && ajStrGetLen(dbifastaGTmpSv))
{
fd = ajCharNewS(dbifastaGTmpSv);
ajListPushAppend(dbifastaGFdl[svnfield], fd);
countfield[svnfield]++;
}
if(svnfield >= 0 && ajStrGetLen(dbifastaGTmpGi))
{
fd = ajCharNewS(dbifastaGTmpGi);
ajListPushAppend(dbifastaGFdl[svnfield], fd);
countfield[svnfield]++;
}
if(desfield >= 0 && ajStrGetLen(dbifastaGTmpDes))
while(ajRegExec(dbifastaGWrdexp, dbifastaGTmpDes))
{
ajRegSubI(dbifastaGWrdexp, 1, &dbifastaGTmpFd);
embDbiMaxlen(&dbifastaGTmpFd, &maxFieldLen[desfield]);
ajStrFmtUpper(&dbifastaGTmpFd);
ajDebug("++des '%S' tmpdes: '%S'\n",
dbifastaGTmpFd, dbifastaGTmpDes);
fd = ajCharNewS(dbifastaGTmpFd);
ajListPushAppend(dbifastaGFdl[desfield], fd);
countfield[desfield]++;
ajRegPost(dbifastaGWrdexp, &dbifastaGTmpDes);
}
}
ipos = ajFileResetPos(libr);
while(ajReadline(libr, &dbifastaGRline))
{
if(ajStrGetCharFirst(dbifastaGRline) == '>')
{
ajFileSeek(libr, ipos, 0);
return ajTrue;
}
ipos = ajFileResetPos(libr);
}
ajFileSeek(libr, ipos, 0); /* end of file reached */
return ajTrue;
}
int main(int argc, char **argv)
{
/*
** All pointers set to NULL for safety.
** Variables names and initialisation values aligned for clarity.
*/
AjBool boo = ajFalse;
ajint n1 = 0;
ajint n2 = 0;
ajlong l1 = 0; /* long int */
float f1 = 0.0;
double d1 = 0.0; /* there is no long double */
size_t size = 100; /* Reserved memory size. Could be any value you know in advance. */
embInit("demostringnew", argc, argv);
demostringnew_msg("/* Starting string values */");
/* Functions with the prefix ajStr are for manipulating EMBOSS strings.
Functions with the prefix ajChar are for manipulating C-type (char*) string
See filesection and datasection sections in ajstr.c */
/*
** String constructor functions
** See "@section constructors" in ajstr.c
*/
/* Construct a new string with no starting value or reserved size.
There is no equivlent function for C-type (char*) strings */
str0 = ajStrNew ();
/* Construct a new string with a reserved size but no starting value */
txt1 = ajCharNewRes(size);
str1 = ajStrNewRes (size);
/* Construct a new C-type (char*) string with a starting value ... */
txt2 = ajCharNewC ("Starting value"); /* ... copied from a C-type (char*) string */
str2 = ajStrNewC (txt2); /* ... copied from a C-type (char*) string */
txt3 = ajCharNewS (str2); /* ... copied from a string */
str3 = ajStrNewS (str2); /* ... copied from a string */
/* Construct a new string with a reserved size and starting value ... */
txt4 = ajCharNewResC("Starting value, reserved size", size); /* ... copied from a C-type (char*) string)*/
str4 = ajStrNewResC (txt4, size); /* ... copied from a C-type (char*) string */
/* or str4 = ajStrNewResLenC(txt4, size, strlen(txt4)); to specify string length */
txt5 = ajCharNewResS(str4, size); /* ... copied from a string */
str5 = ajStrNewResS (str4, size); /* ... copied from a string */
demostringnew_msg("/* After string constructor functions */");
/*
** String destructor functions
** See "@section destructors" in ajstr.c)
*/
/* Destruct a string */
ajCharDel(&txt1);
ajCharDel(&txt2);
ajCharDel(&txt3);
ajCharDel(&txt4);
ajCharDel(&txt5);
ajStrDel (&str0);
ajStrDel (&str1);
ajStrDel (&str3);
ajStrDel (&str5);
/* str2 & str4 still in memory */
demostringnew_msg("/* After string destructor functions */");
/*
** String (de)referencing functions
** See "@section destructors" in ajstr.c)
*/
str0 = ajStrNewRef(str2);
/* or ajStrAssignRef(&str0, str2); */
demostringnew_msg("/* After string reference */");
ajStrDelStatic(&str0);
demostringnew_msg("/* After string dereference */");
/*
** String assignment functions
** See "@section assignment" in ajstr.c)
*/
/* Still only str2 & str4 in memory */
/* Assign a string value using ... */
ajStrAssignC(&str1, "Assigned value"); /* ... a C-type (char*) string */
/* or ajStrAssignLenC(&str1, "Assigned value", strlen("Assigned value")); to specify string length. */
ajStrAssignS(&str3, str1); /* ... a string */
ajStrAssignK(&str5, 'A'); /* ... a character */
demostringnew_msg("/* After string assignment 1 */");
ajStrAssignSubC(&str1, "Assigned value", 0, 11);
ajStrAssignSubS(&str3, str1, 0, 9);
demostringnew_msg("/* After string assignment 2 */");
/* The assignment functions allocate memory if necessary so str1, str3 and str5 will be created for you. It's bad practice to use this mechanism however because it's not obvious the string has been allocated (and needs freeing). Much cleaner to call the construct (ajStrNew) explicitly. */
/* Assign a string with a reserved size and value using ... */
ajStrAssignResC(&str1, size, "Assigned value, reserved size"); /* ... a C-type (char*) string */
ajStrAssignResS(&str3, size, str1); /* ... a string */
demostringnew_msg("/* After string assignment 3 */");
/* Assign a string value only if the string is empty using ... */
str0 = ajStrNew();
ajStrAssignEmptyC(&str0, "New value if string was empty"); /* ... a C-type (char*) string */
ajStrAssignEmptyS(&str1, str0); /* ... a string */
demostringnew_msg("/* After string assignment 4 */");
/* Now str0-5 in memory. The above code is for illustrative purposes: it's much cleaner to put all the constructors / destructors at the top / bottom of the code where possible. */
/* Assign all strings intuitive values */
txt0 = ajCharNewResC("TEXT 0", 100);
txt1 = ajCharNewResC("TEXT 1", 100);
txt2 = ajCharNewResC("Text 2", 100);
txt3 = ajCharNewResC("Text 3", 100);
txt4 = ajCharNewResC("Text 4", 100);
txt5 = ajCharNewResC("Text 5", 100);
ajStrAssignC(&str0, "STRING 0");
ajStrAssignC(&str1, "STRING 1");
ajStrAssignC(&str2, "String 2");
ajStrAssignC(&str3, "String 3");
ajStrAssignC(&str4, "String 4 WITHSOMETEXTINABLOCK");
ajStrAssignC(&str5, "String 5 WITHSOMETEXTINABLOCK");
demostringnew_msg("/* After string assignment 5 */");
/*
** String formatting functions
** See "@section formatting" in ajstr.c
*/
ajCharFmtLower(txt0);
ajCharFmtLower(txt1);
ajStrFmtLower(&str0);
ajStrFmtLowerSub(&str1, 0, 2);
ajCharFmtUpper(txt2);
ajCharFmtUpper(txt3);
ajStrFmtUpper(&str2);
ajStrFmtUpperSub(&str3, 0, 2);
demostringnew_msg("/* After string formatting 1 */");
ajStrFmtTitle(&str0);
ajStrFmtQuote(&str1);
ajStrFmtBlock(&str4, 3);
demostringnew_msg("/* After string formatting 2 */");
/* See also ajStrFmtWrap, ajStrFmtWrapLeft
... these need checking. */
/*
** String conversion functions
** See "@section datatype to string conversion" in ajstr.c
*/
n1 = n2 = l1 = 1;
f1 = d1 = 0.5;
ajStrFromBool( &str0, boo);
ajStrFromInt(&str1, n1);
ajStrFromLong(&str2, l1);
ajStrFromFloat(&str3, f1, 5);
ajStrFromDouble(&str4, d1, 5);
ajStrFromDoubleExp(&str5, d1, 5);
demostringnew_msg("/* After datatype to string conversion */");
/*
** String conversion functions
** See "@section string to datatype conversion" in ajstr.c
*/
ajStrToBool(str0, &boo);
ajStrToInt(str1, &n1);
ajStrToLong(str2, &l1);
ajStrToDouble(str4, &d1);
ajUser("/* After string to datatype conversion */\n"
"boo (from str0): %B\nn1 (from str1): %d\nl1 (from str2): %d",
boo, n1, l1);
ajFmtPrint("f1 (from str3): %f\nd1 (from str4): %f\n", f1, d1);
/* Check ajUser ... doesn't support %f */
/* See also ajStrToHex */
/* Assign all strings new values */
strcpy(txt0, "Text String");
strcpy(txt1, "TEXT STRING");
strcpy(txt2, "Text*");
strcpy(txt3, "Text");
strcpy(txt4, "Text String 4");
strcpy(txt5, "Text String 5");
ajStrAssignC(&str0, "String");
ajStrAssignC(&str1, "STRING");
ajStrAssignC(&str2, "String*");
ajStrAssignC(&str3, "*String");
ajStrAssignC(&str4, "String 4");
ajStrAssignC(&str5, "String 5");
demostringnew_msg("/* After resetting strings */");
/*
** String comparison functions
** See "@section comparison" in ajstr.c
*/
ajUserDumpC("/* String comparison functions */");
boo = ajCharMatchC(txt0, txt1);
ajUser("ajCharMatchC(txt0 txt1); == %B", boo);
boo = ajCharMatchCaseC(txt0, txt1);
ajUser("ajCharMatchCaseC(txt0 txt1); == %B", boo);
boo = ajCharMatchC(txt0, txt2);
ajUser("ajCharMatchC(txt0,txt2); == %B", boo);
boo = ajCharMatchWildC(txt0, txt2);
ajUser("ajCharMatchWildC(txt0,txt2); == %B", boo);
boo = ajCharMatchWildS(txt0, str2);
ajUser("ajCharMatchWildS(txt0,str2); == %B", boo);
/* See also ajCharMatchWildNextC, ajCharMatchWildWordC
... these need checking & documentation updated. */
boo = ajCharPrefixC(txt0, txt3);
ajUser("ajCharPrefixC(txt0, txt3); == %B", boo);
boo = ajCharPrefixS(txt0, str0);
ajUser("ajCharPrefixS(txt0, str0); == %B", boo);
boo = ajCharPrefixCaseC(txt5, txt1);
ajUser("ajCharPrefixCaseC(txt5, txt1); == %B", boo);
boo = ajCharPrefixCaseC(txt1, txt5);
ajUser("ajCharPrefixCaseC(txt1, txt5); == %B", boo);
boo = ajCharPrefixCaseS(txt0, str0);
ajUser("ajCharPrefixCaseS(txt0, str0); == %B", boo);
boo = ajCharSuffixC(txt0, txt3);
ajUser("ajCharSuffixC(txt0, txt3); === %B", boo);
boo = ajCharSuffixS(txt0, str0);
ajUser("ajCharSuffixS(txt0, str0); == %B", boo);
/* See also ajCharSuffixCaseC, ajCharSuffixCaseC, ajCharSuffixCaseS, ajCharSuffixCaseS
... these need checking. */
boo = ajStrMatchC (str0, txt0);
ajUser("ajStrMatchC (str0, txt0); == %B", boo);
boo = ajStrMatchS(str0, str1);
ajUser("ajStrMatchS(str0, str1); == %B", boo);
boo = ajStrMatchCaseC(str0, txt0);
ajUser("ajStrMatchCaseC(str0, txt0); == %B", boo);
boo = ajStrMatchCaseS(str0, str0);
ajUser("ajStrMatchCaseS(str0, str0); == %B", boo);
/*
ajUser("== %B", boo);
boo = ajStrMatchWildC(str2, const char* text);
ajStrMatchWildS (const AjPStr thys, const AjPStr wild);
ajStrMatchWildWordC (const AjPStr str, const char* text);
ajStrMatchWildWordS (const AjPStr str, const AjPStr text);
ajStrPrefixC(const AjPStr str, const char* txt2);
ajStrPrefixS(const AjPStr str, const AjPStr str2);
ajStrPrefixCaseC (const AjPStr str, const char* pref);
ajStrPrefixCaseS (const AjPStr str, const AjPStr pref);
ajStrSuffixC (const AjPStr thys, const char* suff);
ajStrSuffixS (const AjPStr thys, const AjPStr suff);
*/
/**************************************************************************/
/* String substitution functions (See "@section substitution" in ajstr.c) */
/**************************************************************************/
/*
AjBool ajStrExchangeCC(AjPStr* Pstr, const char* txt, const char* txtnew);
AjBool ajStrExchangeCS(AjPStr* Pstr, const char* txt,
const AjPStr strnew);
AjBool ajStrExchangeKK(AjPStr* Pstr, char chr, char chrnew);
AjBool ajStrExchangeSC(AjPStr* Pstr, const AjPStr str,
const char* txtnew);
AjBool ajStrExchangeSS(AjPStr* Pstr, const AjPStr str,
const AjPStr strnew);
AjBool ajStrExchangeSetCC(AjPStr* Pstr, const char* oldc,
const char* newc);
AjBool ajStrExchangeSetSS(AjPStr* Pstr, const AjPStr str,
const AjPStr strnew);
AjBool ajStrRandom(AjPStr *s);
AjBool ajStrReverse(AjPStr* Pstr);
*/
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPSeqall seqall;
AjPSeq seq = NULL;
AjPReport report = NULL;
AjPStr jaspdir = NULL;
AjPStr menu = NULL;
AjPStr substr = NULL;
AjPStr mats = NULL;
AjPStr excl = NULL;
float thresh = 0.;
ajuint recurs = 0;
AjPStr dir = NULL;
AjPStr mfname = NULL;
AjPList flist = NULL;
AjPList hits = NULL;
AjPStr head = NULL;
ajint begin;
ajint end;
ajuint mno;
char cp;
ajuint i;
AjPTable mattab = NULL;
AjPFeattable TabRpt = NULL;
AjBool both = ajFalse;
embInit("jaspscan", argc, argv);
seqall = ajAcdGetSeqall("sequence");
menu = ajAcdGetListSingle("menu");
mats = ajAcdGetString("matrices");
excl = ajAcdGetString("exclude");
thresh = ajAcdGetFloat("threshold");
report = ajAcdGetReport("outfile");
both = ajAcdGetBoolean("both");
jaspdir = ajStrNew();
substr = ajStrNew();
flist = ajListNew();
hits = ajListNew();
dir = ajStrNew();
head = ajStrNew();
cp = ajStrGetCharFirst(menu);
if(cp=='C')
ajStrAssignC(&jaspdir,J_COR);
else if(cp=='F')
ajStrAssignC(&jaspdir,J_FAM);
else if(cp=='P')
ajStrAssignC(&jaspdir,J_PHY);
else if(cp=='N')
ajStrAssignC(&jaspdir,J_CNE);
else if(cp=='O')
ajStrAssignC(&jaspdir,J_POL);
else if(cp=='S')
ajStrAssignC(&jaspdir,J_SPL);
else
ajFatal("Invalid JASPAR database selection");
ajStrAssignS(&dir, ajDatafileValuePath());
if(!ajStrGetLen(dir))
ajFatal("EMBOSS DATA directory couldn't be determined");
jaspscan_ParseInput(dir, jaspdir, mats, excl, &recurs, flist);
mno = ajListGetLength(flist);
if(cp == 'C')
mattab = jaspscan_ReadCoreList(jaspdir);
if(cp == 'F')
mattab = jaspscan_ReadFamList(jaspdir);
if(cp == 'P')
mattab = jaspscan_ReadCoreList(jaspdir);
if(cp == 'N')
mattab = jaspscan_ReadCoreList(jaspdir);
if(cp == 'O')
mattab = jaspscan_ReadCoreList(jaspdir);
if(cp == 'S')
mattab = jaspscan_ReadCoreList(jaspdir);
ajFmtPrintS(&head,"Database scanned: %S Threshold: %.3f",jaspdir,thresh);
ajReportSetHeaderS(report,head);
while(ajSeqallNext(seqall, &seq))
{
begin = ajSeqallGetseqBegin(seqall);
end = ajSeqallGetseqEnd(seqall);
ajStrAssignSubC(&substr,ajSeqGetSeqC(seq),begin-1,end-1);
ajStrFmtUpper(&substr);
TabRpt = ajFeattableNewSeq(seq);
for(i=0; i < mno; ++i)
{
ajListPop(flist,(void **)&mfname);
jaspscan_scan(substr,begin,mfname, cp, thresh, both, hits);
ajListPushAppend(flist, (void **)mfname);
}
jaspscan_ReportHits(TabRpt,mattab,hits);
ajReportWrite(report, TabRpt, seq);
ajFeattableDel(&TabRpt);
}
while(ajListPop(flist,(void **)&mfname))
ajStrDel(&mfname);
ajStrDel(&dir);
ajStrDel(&menu);
ajStrDel(&excl);
ajStrDel(&substr);
ajStrDel(&mats);
ajStrDel(&head);
ajStrDel(&jaspdir);
ajSeqDel(&seq);
ajTableMapDel(mattab,jaspscan_ClearTable,NULL);
ajTableFree(&mattab);
ajListFree(&flist);
ajListFree(&hits);
ajSeqallDel(&seqall);
ajReportDel(&report);
embExit();
return 0;
}
EmbPPropMolwt* embPropEmolwtRead(AjPFile mfptr)
{
AjPStr line = NULL;
AjPStr token = NULL;
AjBool firstline;
const char *p;
ajuint i;
ajint n;
EmbPPropMolwt *ret;
line = ajStrNew();
token = ajStrNew();
firstline = ajTrue;
AJCNEW0(ret,EMBPROPSIZE+2);
for(i=0; i < EMBPROPSIZE+2; ++i)
AJNEW0(ret[i]);
while(ajReadline(mfptr, &line))
{
ajStrRemoveWhiteExcess(&line);
p = ajStrGetPtr(line);
if(*p=='#' || *p=='!' || !*p)
continue;
if(firstline)
{
if(!ajStrPrefixC(line,"Mol"))
ajFatal("Incorrect format molwt file: '%S'", line);
firstline = ajFalse;
continue;
}
ajFmtScanS(line,"%S",&token);
ajStrFmtUpper(&token);
if(ajStrGetLen(token) != 1)
{
if(ajStrPrefixC(token,"HYDROGEN"))
{
if(ajFmtScanS(line,"%*s%lf%lf",
&ret[EMBPROPHINDEX]->average,
&ret[EMBPROPHINDEX]->mono) != 2)
ajFatal("Bad format hydrogen data line");
}
else if(ajStrPrefixC(token,"OXYGEN"))
{
if(ajFmtScanS(line,"%*s%lf%lf",
&ret[EMBPROPOINDEX]->average,
&ret[EMBPROPOINDEX]->mono) != 2)
ajFatal("Bad format oxygen data line");
}
else if(ajStrPrefixC(token,"WATER"))
{
if(ajFmtScanS(line,"%*s%lf%lf",
&ret[EMBPROPWINDEX]->average,
&ret[EMBPROPWINDEX]->mono) != 2)
ajFatal("Bad format water data line");
}
else
ajFatal("Unknown molwt token %S",token);
continue;
}
i = ajBasecodeToInt((ajint) *ajStrGetPtr(token));
if(i == 27)
ajFatal("Molwt file line doesn't begin with a single A->Z (%S)",
line);
n = ajFmtScanS(line,"%*s%lf%lf",
&ret[i]->average,
&ret[i]->mono);
if(n != 2)
ajFatal("Only %d columns in amino file - expected %d",n,3);
}
ajStrDel(&line);
ajStrDel(&token);
return ret;
}
static AjBool dbiblast_parseSimple(const AjPStr line,
AjPFile * alistfile,
AjBool systemsort, AjPStr const * fields,
ajint* maxFieldLen,
ajuint* countfield,
AjPStr* myid,
AjPList* myfdl)
{
static AjPRegexp idexp = NULL;
static AjPStr mytmpac = NULL;
char* ac;
static ajint numFields;
static ajint accfield = -1;
static AjBool reset = AJTRUE;
if(!fields)
{
reset = ajTrue;
accfield = -1;
return ajFalse;
}
if(reset)
{
numFields = 0;
while(fields[numFields])
{
if(ajStrMatchCaseC(fields[numFields], "acc"))
accfield=numFields;
else if(!ajStrMatchCaseC(fields[numFields], "sv") &&
!ajStrMatchCaseC(fields[numFields], "des"))
ajWarn("Simple ID parsing unknown field '%S' ignored",
fields[numFields]);
numFields++;
}
reset = ajFalse;
}
if(!idexp)
idexp = ajRegCompC("^([^ ]+)( +([A-Za-z][A-Za-z0-9]+[0-9]))");
if(!ajRegExec(idexp, line))
return ajFalse;
ajRegSubI(idexp, 1, myid);
ajRegSubI(idexp, 3, &mytmpac);
ajStrFmtUpper(myid);
ajStrFmtUpper(&mytmpac); /* GCG mixes case on new SwissProt acnums */
if(accfield >= 0)
{
embDbiMaxlen(&mytmpac, &maxFieldLen[accfield]);
countfield[accfield]++;
if(systemsort)
ajFmtPrintF(alistfile[accfield], "%S %S\n", *myid, mytmpac);
else
{
ac = ajCharNewS(mytmpac);
ajListPushAppend(myfdl[accfield], ac);
}
}
ajDebug("parseSimple '%S' '%S'\n", *myid, mytmpac);
return ajTrue;
}
int main(int argc, char **argv)
{
AjPSeqall seqall;
AjPSeq seq = NULL;
AjPStr seqcmp = NULL;
AjPStr enzymes = NULL;
AjPFile outf = NULL;
ajint begin;
ajint end;
ajint min;
ajint max;
ajint sitelen;
AjBool alpha;
AjBool single;
AjBool blunt;
AjBool ambiguity;
AjBool sticky;
AjBool plasmid;
AjBool threeprime;
AjBool commercial;
AjBool html;
AjBool limit;
AjBool frags;
AjBool methyl;
AjPFile dfile;
AjPFile enzfile = NULL;
AjPFile equfile = NULL;
AjPFile methfile = NULL;
AjPStr name = NULL;
AjPTable table = NULL;
ajint hits;
AjPList l = NULL;
embInit("restover", argc, argv);
seqall = ajAcdGetSeqall("sequence");
seqcmp = ajAcdGetString("seqcomp");
ajStrFmtUpper(&seqcmp);
outf = ajAcdGetOutfile("outfile");
/*
** Some of these are not needed but I left them in case someone wants to
** use them some time ...
*/
enzymes = ajStrNewC("all");
min = ajAcdGetInt("min");
max = ajAcdGetInt("max");
sitelen = 2;
threeprime = ajAcdGetBoolean("threeprime");
blunt = ajAcdGetBoolean("blunt");
sticky = ajAcdGetBoolean("sticky");
single = ajAcdGetBoolean("single");
html = ajAcdGetBoolean("html");
alpha = ajAcdGetBoolean("alphabetic");
ambiguity = ajAcdGetBoolean("ambiguity");
plasmid = ajAcdGetBoolean("plasmid");
commercial = ajAcdGetBoolean("commercial");
limit = ajAcdGetBoolean("limit");
frags = ajAcdGetBoolean("fragments");
methyl = ajAcdGetBoolean("methylation");
dfile = ajAcdGetDatafile("datafile");
methfile = ajAcdGetDatafile("mfile");
if(single)
max = min = 1;
table = ajTablestrNew(EQUGUESS);
l = ajListNew();
if(threeprime)
ajStrReverse(&seqcmp);
/* read the local file of enzymes names */
restover_read_file_of_enzyme_names(&enzymes);
if(!dfile)
{
enzfile = ajDatafileNewInNameC(ENZDATA);
if(!enzfile)
ajFatal("Cannot locate enzyme file. Run REBASEEXTRACT");
}
else
{
enzfile = dfile;
}
if(limit)
{
equfile = ajDatafileNewInNameC(EQUDATA);
if(!equfile)
limit=ajFalse;
else
{
restover_read_equiv(equfile,table);
ajFileClose(&equfile);
}
}
while(ajSeqallNext(seqall, &seq))
{
begin = ajSeqallGetseqBegin(seqall);
end = ajSeqallGetseqEnd(seqall);
ajFileSeek(enzfile,0L,0);
ajSeqFmtUpper(seq);
hits = embPatRestrictMatch(seq,begin,end,enzfile,methfile,enzymes,
sitelen,plasmid,ambiguity,min,max,blunt,
sticky,commercial,methyl,l);
ajDebug("hits:%d listlen:%u\n", hits, ajListGetLength(l));
if(hits)
{
name = ajStrNewC(ajSeqGetNameC(seq));
restover_printHits(seq, seqcmp, outf,l,name,hits,begin,end,
min,max,plasmid,
sitelen,limit,table,alpha,frags,
html);
ajStrDel(&name);
}
ajListFree(&l);
}
ajListFree(&l);
ajSeqDel(&seq);
ajFileClose(&outf);
ajFileClose(&dfile);
ajFileClose(&enzfile);
ajFileClose(&equfile);
ajFileClose(&methfile);
ajSeqallDel(&seqall);
ajStrDel(&seqcmp);
ajStrDel(&enzymes);
ajStrDel(&name);
ajTablestrFree(&table);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPSeqall seqall;
AjPFile primfile;
AjPStr rdline = NULL;
Primer primdata;
AjPStrTok handle = NULL;
AjPList primList = NULL;
embInit("stssearch", argc, argv);
primfile = ajAcdGetInfile("infile");
out = ajAcdGetOutfile("outfile");
seqall = ajAcdGetSeqall("seqall");
while(ajReadlineTrim(primfile, &rdline))
{
if(ajStrGetCharFirst(rdline) == '#')
continue;
if(ajStrSuffixC(rdline, ".."))
continue;
AJNEW(primdata);
primdata->Name = NULL;
primdata->Oligoa = NULL;
primdata->Oligob = NULL;
handle = ajStrTokenNewC(rdline, " \t");
ajStrTokenNextParse(&handle, &primdata->Name);
if(!(nprimers % 1000))
ajDebug("Name [%d]: '%S'\n", nprimers, primdata->Name);
ajStrTokenNextParse(&handle, &primdata->Oligoa);
ajStrFmtUpper(&primdata->Oligoa);
primdata->Prima = ajRegComp(primdata->Oligoa);
ajStrTokenNextParse(&handle, &primdata->Oligob);
ajStrFmtUpper(&primdata->Oligob);
primdata->Primb = ajRegComp(primdata->Oligob);
ajStrTokenDel(&handle);
if(!nprimers)
primList = ajListNew();
ajListPushAppend(primList, primdata);
nprimers++;
}
if(!nprimers)
ajFatal("No primers read\n");
ajDebug("%d primers read\n", nprimers);
while(ajSeqallNext(seqall, &seq))
{
ajSeqFmtUpper(seq);
ajStrAssignS(&seqstr, ajSeqGetSeqS(seq));
ajStrAssignS(&revstr, ajSeqGetSeqS(seq));
ajSeqstrReverse(&revstr);
ajDebug("Testing: %s\n", ajSeqGetNameC(seq));
ntests = 0;
ajListMap(primList, stssearch_primTest, NULL);
}
ajFileClose(&out);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajFileClose(&out);
ajStrDel(&revstr);
ajStrDel(&seqstr);
ajFileClose(&primfile);
ajListMap(primList, stssearch_primDel, NULL);
ajListFree(&primList);
ajStrDel(&rdline);
embExit();
return 0;
}
static void primersearch_scan_seq(const Primer primdata,
const AjPSeq seq, AjBool reverse)
{
AjPStr seqstr = NULL;
AjPStr revstr = NULL;
AjPStr seqname = NULL;
ajuint fhits = 0;
ajuint rhits = 0;
AjPList fhits_list = NULL;
AjPList rhits_list = NULL;
/* initialise variables for search */
ajStrAssignC(&seqname,ajSeqGetNameC(seq));
ajStrAssignS(&seqstr, ajSeqGetSeqS(seq));
ajStrAssignS(&revstr, ajSeqGetSeqS(seq));
ajStrFmtUpper(&seqstr);
ajStrFmtUpper(&revstr);
ajSeqstrReverse(&revstr);
fhits_list = ajListNew();
rhits_list = ajListNew();
if(!reverse)
{
/* test OligoA against forward sequence, and OligoB against reverse */
embPatFuzzSearch(primdata->forward->type,
ajSeqGetBegin(seq),
primdata->forward->patstr,
seqname,
seqstr,
fhits_list,
primdata->forward->len,
primdata->forward->mm,
primdata->forward->amino,
primdata->forward->carboxyl,
primdata->forward->buf,
primdata->forward->off,
primdata->forward->sotable,
primdata->forward->solimit,
primdata->forward->re,
primdata->forward->skipm,
&fhits,
primdata->forward->real_len,
&(primdata->forward->tidy));
if(fhits)
embPatFuzzSearch(primdata->reverse->type,
ajSeqGetBegin(seq),
primdata->reverse->patstr,
seqname,
revstr,
rhits_list,
primdata->reverse->len,
primdata->reverse->mm,
primdata->reverse->amino,
primdata->reverse->carboxyl,
primdata->reverse->buf,
primdata->reverse->off,
primdata->reverse->sotable,
primdata->reverse->solimit,
primdata->reverse->re,
primdata->reverse->skipm,
&rhits,
primdata->reverse->real_len,
&(primdata->reverse->tidy));
}
else
{
/*test OligoB against forward sequence, and OligoA against reverse */
embPatFuzzSearch(primdata->reverse->type,
ajSeqGetBegin(seq),
primdata->reverse->patstr,
seqname,
seqstr,
fhits_list,
primdata->reverse->len,
primdata->reverse->mm,
primdata->reverse->amino,
primdata->reverse->carboxyl,
primdata->reverse->buf,
primdata->reverse->off,
primdata->reverse->sotable,
primdata->reverse->solimit,
primdata->reverse->re,
primdata->reverse->skipm,
&fhits,
primdata->reverse->real_len,
&(primdata->reverse->tidy));
if(fhits)
embPatFuzzSearch(primdata->forward->type,
ajSeqGetBegin(seq),
primdata->forward->patstr,
seqname,
revstr,
rhits_list,
primdata->forward->len,
primdata->forward->mm,
primdata->forward->amino,
primdata->forward->carboxyl,
primdata->forward->buf,
primdata->forward->off,
primdata->forward->sotable,
primdata->forward->solimit,
primdata->forward->re,
primdata->forward->skipm,
&rhits,
primdata->forward->real_len,
&(primdata->forward->tidy));
}
if(fhits && rhits)
/* get amplimer length(s) and write out the hit */
primersearch_store_hits(primdata, fhits_list, rhits_list,
seq, reverse);
/* tidy up */
primersearch_clean_hitlist(&fhits_list);
primersearch_clean_hitlist(&rhits_list);
ajStrDel(&seqstr);
ajStrDel(&revstr);
ajStrDel(&seqname);
return;
}
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;
}
static AjPList silent_mismatch(const AjPStr sstr, AjPList relist,
AjPStr* tailstr,
const AjPStr sname, ajint RStotal, ajint begin,
ajint radj,AjBool rev, ajint end,
AjBool tshow)
{
PSilent res;
AjPList results;
AjPStr str; /*holds RS patterns*/
AjPStr tstr;
AjBool dummy = ajFalse; /*need a bool for ajPatClassify*/
ajint mm; /*number of mismatches*/
ajint hits; /*number of pattern matches found*/
ajint i;
ajint aw;
ajint start;
AjPList patlist = NULL; /*a list for pattern matches.
a list of ..*/
EmbPMatMatch match; /*..AjMatMatch structures*/
PRinfo rlp = NULL;
AjPStr pep = NULL; /*string to hold protein*/
AjPTrn table = NULL; /*object to hold translation table*/
str = ajStrNew();
tstr = ajStrNew();
pep = ajStrNew();
table = ajTrnNewI(0); /*0 stands for standard DNA-
see fuzztran.acd*/
results = ajListNew();
start = 1;
if(!rev) /* forward strand */
{
ajTrnSeqFrameS(table,sstr,1,&pep); /*1 stands for frame number*/
if(tshow)
{
silent_fmt_sequence("TRANSLATED SEQUENCE",
pep,tailstr,start,ajFalse);
}
}
else /* reverse strand */
{
ajStrAssignC(&tstr,ajStrGetPtr(sstr)+(end-begin+1)%3);
ajTrnSeqFrameS(table,tstr,1,&pep);
if(tshow)
{
silent_fmt_sequence("REVERSE TRANSLATED SEQUENCE",
pep,tailstr,start,ajFalse);
}
}
for(aw=0;aw<RStotal;aw++) /* loop to read in restriction
enzyme patterns */
{
/* Pop off the first RE */
ajListPop(relist,(void **)&rlp);
/* ignore unknown cut sites and zero cutters */
if(*ajStrGetPtr(rlp->site)=='?'||!rlp->ncuts)
{
ajListPushAppend(relist,(void*)rlp);
continue;
}
ajStrFmtUpper(&rlp->site); /* convert all RS to upper case */
ajStrAssignS(&str,rlp->site); /* str now holds RS patterns */
patlist = ajListNew();
if(!embPatClassify(str,&str,
&dummy,&dummy,&dummy,&dummy,&dummy,&dummy,0))
continue;
mm = 0;
hits=embPatBruteForce(sstr,str,ajFalse,ajFalse,patlist,begin+1,mm,
sname);
if(hits)
while(ajListPop(patlist,(void**)&match))
embMatMatchDel(&match);
else
{
mm = 1;
hits = embPatBruteForce(sstr,str,ajFalse,ajFalse,patlist,
begin+1,mm,sname);
if(hits)
for(i=0;i<hits;++i)
{
ajListPop(patlist,(void**)&match);
res = silent_checktrans(sstr,match,rlp,begin,radj,
rev,end);
if (res)
ajListPushAppend(results,(void *)res);
embMatMatchDel(&match);
}
}
ajListPushAppend(relist,(void *)rlp);
ajListFree(&patlist);
}
ajStrDel(&str);
ajStrDel(&tstr);
ajStrDel(&pep);
ajTrnDel(&table);
return (results);
}
EmbPPropAmino* embPropEaminoRead(AjPFile mfptr)
{
AjPStr line = NULL;
AjPStr token = NULL;
AjBool firstline;
const char *p;
ajuint i;
ajint n;
EmbPPropAmino *ret;
line = ajStrNew();
token = ajStrNew();
firstline = ajTrue;
AJCNEW0(ret,EMBPROPSIZE);
for(i=0; i < EMBPROPSIZE; ++i)
AJNEW0(ret[i]);
while(ajReadline(mfptr, &line))
{
ajStrRemoveWhiteExcess(&line);
p = ajStrGetPtr(line);
if(*p=='#' || *p=='!' || !*p)
continue;
if(firstline)
{
if(!ajStrPrefixC(line,"aa"))
ajFatal("Incorrect (old?) format amino data file");
firstline = ajFalse;
continue;
}
ajFmtScanS(line,"%S",&token);
ajStrFmtUpper(&token);
if(ajStrGetLen(token) != 1)
ajFatal("Amino file line doesn't begin with a single character");
i = ajBasecodeToInt((ajint) *ajStrGetPtr(token));
if(i == 27)
ajFatal("Amino file line doesn't begin with a single A->Z (%S)",
line);
n = ajFmtScanS(line,"%*s%d%d%d%d%d%d%f%d%d%d",
&ret[i]->tiny,
&ret[i]->sm_all,
&ret[i]->aliphatic,
&ret[i]->aromatic,
&ret[i]->nonpolar,
&ret[i]->polar,
&ret[i]->charge,
&ret[i]->pve,
&ret[i]->nve,
&ret[i]->extcoeff);
if(n!= 10)
ajFatal("Only %d columns in amino file - expected %d",n+1,11);
}
ajStrDel(&line);
ajStrDel(&token);
return ret;
}
int main(int argc, char **argv)
{
AjPFile outf = NULL;
AjPSeq sequence = NULL;
AjPStr substr = NULL;
AjPStr seqstr = NULL;
AjPStr revstr = NULL;
AjPStr p1;
AjPStr p2;
PPrimer eric = NULL;
PPrimer fred = NULL;
PPrimer f;
PPrimer r;
PPair pair;
AjPList forlist = NULL;
AjPList revlist = NULL;
AjPList pairlist = NULL;
AjBool targetrange;
AjBool isDNA = ajTrue;
AjBool dolist = ajFalse;
ajint primerlen = 0;
ajint minprimerlen = 0;
ajint maxprimerlen = 0;
ajint minprodlen = 0;
ajint maxprodlen = 0;
ajint prodlen = 0;
ajint seqlen = 0;
ajint stepping_value = 1;
ajint targetstart = 0;
ajint targetend = 0;
ajint limit = 0;
ajint limit2 = 0;
ajint lastpos = 0;
ajint startpos = 0;
ajint endpos = 0;
ajint begin;
ajint end;
ajint v1;
ajint v2;
ajint overlap;
float minpmGCcont = 0.;
float maxpmGCcont = 0.;
float minprodGCcont = 0.;
float maxprodGCcont = 0.;
float prodTm;
float prodGC;
ajint i;
ajint j;
ajint neric=0;
ajint nfred=0;
ajint npair=0;
float minprimerTm = 0.0;
float maxprimerTm = 0.0;
float saltconc = 0.0;
float dnaconc = 0.0;
embInit ("prima", argc, argv);
substr = ajStrNew();
forlist = ajListNew();
revlist = ajListNew();
pairlist = ajListNew();
p1 = ajStrNew();
p2 = ajStrNew();
sequence = ajAcdGetSeq("sequence");
outf = ajAcdGetOutfile("outfile");
minprimerlen = ajAcdGetInt("minprimerlen");
maxprimerlen = ajAcdGetInt("maxprimerlen");
minpmGCcont = ajAcdGetFloat("minpmGCcont");
maxpmGCcont = ajAcdGetFloat("maxpmGCcont");
minprimerTm = ajAcdGetFloat("mintmprimer");
maxprimerTm = ajAcdGetFloat("maxtmprimer");
minprodlen = ajAcdGetInt("minplen");
maxprodlen = ajAcdGetInt("maxplen");
minprodGCcont = ajAcdGetFloat("minpgccont");
maxprodGCcont = ajAcdGetFloat("maxpgccont");
saltconc = ajAcdGetFloat("saltconc");
dnaconc = ajAcdGetFloat("dnaconc");
targetrange = ajAcdGetToggle("targetrange");
targetstart = ajAcdGetInt("targetstart");
targetend = ajAcdGetInt("targetend");
overlap = ajAcdGetInt("overlap");
dolist = ajAcdGetBoolean("list");
seqstr = ajSeqGetSeqCopyS(sequence);
ajStrFmtUpper(&seqstr);
begin = ajSeqGetBegin(sequence);
end = ajSeqGetEnd(sequence);
seqlen = end-begin+1;
ajStrAssignSubC(&substr,ajStrGetPtr(seqstr),begin-1,end-1);
revstr = ajStrNewC(ajStrGetPtr(substr));
ajSeqstrReverse(&revstr);
AJCNEW0(entropy, seqlen);
AJCNEW0(enthalpy, seqlen);
AJCNEW0(energy, seqlen);
/* Initialise Tm calculation arrays */
ajMeltTempSave(ajStrGetPtr(substr),0,seqlen,saltconc,dnaconc,1,
&entropy, &enthalpy, &energy);
ajFmtPrintF(outf, "\n\nINPUT SUMMARY\n");
ajFmtPrintF(outf, "*************\n\n");
if(targetrange)
ajFmtPrintF
(outf, "Prima of %s from positions %d to %d bps\n",
ajSeqGetNameC(sequence),targetstart, targetend);
else
ajFmtPrintF(outf, "Prima of %s\n", ajSeqGetNameC(sequence));
ajFmtPrintF(outf, "PRIMER CONSTRAINTS:\n");
ajFmtPrintF
(outf, "PRIMA DOES NOT ALLOW PRIMER SEQUENCE AMBIGUITY OR ");
ajFmtPrintF(outf,"DUPLICATE PRIMER ENDPOINTS\n");
ajFmtPrintF(outf,
"Primer size range is %d-%d\n",minprimerlen,maxprimerlen);
ajFmtPrintF(outf,
"Primer GC content range is %.2f-%.2f\n",minpmGCcont,
maxpmGCcont);
ajFmtPrintF(outf,"Primer melting Temp range is %.2f - %.2f C\n",
minprimerTm, maxprimerTm);
ajFmtPrintF (outf, "PRODUCT CONSTRAINTS:\n");
ajFmtPrintF(outf,"Product GC content range is %.2f-%.2f\n",
minprodGCcont, maxprodGCcont);
ajFmtPrintF(outf, "Salt concentration is %.2f (mM)\n", saltconc);
ajFmtPrintF(outf, "DNA concentration is %.2f (nM)\n", dnaconc);
if(targetrange)
ajFmtPrintF(outf, "Targeted range to amplify is from %d to %d\n",
targetstart,targetend);
else
{
ajFmtPrintF(outf,"Considering all suitable Primer pairs with ");
ajFmtPrintF(outf,"Product length ranges %d to %d\n\n\n", minprodlen,
maxprodlen);
}
ajFmtPrintF(outf, "\n\nPRIMER/PRODUCT PAIR CALCULATIONS & OUTPUT\n");
ajFmtPrintF(outf, "*****************************************\n\n");
if(seqlen-minprimerlen < 0)
ajFatal("Sequence too short");
if(targetrange)
{
ajStrAssignSubC(&p1,ajStrGetPtr(substr),targetstart-begin,targetend-begin);
prodGC = ajMeltGC(substr,seqlen);
prodTm = ajMeltTempProd(prodGC,saltconc,seqlen);
if(prodGC<minprodGCcont || prodGC>maxprodGCcont)
{
ajFmtPrintF(outf,
"Product GC content [%.2f] outside acceptable range\n",
prodGC);
embExitBad();
return 0;
}
prima_testtarget(substr, revstr, targetstart-begin, targetend-begin,
minprimerlen, maxprimerlen,
seqlen, minprimerTm, maxprimerTm, minpmGCcont,
maxpmGCcont, minprodGCcont, maxprodGCcont, saltconc,
dnaconc, pairlist, &npair);
}
if(!targetrange)
{
limit = seqlen-minprimerlen-minprodlen+1;
lastpos = seqlen-minprodlen;
limit2 = maxprodlen-minprodlen;
/* Outer loop selects all possible product start points */
for(i=minprimerlen; i<limit; ++i)
{
startpos = i;
ajDebug("Position in sequence %d\n",startpos);
endpos = i+minprodlen-1;
/* Inner loop selects all possible product lengths */
for(j=0; j<limit2; ++j, ++endpos)
{
if(endpos>lastpos)
break;
v1 = endpos-startpos+1;
ajStrAssignSubC(&p1,ajStrGetPtr(substr),startpos,endpos);
prodGC = ajMeltGC(p1,v1);
prodTm = ajMeltTempProd(prodGC,saltconc,v1);
if(prodGC<minprodGCcont || prodGC>maxprodGCcont)
continue;
/* Only accept primers with acceptable Tm and GC */
neric = 0;
nfred = 0;
prima_testproduct(substr, startpos, endpos, primerlen,
minprimerlen, maxprimerlen,minpmGCcont,
maxpmGCcont, minprimerTm, maxprimerTm,
minprodlen, maxprodlen, prodTm, prodGC, seqlen,
&eric,&fred,forlist,revlist,&neric,&nfred,
stepping_value, saltconc,dnaconc, isDNA, begin);
if(!neric)
continue;
/* Now reject those primers with self-complementarity */
prima_reject_self(forlist,revlist,&neric,&nfred);
if(!neric)
continue;
/* Reject any primers that could bind elsewhere in the
sequence */
prima_test_multi(forlist,revlist,&neric,&nfred,substr,revstr,
seqlen);
/* Now select the least complementary pair (if any) */
prima_best_primer(forlist, revlist, &neric, &nfred);
if(!neric)
continue;
AJNEW(pair);
ajListPop(forlist,(void **)&f);
ajListPop(revlist,(void **)&r);
pair->f = f;
pair->r = r;
++npair;
ajListPush(pairlist,(void *)pair);
}
}
}
if(!targetrange)
{
/* Get rid of primer pairs nearby the top scoring ones */
prima_TwoSortscorepos(&pairlist);
prima_prune_nearby(pairlist, &npair, maxprimerlen-1);
ajListSort(pairlist,prima_PosCompare);
prima_check_overlap(pairlist,&npair,overlap);
}
if(npair)
{
if(!targetrange)
ajFmtPrintF(outf,"%d pairs found\n\n",npair);
else
ajFmtPrintF(outf,
"Closest primer pair to specified product is:\n\n");
if((maxprimerlen<26 && seqlen<999999 && !dolist))
ajFmtPrintF(outf,"\n\t\tForward\t\t\t\t\tReverse\n\n");
}
for(i=0;i<npair;++i)
{
if(!targetrange)
ajFmtPrintF(outf,"[%d]\n",i+1);
ajListPop(pairlist,(void **)&pair);
prodlen = pair->r->start - (pair->f->start + pair->f->primerlen);
if((maxprimerlen<26 && seqlen<999999 && !dolist))
{
v1 = pair->f->start;
v2 = v1 + pair->f->primerlen -1;
ajStrAssignSubS(&p1,substr,v1,v2);
ajFmtPrintF(outf,"%6d %-25.25s %d\t", v1+begin, ajStrGetPtr(p1),
v2+begin);
v1 = pair->r->start;
v2 = v1 + pair->r->primerlen -1;
ajStrAssignSubS(&p2,substr,v1,v2);
ajSeqstrReverse(&p2);
ajFmtPrintF(outf,
"%6d %-25.25s %d\n", v1+begin, ajStrGetPtr(p2), v2+begin);
ajFmtPrintF(outf," Tm %.2f C (GC %.2f%%)\t\t ",
pair->f->primerTm,pair->f->primGCcont*100.);
ajFmtPrintF(outf,"Tm %.2f C (GC %.2f%%)\n",
pair->r->primerTm,pair->r->primGCcont*100.);
ajFmtPrintF(outf," Length: %-32dLength: %d\n",
pair->f->primerlen,pair->r->primerlen);
ajFmtPrintF(outf," Tma: %.2f C\t\t\t",
ajAnneal(pair->f->primerTm,pair->f->prodTm));
ajFmtPrintF(outf," Tma: %.2f C\n\n\n",
ajAnneal(pair->r->primerTm,pair->f->prodTm));
ajFmtPrintF(outf," Product GC: %.2f%%\n",
pair->f->prodGC * 100.0);
ajFmtPrintF(outf," Product Tm: %.2f C\n",
pair->f->prodTm);
ajFmtPrintF(outf," Length: %d\n\n\n",prodlen);
}
else
{
ajFmtPrintF(outf," Product from %d to %d\n",pair->f->start+
pair->f->primerlen+begin,pair->r->start-1+begin);
ajFmtPrintF(outf," Tm: %.2f C GC: %.2f%%\n",
pair->f->prodTm,pair->f->prodGC*(float)100.);
ajFmtPrintF(outf," Length: %d\n\n\n",prodlen);
v1 = pair->f->start;
v2 = v1 + pair->f->primerlen -1;
ajStrAssignSubS(&p1,substr,v1,v2);
ajFmtPrintF(outf," Forward: 5' %s 3'\n",ajStrGetPtr(p1));
ajFmtPrintF(outf," Start: %d\n",v1+begin);
ajFmtPrintF(outf," End: %d\n",v2+begin);
ajFmtPrintF(outf," Tm: %.2f C\n",
pair->f->primerTm);
ajFmtPrintF(outf," GC: %.2f%%\n",
pair->f->primGCcont*(float)100.);
ajFmtPrintF(outf," Len: %d\n",
pair->f->primerlen);
ajFmtPrintF(outf," Tma: %.2f C\n\n\n",
ajAnneal(pair->f->primerTm,pair->f->prodTm));
v1 = pair->r->start;
v2 = v1 + pair->r->primerlen -1;
ajStrAssignSubS(&p2,substr,v1,v2);
ajSeqstrReverse(&p2);
ajStrAssignSubS(&p1,substr,v1,v2);
ajFmtPrintF(outf," Reverse: 5' %s 3'\n",ajStrGetPtr(p1));
ajFmtPrintF(outf," Start: %d\n",v1+begin);
ajFmtPrintF(outf," End: %d\n",v2+begin);
ajFmtPrintF(outf," Tm: %.2f C\n",
pair->r->primerTm);
ajFmtPrintF(outf," GC: %.2f%%\n",
pair->r->primGCcont*(float)100.);
ajFmtPrintF(outf," Len: %d\n",
pair->r->primerlen);
ajFmtPrintF(outf," Tma: %.2f C\n\n\n",
ajAnneal(pair->r->primerTm,pair->f->prodTm));
}
prima_PrimerDel(&pair->f);
prima_PrimerDel(&pair->r);
AJFREE(pair);
}
ajStrDel(&seqstr);
ajStrDel(&revstr);
ajStrDel(&substr);
ajStrDel(&p1);
ajStrDel(&p2);
ajListFree(&forlist);
ajListFree(&revlist);
ajListFree(&pairlist);
ajFileClose(&outf);
ajSeqDel(&sequence);
AJFREE(entropy);
AJFREE(enthalpy);
AJFREE(energy);
embExit();
return 0;
}
static void domainalign_ProcessStampFile(AjPStr in,
AjPStr out,
AjPDomain domain,
ajint noden,
AjPFile logf)
{
AjPFile outf = NULL; /* Output file pointer. */
AjPFile inf = NULL; /* Input file pointer. */
AjPStr temp1 = NULL; /* Temporary string. */
AjPStr temp2 = NULL; /* Temporary string. */
AjPStr temp3 = NULL; /* Temporary string. */
AjPStr line = NULL; /* Line of text from input file. */
ajint blk = 1; /* Count of the current block in the input file.
Block 1 is the numbering and protein sequences,
Block 2 is the secondary structure,
Block 3 is the Very/Less/Post similar records*/
AjBool ok = ajFalse;
/* Initialise strings. */
line = ajStrNew();
temp1 = ajStrNew();
temp2 = ajStrNew();
temp3 = ajStrNew();
/* Open input and output files. */
if(!(inf=ajFileNewInNameS(in)))
ajFatal("Could not open input file in domainalign_ProcessStampFile");
/* Start of code for reading input file.
Ignore everything up to first line beginning with 'Number'. */
while((ajReadlineTrim(inf,&line)))
{
/* ajFileReadLine will trim the tailing \n. */
if((ajStrGetCharPos(line, 1)=='\0'))
{
ok = ajTrue;
break;
}
}
/* Read rest of input file. */
if(ok)
{
/* Write DOMAIN classification records to file. */
if(!(outf=ajFileNewOutNameS(out)))
ajFatal("Could not open output file in domainalign_ProcessStampFile");
if((domain->Type == ajSCOP))
{
ajFmtPrintF(outf,"# TY SCOP\n# XX\n");
ajFmtPrintF(outf,"# CL %S",domain->Scop->Class);
ajFmtPrintSplit(outf,domain->Scop->Fold,"\n# XX\n# FO ",
75," \t\n\r");
ajFmtPrintSplit(outf,domain->Scop->Superfamily,"# XX\n# SF ",
75," \t\n\r");
ajFmtPrintSplit(outf,domain->Scop->Family,"# XX\n# FA ",
75," \t\n\r");
ajFmtPrintF(outf,"# XX\n");
}
else
{
ajFmtPrintF(outf,"# TY CATH\n# XX\n");
ajFmtPrintF(outf,"# CL %S",domain->Cath->Class);
ajFmtPrintSplit(outf,domain->Cath->Architecture,"\n# XX\n# AR ",
75," \t\n\r");
ajFmtPrintSplit(outf,domain->Cath->Topology,"# XX\n# TP ",75,
" \t\n\r");
ajFmtPrintSplit(outf,domain->Cath->Superfamily,"# XX\n# SF ",75,
" \t\n\r");
ajFmtPrintF(outf,"# XX\n");
}
if((domain->Type == ajSCOP))
{
if(noden==1)
ajFmtPrintF(outf,"# SI %d\n# XX",domain->Scop->Sunid_Class);
else if(noden==2)
ajFmtPrintF(outf,"# SI %d\n# XX",domain->Scop->Sunid_Fold);
else if(noden==3)
ajFmtPrintF(outf,"# SI %d\n# XX",
domain->Scop->Sunid_Superfamily);
else if(noden==4)
ajFmtPrintF(outf,"# SI %d\n# XX",
domain->Scop->Sunid_Family);
else
ajFatal("Node number error in domainalign_ProcessStampFile");
}
else
{
if(noden==5)
ajFmtPrintF(outf,"# SI %d\n# XX", domain->Cath->Class_Id);
else if(noden==6)
ajFmtPrintF(outf,"# SI %d\n# XX", domain->Cath->Arch_Id);
else if(noden==7)
ajFmtPrintF(outf,"# SI %d\n# XX",domain->Cath->Topology_Id);
else if(noden==8)
ajFmtPrintF(outf,"# SI %d\n# XX",
domain->Cath->Superfamily_Id);
else if(noden==9)
ajFmtPrintF(outf,"# SI %d\n# XX",domain->Cath->Family_Id);
else
ajFatal("Node number error in domainalign_ProcessStampFile");
}
while((ajReadlineTrim(inf,&line)))
{
/* Increment counter for block of file. */
if((ajStrGetCharPos(line, 1)=='\0'))
{
blk++;
if(blk==4)
blk=1;
continue;
}
/* Block of numbering line and protein sequences. */
if(blk==1)
{
/* Print the number line out as it is. */
if(ajStrPrefixC(line,"Number"))
ajFmtPrintF(outf,"\n# %7s %S\n"," ", line);
else
{
/* Read only the 7 characters
of the domain identifier
code in. */
ajFmtScanS(line, "%S", &temp1);
ajStrAssignSubS(&temp2, temp1, 0, 6);
/* Read the sequence. */
ajStrAssignSubS(&temp3, line, 13, 69);
ajStrExchangeSetCC(&temp3, " ", "X");
ajFmtPrintF(logf, "Replaced ' ' in STAMP alignment "
"with 'X'\n");
ajStrFmtUpper(&temp3);
/* Write domain id code and sequence out. */
ajFmtPrintF(outf,"%-15S%7d %S%7d\n",
temp2, 0, temp3, 0);
}
}
/* Secondary structure filled with '????' (unwanted). */
else if(blk==2)
{
continue;
}
/* Similarity lines. */
else
{
if(ajStrPrefixC(line,"Post"))
{
/* Read the sequence. */
ajStrAssignSubS(&temp3, line, 13, 69);
/* Write post similar line out. */
ajFmtPrintF(outf,"%-15s%7s %S\n","# Post_similar", " ",
temp3);
}
/* Ignore Very and Less similar lines. */
else continue;
}
}
}
else /* ok == ajFalse. */
{
ajWarn("\n***********************************************\n"
"* STAMP was called but output file was EMPTY! *\n"
"* NO OUTPUT FILE GENERATED FOR THIS NODE. *\n"
"***********************************************\n");
ajFmtPrintF(logf, "STAMP called but output file empty. "
"No output file for this node!");
}
/* Clean up and close input and output files. */
ajFileClose(&outf);
ajFileClose(&inf);
ajStrDel(&line);
ajStrDel(&temp1);
ajStrDel(&temp2);
ajStrDel(&temp3);
/* All done. */
return;
}
int main(int argc, char **argv)
{
AjPSeqall seqall;
AjPSeq seq;
AjPFile outf;
AjPCod codon;
AjPStr substr;
AjBool sum;
ajint ccnt;
ajint beg;
ajint end;
float Nc;
double td;
embInit("chips", argc, argv);
seqall = ajAcdGetSeqall("seqall");
outf = ajAcdGetOutfile("outfile");
sum = ajAcdGetBoolean("sum");
codon = ajCodNewCodenum(0);
ccnt = 0;
substr = ajStrNew();
while(ajSeqallNext(seqall, &seq))
{
beg = ajSeqallGetseqBegin(seqall);
end = ajSeqallGetseqEnd(seqall);
ajStrAssignSubS(&substr,ajSeqGetSeqS(seq),beg-1,end-1);
ajStrFmtUpper(&substr);
ajCodSetTripletsS(codon,substr,&ccnt);
if(!sum)
{
ajCodCalcUsage(codon,ccnt);
td = ajCodCalcNc(codon);
Nc = (float) td;
ajFmtPrintF(outf,"%-20s Nc = %.3f\n",ajSeqGetNameC(seq),Nc);
ajCodClearData(codon);
}
}
if(sum)
{
ajCodCalcUsage(codon,ccnt);
td = ajCodCalcNc(codon);
Nc = (float) td;
ajFmtPrintF(outf,"# CHIPS codon usage statistics\n\n");
ajFmtPrintF(outf,"Nc = %.3f\n",Nc);
}
ajFileClose(&outf);
ajCodDel(&codon);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&substr);
embExit();
return 0;
}
ajuint embMatProtScanInt(const AjPStr s, const AjPStr n, const EmbPMatPrints m,
AjPList *l,
AjBool *all, AjBool *ordered, AjBool overlap)
{
EmbPMatMatch mm;
AjPStr t;
char *p;
char *q;
ajint slen;
ajint score;
ajint mlen;
ajint elem;
ajint minpc;
ajint maxscore;
ajint limit;
ajint sum;
ajint hpe;
ajint hpm;
ajint lastelem;
ajint lastpos;
ajint op;
ajint i;
ajint j;
t = ajStrNewC(ajStrGetPtr(s));
ajStrFmtUpper(&t);
p = q = ajStrGetuniquePtr(&t);
slen = ajStrGetLen(t);
for(i=0;i<slen;++i,++p)
*p = ajSysCastItoc(ajBasecodeToInt((ajint)*p));
p = q;
*all = *ordered = ajTrue;
lastelem = lastpos = INT_MAX;
hpm=0;
for(elem=(m)->n - 1;elem >= 0;--elem)
{
hpe = 0;
mlen = (m)->len[elem];
minpc = (m)->thresh[elem];
maxscore = (m)->max[elem];
limit = slen-mlen;
for(i=0;i<limit;++i)
{
sum = 0;
for(j=0;j<mlen;++j)
sum += (m)->matrix[elem][(ajint) p[i+j]][j];
score = (sum*100)/maxscore;
if(score>=minpc)
{
if(elem<lastelem && *ordered)
{
if(lastelem == INT_MAX)
{
lastelem = elem;
lastpos = i;
}
else
{
lastelem = elem;
op = i;
if(!overlap)
op += mlen;
if(op >= lastpos)
*ordered = ajFalse;
lastpos = i;
}
}
++hpe;
++hpm;
matPushHitInt(n,m,l,i,score,elem,hpe,hpm);
}
}
if(!hpe)
*all = ajFalse;
}
if(hpm)
{
ajListPop(*l,(void **)&mm);
if(*all)
{
mm->all = ajTrue;
if(*ordered)
mm->ordered = ajTrue;
else
mm->ordered = ajFalse;
}
else
{
mm->all = ajFalse;
if(*ordered)
mm->ordered = ajTrue;
else
mm->ordered = ajFalse;
}
ajListPush(*l,(void *)mm);
}
ajStrDel(&t);
return hpm;
}
static void primersearch_read_primers(AjPList *primerList, AjPFile primerFile,
ajint mmp)
{
AjPStr rdline = NULL;
AjPStrTok handle = NULL;
ajint nprimers = 0;
Primer primdata = NULL;
while (ajReadlineTrim(primerFile, &rdline))
{
primdata = NULL;
if (ajStrGetCharFirst(rdline) == '#')
continue;
if (ajStrSuffixC(rdline, ".."))
continue;
AJNEW(primdata);
primdata->Name = NULL;
primersearch_initialise_pguts(&primdata->forward);
primersearch_initialise_pguts(&primdata->reverse);
primdata->hitlist = ajListNew();
handle = ajStrTokenNewC(rdline, " \t");
ajStrTokenNextParse(&handle, &primdata->Name);
ajStrTokenNextParse(&handle, &primdata->forward->patstr);
ajStrFmtUpper(&primdata->forward->patstr);
ajStrTokenNextParse(&handle, &primdata->reverse->patstr);
ajStrFmtUpper(&primdata->reverse->patstr);
ajStrTokenDel(&handle);
/* copy patterns for Henry Spencer code */
ajStrAssignC(&primdata->forward->origpat,
ajStrGetPtr(primdata->forward->patstr));
ajStrAssignC(&primdata->reverse->origpat,
ajStrGetPtr(primdata->reverse->patstr));
/* set the mismatch level */
primdata->forward->mm = (ajint)
(ajStrGetLen(primdata->forward->patstr)*mmp)/100;
primdata->reverse->mm = (ajint)
(ajStrGetLen(primdata->reverse->patstr)*mmp)/100;
if(primersearch_classify_and_compile(&primdata))
{
ajListPushAppend(*primerList, primdata);
nprimers++;
}
else /* there was something funny about the primer sequences */
{
ajUser("Cannot use %s\n", ajStrGetPtr(primdata->Name));
primersearch_free_pguts(&primdata->forward);
primersearch_free_pguts(&primdata->reverse);
ajStrDel(&primdata->Name);
ajListFree(&primdata->hitlist);
ajListFree(&primdata->hitlist);
AJFREE(primdata);
}
}
ajStrDel(&rdline);
return;
}
AjPPatlistRegex ajPatlistRegexRead (const AjPStr patspec,
const AjPStr patname,
const AjPStr fmt,
ajuint type, AjBool upper, AjBool lower)
{
AjPPatlistRegex patlist = NULL;
AjPStr line = NULL;
AjPStr pat = NULL;
AjPStr name = NULL;
AjPFilebuff infile = NULL;
AjPStr patstr = NULL;
ajuint ifmt;
ajuint npat = 0;
AjPStr namestr = NULL;
ajStrAssignS(&namestr, patname);
ajStrAssignEmptyC(&namestr, "regex");
ajStrAssignS(&patstr, patspec);
patlist = ajPatlistRegexNewType(type);
ifmt = patternRegexFormat(fmt);
if(ajStrGetCharFirst(patspec) == '@')
{
ajStrCutStart(&patstr, 1);
infile = ajFilebuffNewNameS(patstr);
if(!infile)
{
ajErr("Unable to open regular expression file '%S'", patstr);
return NULL;
}
line = ajStrNew();
pat = ajStrNew();
name = ajStrNew();
if(!ifmt)
{
ajBuffreadLineTrim(infile,&line);
if(ajStrPrefixC(line, ">"))
ifmt = 2;
else
ifmt = 1;
ajFilebuffReset(infile);
}
switch(ifmt)
{
case 1:
while (ajBuffreadLineTrim(infile,&line))
{
npat++;
ajStrAppendS (&pat,line);
if(lower)
ajStrFmtLower(&pat);
if(upper)
ajStrFmtUpper(&pat);
ajFmtPrintS(&name, "%S%u", namestr, npat);
ajPatternRegexNewList(patlist,name,pat);
ajStrSetClear(&pat);
}
break;
default:
while (ajBuffreadLineTrim(infile,&line))
{
if (ajStrFindC(line,">")>-1)
{
npat++;
if (ajStrGetLen(name))
{
if(lower)
ajStrFmtLower(&pat);
if(upper)
ajStrFmtUpper(&pat);
ajPatternRegexNewList(patlist,name,pat);
ajStrSetClear(&name);
ajStrSetClear(&pat);
}
ajStrCutStart(&line,1);
ajStrAssignS (&name,line);
if(!ajStrGetLen(name))
ajFmtPrintS(&name, "%S%u", namestr, npat);
}
else
ajStrAppendS (&pat,line);
}
ajStrAssignEmptyS(&name, patname);
ajPatternRegexNewList(patlist,name,pat);
ajStrSetClear(&pat);
break;
}
ajFilebuffDel(&infile);
}
else
{
ajStrAssignS(&pat, patspec);
if(lower)
ajStrFmtLower(&pat);
if(upper)
ajStrFmtUpper(&pat);
ajStrAssignS(&name, namestr);
ajPatternRegexNewList(patlist,name,pat);
}
ajStrDel(&name);
ajStrDel(&namestr);
ajStrDel(&patstr);
ajStrDel(&line);
ajStrDel(&pat);
return patlist;
}
static AjBool dbiblast_parseNcbi(const AjPStr line, AjPFile * alistfile,
AjBool systemsort, AjPStr const * fields,
ajint* maxFieldLen,
ajuint* countfield,
AjPStr* myid,
AjPList* fdlist)
{
char* fd;
static ajint numFields;
static ajint accfield = -1;
static ajint desfield = -1;
static ajint svnfield = -1;
static AjBool reset = AJTRUE;
if(!fields)
{
reset = ajTrue;
accfield = svnfield = desfield = -1;
return ajFalse;
}
if(reset)
{
numFields = 0;
while(fields[numFields])
{
if(ajStrMatchCaseC(fields[numFields], "acc"))
accfield=numFields;
else if(ajStrMatchCaseC(fields[numFields], "sv"))
svnfield=numFields;
else if(ajStrMatchCaseC(fields[numFields], "des"))
desfield=numFields;
else
ajWarn("EMBL parsing unknown field '%S' ignored",
fields[numFields]);
numFields++;
}
reset = ajFalse;
}
if(!wrdexp)
wrdexp = ajRegCompC("([A-Za-z0-9]+)");
ajStrAssignC(&tmpdes,"");
ajStrAssignC(&t,"");
ajStrAssignC(&tmpac,"");
ajStrAssignC(&tmpsv,"");
ajStrAssignC(&tmpgi,"");
ajStrAssignC(&tmpdb,"");
ajFmtPrintS(&t,">%S",line);
if(!ajSeqParseNcbi(t,myid,&tmpac,&tmpsv,&tmpgi,&tmpdb,&tmpdes))
return ajFalse;
if(ajStrGetLen(tmpac))
ajStrFmtUpper(&tmpac);
if(accfield >= 0)
embDbiMaxlen(&tmpac, &maxFieldLen[accfield]);
if(svnfield >= 0)
{
embDbiMaxlen(&tmpsv, &maxFieldLen[svnfield]);
embDbiMaxlen(&tmpgi, &maxFieldLen[svnfield]);
}
ajStrFmtUpper(myid);
/* ajDebug("parseNCBI success\n"); */
if(systemsort)
{
if(accfield >= 0 && ajStrGetLen(tmpac))
{
countfield[accfield]++;
ajFmtPrintF(alistfile[accfield], "%S %S\n", *myid, tmpac);
}
if(svnfield >= 0 && ajStrGetLen(tmpsv))
{
countfield[svnfield]++;
ajFmtPrintF(alistfile[svnfield], "%S %S\n", *myid, tmpsv);
}
if(svnfield >= 0 && ajStrGetLen(tmpgi))
{
countfield[svnfield]++;
ajFmtPrintF(alistfile[svnfield], "%S %S\n", *myid, tmpgi);
}
if(desfield >= 0 && ajStrGetLen(tmpdes))
while(ajRegExec(wrdexp, tmpdes))
{
ajRegSubI(wrdexp, 1, &tmpfd);
embDbiMaxlen(&tmpfd, &maxFieldLen[desfield]);
ajStrFmtUpper(&tmpfd);
ajDebug("++des '%S'\n", tmpfd);
countfield[desfield]++;
ajFmtPrintF(alistfile[desfield], "%S %S\n", *myid, tmpfd);
ajRegPost(wrdexp, &tmpdes);
}
}
else
{
if(accfield >= 0 && ajStrGetLen(tmpac))
{
fd = ajCharNewS(tmpac);
countfield[accfield]++;
ajListPushAppend(fdlist[accfield], fd);
}
if(svnfield >= 0 && ajStrGetLen(tmpsv))
{
fd = ajCharNewS(tmpsv);
countfield[svnfield]++;
ajListPushAppend(fdlist[svnfield], fd);
}
if(svnfield >= 0 && ajStrGetLen(tmpgi))
{
fd = ajCharNewS(tmpgi);
ajListPushAppend(fdlist[svnfield], fd);
}
if(desfield >= 0 && ajStrGetLen(tmpdes))
{
while(ajRegExec(wrdexp, tmpdes))
{
ajRegSubI(wrdexp, 1, &tmpfd);
embDbiMaxlen(&tmpfd, &maxFieldLen[desfield]);
ajStrFmtUpper(&tmpfd);
ajDebug("++des '%S'\n", tmpfd);
fd = ajCharNewS(tmpfd);
countfield[desfield]++;
ajListPushAppend(fdlist[desfield], fd);
ajRegPost(wrdexp, &tmpdes);
}
}
}
/* ajDebug("parseNCBI '%S' '%S'\n", *myid, tmpac); */
return ajTrue;
}
int main(int argc, char **argv)
{
AjPSeqall seqall;
AjPSeq seq = NULL;
AjPFile outf = NULL;
AjPStr strand = NULL;
AjPStr substr = NULL;
AjPStr bases = NULL;
ajint begin;
ajint end;
ajint len;
ajint minlen;
float minobsexp;
float minpc;
ajint window;
ajint shift;
ajint plotstart;
ajint plotend;
float *xypc = NULL;
float *obsexp = NULL;
AjBool *thresh = NULL;
float obsexpmax;
ajint i;
ajint maxarr;
embInit("newcpgreport",argc,argv);
seqall = ajAcdGetSeqall("sequence");
window = ajAcdGetInt("window");
shift = ajAcdGetInt("shift");
outf = ajAcdGetOutfile("outfile");
minobsexp = ajAcdGetFloat("minoe");
minlen = ajAcdGetInt("minlen");
minpc = ajAcdGetFloat("minpc");
substr = ajStrNew();
bases = ajStrNewC("CG");
maxarr = 0;
while(ajSeqallNext(seqall, &seq))
{
begin = ajSeqallGetseqBegin(seqall);
end = ajSeqallGetseqEnd(seqall);
strand = ajSeqGetSeqCopyS(seq);
ajStrFmtUpper(&strand);
ajStrAssignSubC(&substr,ajStrGetPtr(strand),--begin,--end);
len=ajStrGetLen(substr);
if(len > maxarr)
{
AJCRESIZE(obsexp, len);
AJCRESIZE(thresh, len);
AJCRESIZE(xypc, len);
maxarr = len;
}
for(i=0;i<len;++i)
obsexp[i]=xypc[i]=0.0;
newcpgreport_findbases(substr, len, window, shift, obsexp,
xypc, bases, &obsexpmax, &plotstart, &plotend);
newcpgreport_identify(outf, obsexp, xypc, thresh, 0, len, shift,
ajStrGetPtr(bases), ajSeqGetNameC(seq), minlen,
minobsexp, minpc, ajStrGetPtr(strand));
ajStrDel(&strand);
}
ajStrDel(&bases);
ajSeqDel(&seq);
ajStrDel(&substr);
ajFileClose(&outf);
AJFREE(obsexp);
AJFREE(thresh);
AJFREE(xypc);
ajSeqallDel(&seqall);
embExit();
return 0;
}
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)
{
AjPSeq seq = NULL;
AjPStr strand = NULL;
AjPStr substr = NULL;
AjPStr squares = NULL;
AjPStr diamonds = NULL;
AjPStr octags = NULL;
AjBool amphipathic;
AjPStr txt = NULL;
AjPGraph graph = NULL;
ajint begin;
ajint end;
ajint lc;
ajint i;
ajint j;
ajint r;
ajint count;
ajint pstart;
ajint pstop;
float xmin = 0.0;
float xmax = 150.0;
float ymin = 0.0;
float ymax = 112.5;
float xstart;
float ystart;
float ch = (float)1.8;
float xinc;
float yinc;
AjPStr fstr = NULL;
float x;
float y;
embInit("pepnet", argc, argv);
seq = ajAcdGetSeq("sequence");
graph = ajAcdGetGraph("graph");
octags = ajAcdGetString("octags");
squares = ajAcdGetString("squares");
diamonds = ajAcdGetString("diamonds");
amphipathic = ajAcdGetToggle("amphipathic");
ajStrFmtUpper(&octags);
ajStrFmtUpper(&squares);
ajStrFmtUpper(&diamonds);
if(amphipathic)
{
ajStrAssignC(&squares,"ACFGILMVWY");
ajStrAssignC(&diamonds,"");
ajStrAssignC(&octags,"");
}
substr = ajStrNew();
txt = ajStrNew();
fstr = ajStrNew();
begin = ajSeqGetBegin(seq);
end = ajSeqGetEnd(seq);
strand = ajSeqGetSeqCopyS(seq);
ajStrFmtUpper(&strand);
ajStrAssignSubC(&substr,ajStrGetPtr(strand),begin-1,end-1);
ajGraphAppendTitleS(graph, ajSeqGetUsaS(seq));
ajGraphOpenWin(graph, xmin,xmax,ymin,ymax);
for(count=begin-1,r=0;count<end;count+=231)
{
if (count > begin)
ajGraphNewpage(graph, ajFalse);
pstart=count;
pstop = AJMIN(end-1, count+230);
ajGraphicsSetCharscale(0.75);
xstart = 145.0;
ystart = 80.0;
yinc = ch * (float)2.5;
xinc = yinc / (float)2.5;
x = xstart;
for(i=pstart;i<=pstop;i+=7)
{
lc = i;
if(x < 10.0*xinc)
{
x = xstart;
ystart -= (float)7.5*yinc;
}
y=ystart;
ajFmtPrintS(&txt,"%d",i+1);
ajGraphicsSetFgcolour(RED);
ajGraphicsDrawposTextJustify(x-xinc,y-yinc-1,ajStrGetPtr(txt),0.5);
for(j=0;j<4;++j)
{
x -= xinc;
y += yinc;
if(lc <= pstop)
pepnet_plotresidue(*(ajStrGetPtr(substr)+r),x,y,
ajStrGetPtr(squares),ajStrGetPtr(octags),
ajStrGetPtr(diamonds));
++r;
++lc;
}
y=ystart+yinc/(float)2.0;
for(j=4;j<7;++j)
{
x -= xinc;
y += yinc;
if(lc <= pstop)
pepnet_plotresidue(*(ajStrGetPtr(substr)+r),x,y,
ajStrGetPtr(squares),ajStrGetPtr(octags),
ajStrGetPtr(diamonds));
++r;
++lc;
}
}
}
ajGraphicsClose();
ajGraphxyDel(&graph);
ajStrDel(&strand);
ajStrDel(&fstr);
ajSeqDel(&seq);
ajStrDel(&substr);
ajStrDel(&squares);
ajStrDel(&diamonds);
ajStrDel(&octags);
ajStrDel(&txt);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPSeqall seqall;
AjPSeq seq = NULL;
AjPReport outf = NULL;
AjPFile inf = NULL;
ajint begin;
ajint end;
AjPList l = NULL;
AjPStr strand = NULL;
AjPStr substr = NULL;
AjPStr line = NULL;
AjPStr name = NULL;
AjPStr acc = NULL;
AjPStr bf = NULL;
AjPStr menu;
AjPStr pattern = NULL;
AjPStr opattern = NULL;
AjPStr pname = NULL;
AjPStr key = NULL;
AjPStr value = NULL;
AjPTable atable = NULL;
AjPTable btable = NULL;
ajint mismatch;
ajint minlength;
ajint sum;
ajint v;
char cp;
const char *p;
embInit("tfscan", argc, argv);
seqall = ajAcdGetSeqall("sequence");
outf = ajAcdGetReport("outfile");
mismatch = ajAcdGetInt("mismatch");
minlength = ajAcdGetInt("minlength");
menu = ajAcdGetListSingle("menu");
pname = ajStrNew();
cp=ajStrGetCharFirst(menu);
if(cp=='F')
ajStrAssignC(&pname,"tffungi");
else if(cp=='I')
ajStrAssignC(&pname,"tfinsect");
else if(cp=='O')
ajStrAssignC(&pname,"tfother");
else if(cp=='P')
ajStrAssignC(&pname,"tfplant");
else if(cp=='V')
ajStrAssignC(&pname,"tfvertebrate");
else if(cp=='C')
inf = ajAcdGetDatafile("custom");
if(cp!='C')
{
inf = ajDatafileNewInNameS(pname);
if(!inf)
ajFatal("Either EMBOSS_DATA undefined or TFEXTRACT needs running");
}
name = ajStrNew();
acc = ajStrNew();
bf = ajStrNewC("");
substr = ajStrNew();
line = ajStrNew();
pattern = ajStrNewC("AA");
opattern = ajStrNew();
while(ajSeqallNext(seqall, &seq))
{
begin=ajSeqallGetseqBegin(seqall);
end=ajSeqallGetseqEnd(seqall);
ajStrAssignC(&name,ajSeqGetNameC(seq));
strand=ajSeqGetSeqCopyS(seq);
ajStrAssignSubC(&substr,ajStrGetPtr(strand),begin-1,end-1);
ajStrFmtUpper(&substr);
l=ajListNew();
atable = ajTablestrNew(1000);
btable = ajTablestrNew(1000);
sum=0;
while(ajReadlineTrim(inf,&line))
{
p = ajStrGetPtr(line);
if(!*p || *p=='#' || *p=='\n' || *p=='!')
continue;
ajFmtScanS(line,"%S%S%S",&pname,&pattern,&acc);
p += ajStrGetLen(pname);
while(*p && *p==' ')
++p;
p += ajStrGetLen(pattern);
while(*p && *p==' ')
++p;
p += ajStrGetLen(acc);
while(*p && *p==' ')
++p;
ajStrAssignS(&opattern,pattern);
ajStrAssignC(&bf,p); /* rest of line */
v = embPatVariablePattern(pattern,substr,pname,l,0,
mismatch,begin);
if(v)
{
key = ajStrNewS(pname);
value = ajStrNewS(acc);
ajTablePut(atable,(void *)key,(void *)value);
key = ajStrNewS(pname);
value = ajStrNewS(bf);
ajTablePut(btable,(void *)key,(void *)value);
}
sum += v;
}
if(sum)
tfscan_print_hits(&l,sum,outf,atable,seq,minlength,
btable);
ajFileSeek(inf,0L,0);
ajListFree(&l);
ajTablestrFree(&atable);
ajTablestrFree(&btable);
ajStrDel(&strand);
}
ajStrDel(&line);
ajStrDel(&name);
ajStrDel(&acc);
ajStrDel(&pname);
ajStrDel(&opattern);
ajStrDel(&bf);
ajStrDel(&pattern);
ajStrDel(&substr);
ajSeqDel(&seq);
ajFileClose(&inf);
ajReportClose(outf);
ajReportDel(&outf);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&menu);
embExit();
return 0;
}
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)
{
/* Variable Declarations */
AjPStr code = NULL;
AjPFile mfptr = NULL;
AjPFile wfptr = NULL;
AjPFile outf = NULL;
EmbPPropMolwt *mwdata;
EmbPPropAmino *aadata;
float *dhstat = NULL;
char code1;
AjPStr code3 = NULL;
ajint idx = 0;
ajuint i;
ajuint iend;
AjPStr propstr = NULL;
float charge;
char csign;
/* ACD File Processing */
embInit("inforesidue", argc, argv);
code = ajAcdGetString("code");
mfptr = ajAcdGetDatafile("aadata");
wfptr = ajAcdGetDatafile("mwdata");
outf = ajAcdGetOutfile("outfile");
aadata = embPropEaminoRead(mfptr);
mwdata = embPropEmolwtRead(wfptr);
if(!embReadAminoDataFloatC(DAYHOFF_FILE,&dhstat,(float)0.001))
ajFatal("Set the EMBOSS_DATA environment variable");
/* Application logic */
ajStrFmtUpper(&code);
iend = ajStrGetLen(code);
ajFmtPrintF(outf, "%-4s %-5s %-20s %6s %9s %-30s %s\n",
"Code", "Short", "Mnemonic",
"Charge", "MolWt",
"Properties", "Ambiguity");
for(i=0; i<iend; i++)
{
code1=ajStrGetCharPos(code,i);
if(ajResidueExistsChar(code1))
{
idx = ajBasecodeToInt(code1);
ajResidueToTriplet(code1, &code3);
ajStrFmtTitle(&code3);
if(!embPropGetProperties(aadata[idx], &propstr))
ajStrAssignC(&propstr, "(none)");
charge = embPropGetCharge(aadata[idx]);
if(charge > 0.0)
csign = '+';
else if(charge < 0.0)
csign = '-';
else
csign = ' ';
ajFmtPrintF(outf, "%-4c %-5S %-20S %3c%3.1f %9.4f %-30S %S\n",
code1, code3, ajResidueGetMnemonic(code1),
csign, fabs(charge),
embPropMolwtGetMolwt(mwdata[idx]),
propstr, ajResidueGetCodes(code1));
}
else
{
ajFmtPrintF(outf, "%-4c %-5s %-20s %6s %9s %-30s %s\n",
code1, ".", "invalid", ".", ".", ".", ".");
}
}
/* Memory management and exit */
ajStrDel(&code);
ajStrDel(&code3);
ajStrDel(&propstr);
ajFileClose(&outf);
ajFileClose(&mfptr);
ajFileClose(&wfptr);
ajFileClose(&outf);
embPropAminoDel(&aadata);
embPropMolwtDel(&mwdata);
AJFREE(dhstat);
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;
}
static void jaspscan_ParseInput(const AjPStr dir, const AjPStr jaspdir,
const AjPStr mats, const AjPStr excl,
ajuint *recurs, AjPList ret)
{
ajuint nm = 0;
ajuint ne = 0;
AjPStr *carr = NULL;
AjPStr *earr = NULL;
AjPFile inf = NULL;
AjPStr line = NULL;
AjPStr comm = NULL;
AjPStr val = NULL;
ajuint i;
ajuint j;
char c;
ajuint rlen = 0;
if(*recurs > JASPSCAN_RECURS)
ajFatal("Too many recursion levels in matrix list files");
line = ajStrNew();
comm = ajStrNew();
if(mats)
{
nm = ajArrCommaList(mats,&carr);
for(i=0; i < nm; ++i)
{
if(ajStrGetCharFirst(carr[i]) != '@')
ajStrFmtUpper(&carr[i]);
if(ajStrMatchC(carr[i],"ALL"))
{
jaspscan_GetFileList(dir, jaspdir, "*", ret);
ajListSortUnique(ret, ajStrVcmp, jaspscan_strdel);
}
else if(ajStrGetCharFirst(carr[i]) == '@')
{
ajStrTrimStartC(&carr[i],"@");
inf = ajFileNewInNameS(carr[i]);
if(!inf)
ajFatal("Cannot open list file %S",carr[i]);
while(ajReadlineTrim(inf,&line))
{
ajStrRemoveWhite(&line);
c = ajStrGetCharFirst(line);
if(c == '#' || c== '!')
continue;
if(ajStrGetLen(comm))
ajStrAppendC(&comm,",");
ajStrFmtUpper(&line);
ajStrAppendS(&comm,line);
}
*recurs += 1;
jaspscan_ParseInput(dir,jaspdir,comm,NULL,recurs,ret);
*recurs -= 1;
ajListSortUnique(ret, ajStrVcmp, jaspscan_strdel);
ajFileClose(&inf);
}
else
{
jaspscan_GetFileList(dir,jaspdir,ajStrGetPtr(carr[i]),ret);
ajListSortUnique(ret, ajStrVcmp, jaspscan_strdel);
}
}
for(i=0; i < nm; ++i)
ajStrDel(&carr[i]);
AJFREE(carr);
}
if(excl)
{
ne = ajArrCommaList(excl,&earr);
for(i=0; i < ne; ++i)
{
if(ajStrGetCharFirst(earr[i]) != '@')
ajStrFmtUpper(&earr[i]);
if(ajStrGetCharFirst(earr[i]) == '@')
{
ajStrTrimStartC(&earr[i],"@");
inf = ajFileNewInNameS(earr[i]);
if(!inf)
ajFatal("Cannot open list file %S",earr[i]);
while(ajReadlineTrim(inf,&line))
{
ajStrRemoveWhite(&line);
c = ajStrGetCharFirst(line);
if(c == '#' || c== '!')
continue;
if(ajStrGetLen(comm))
ajStrAppendC(&comm,",");
ajStrFmtUpper(&line);
ajStrAppendS(&comm,line);
}
*recurs += 1;
jaspscan_ParseInput(dir,jaspdir,NULL,comm,recurs,ret);
*recurs -= 1;
ajListSortUnique(ret, ajStrVcmp, jaspscan_strdel);
ajFileClose(&inf);
}
else
{
ajStrAssignS(&line,earr[i]);
ajStrAppendC(&line,J_EXT);
rlen = ajListGetLength(ret);
for(j=0; j < rlen; ++j)
{
ajListPop(ret,(void **)&val);
if(ajStrSuffixS(val,line))
ajStrDel(&val);
else
ajListPushAppend(ret,(void *)val);
}
}
}
for(i=0; i < ne; ++i)
ajStrDel(&earr[i]);
AJFREE(earr);
}
ajStrDel(&line);
ajStrDel(&comm);
return;
}
int main(int argc, char **argv)
{
AjPSeq seq = NULL;
AjPStr strand = NULL;
AjPStr substr = NULL;
AjPStr squares = NULL;
AjPStr diamonds = NULL;
AjPStr octags = NULL;
AjBool wheel;
AjBool amphipathic;
AjPGraph graph=0;
AjBool first;
AjBool startloop;
ajint begin;
ajint end;
ajint len;
ajint steps;
ajint turns;
ajint lc;
ajint i;
ajint j;
ajint k;
float xmin = (float) -1.0;
float xmax = (float) 1.0;
float ymin = (float) -0.75;
float ymax = (float) 0.75;
float minresplot = (float) 36.0;
float resgap = (float) 0.0533;
float wheelgap = (float) 0.00;
float nresgap = (float) 0.08;
float angle;
float oldangle;
float ang;
float radius;
float wradius;
float xx1;
float xx2;
float yy1;
float yy2;
embInit("pepwheel", argc, argv);
seq = ajAcdGetSeq("sequence");
steps = ajAcdGetInt("steps");
turns = ajAcdGetInt("turns");
graph = ajAcdGetGraph("graph");
octags = ajAcdGetString("octags");
squares = ajAcdGetString("squares");
diamonds = ajAcdGetString("diamonds");
wheel = ajAcdGetBoolean("wheel");
amphipathic = ajAcdGetToggle("amphipathic");
ajStrFmtUpper(&octags);
ajStrFmtUpper(&squares);
ajStrFmtUpper(&diamonds);
if(amphipathic)
{
ajStrAssignC(&squares,"ACFGILMVWY");
ajStrAssignC(&diamonds,"");
ajStrAssignC(&octags,"");
}
substr = ajStrNew();
begin = ajSeqGetBegin(seq);
end = ajSeqGetEnd(seq);
ajDebug("begin: %d end: %d\n", begin, end);
strand = ajSeqGetSeqCopyS(seq);
ajStrFmtUpper(&strand);
ajStrAssignSubC(&substr,ajStrGetPtr(strand),begin-1,end-1);
len = ajStrGetLen(substr);
ajGraphAppendTitleS(graph, ajSeqGetUsaS(seq));
ajGraphOpenWin(graph,xmin,xmax,ymin,ymax);
ajGraphicsSetFgcolour(AJB_BLACK);
ang = ((float)360.0 / (float)steps) * (float)turns;
first = ajTrue;
angle = (float) 90.0 + ang;
if(end-begin > (ajint)minresplot)
wradius = (float) 0.2;
else
wradius = (float) 0.40;
for(i=0,lc=0,radius=wradius+wheelgap;i<len;i+=steps)
{
wradius += wheelgap;
startloop = ajTrue;
k = AJMIN(i+steps, end);
for(j=i;j<k;++j)
{
oldangle = angle;
angle = oldangle-ang;
if(first)
startloop = first = ajFalse;
else
{
if(startloop)
{
if(wheel)
{
ajCvtPolToRec(wradius-wheelgap,oldangle,&xx1,&yy1);
ajCvtPolToRec(wradius,angle,&xx2,&yy2);
ajGraphicsDrawposLine(xx1,yy1,xx2,yy2);
}
startloop=ajFalse;
}
else
if(wheel)
{
ajCvtPolToRec(wradius,oldangle,&xx1,&yy1);
ajCvtPolToRec(wradius,angle,&xx2,&yy2);
ajGraphicsDrawposLine(xx1,yy1,xx2,yy2);
}
}
pepwheel_plotresidue(*(ajStrGetPtr(substr)+lc),radius+resgap,angle,
ajStrGetPtr(squares),ajStrGetPtr(octags),
ajStrGetPtr(diamonds),
xmin,xmax,ymin,ymax);
++lc;
if(lc==len)
break;
}
radius += nresgap;
}
ajGraphicsClose();
ajGraphxyDel(&graph);
ajStrDel(&strand);
ajStrDel(&substr);
ajSeqDel(&seq);
ajStrDel(&squares);
ajStrDel(&diamonds);
ajStrDel(&octags);
embExit();
return 0;
}
