void tagStormCheck(char *schemaFile, char *tagStormFile)
/* tagStormCheck - Check that a tagStorm conforms to a schema.. */
{
/* Load up schema from file. Make a hash of all non-wildcard
* tags, and a list of wildcard tags. */
struct tagSchema *schema, *schemaList = tagSchemaFromFile(schemaFile);
struct slRef *wildSchemaList = NULL, *requiredSchemaList = NULL;
/* Split up schemaList into hash and wildSchemaList. Calculate schemaSize */
struct hash *hash = hashNew(0);
int schemaSize = 0;
for (schema = schemaList; schema != NULL; schema = schema->next)
{
++schemaSize;
if (anyWild(schema->name))
{
refAdd(&wildSchemaList, schema);
}
else
hashAdd(hash, schema->name, schema);
if (schema->required != 0)
refAdd(&requiredSchemaList, schema);
}
slReverse(&wildSchemaList);
schemaList = NULL;
struct tagStorm *tagStorm = tagStormFromFile(tagStormFile);
struct dyString *scratch = dyStringNew(0);
rCheck(tagStorm->forest, tagStormFile, wildSchemaList, hash, requiredSchemaList, scratch);
if (gErrCount > 0)
noWarnAbort();
else
verbose(1, "No problems detected.\n");
}
void getGenoGraphs(struct sqlConnection *conn)
/* Set up ggList and ggHash with all available genome graphs */
{
struct genoGraph *userList = getUserGraphs();
struct genoGraph *compList = getCompGraphs(conn);
struct genoGraph *dbList = getDbGraphs(conn);
struct genoGraph *gg;
struct slRef *ref, *refList = NULL;
/* Buld up ggList from user and db lists. */
for (gg = compList; gg != NULL; gg = gg->next)
refAdd(&refList, gg);
for (gg = userList; gg != NULL; gg = gg->next)
refAdd(&refList, gg);
for (gg = dbList; gg != NULL; gg = gg->next)
refAdd(&refList, gg);
slReverse(&refList);
ggList = refList;
/* Buld up ggHash from ggList. */
ggHash = hashNew(0);
for (ref = ggList; ref != NULL; ref = ref->next)
{
gg = ref->val;
hashAdd(ggHash, gg->name, gg);
}
}
void addOutKeys(struct hash *tableHash, struct joinerPair *routeList,
struct tableJoiner **pTfList)
/* Add output keys to tableJoiners. These are in table hash.
* We may also have to add some fieldLess tables to the mix,
* which will get appended to *pTfList, and added to the hash
* if need be. */
{
struct joinerPair *route;
struct tableJoiner *tj;
char fullName[256];
for (route = routeList; route != NULL; route = route->next)
{
struct joinerDtf *a = route->a;
safef(fullName, sizeof(fullName), "%s.%s", a->database, a->table);
tj = hashFindVal(tableHash, fullName);
if (tj == NULL)
{
AllocVar(tj);
tj->database = a->database;
tj->table = a->table;
slAddTail(pTfList, tj);
hashAdd(tableHash, fullName, tj);
}
if (!inKeysOut(tj, route))
refAdd(&tj->keysOut, route);
}
}
static void joinerLinkParents(struct joiner *joiner)
/* Go through and link together parents and children. */
{
struct joinerSet *js, *parent;
struct hash *hash = newHash(0);
for (js = joiner->jsList; js != NULL; js = js->next)
{
if (hashLookup(hash, js->name))
errAbort("Duplicate joiner %s line %d of %s",
js->name, js->lineIx, joiner->fileName);
hashAdd(hash, js->name, js);
}
for (js = joiner->jsList; js != NULL; js = js->next)
{
char *typeOf = js->typeOf;
if (typeOf != NULL)
{
js->parent = hashFindVal(hash, typeOf);
if (js->parent == NULL)
errAbort("%s not define line %d of %s",
typeOf, js->lineIx, joiner->fileName);
refAdd(&js->parent->children, js);
}
}
for (js = joiner->jsList; js != NULL; js = js->next)
{
for (parent = js->parent; parent != NULL; parent = parent->parent)
{
if (parent == js)
errAbort("Circular typeOf dependency on joiner %s line %d of %s",
js->name, js->lineIx, joiner->fileName);
}
slReverse(&js->children);
}
}
struct expVar *expVarsFromTaggedFiles(struct taggedFile *tfList)
/* Build up a list of vars and their values and what file they are found in. */
{
struct hash *tagHash = hashNew(0);
struct expVar *varList = NULL, *var;
struct taggedFile *tf;
for (tf = tfList; tf != NULL; tf = tf->next)
{
struct metaTagVal *mtv;
for (mtv = tf->tagList; mtv != NULL; mtv = mtv->next)
{
if (sameString(mtv->val, "n/a") || isEmpty(mtv->tag))
continue;
var = hashFindVal(tagHash, mtv->tag);
if (var == NULL)
{
AllocVar(var);
var->name = cloneString(mtv->tag);
slAddHead(&varList, var);
hashAdd(tagHash, var->name, var);
}
struct expVal *val = expValFind(var->valList, mtv->val);
if (val == NULL)
{
AllocVar(val);
val->val = cloneString(mtv->val);
slAddHead(&var->valList, val);
}
var->useCount += 1;
refAdd(&val->tfList, tf);
}
}
hashFree(&tagHash);
return varList;
}
static struct htmlFormVar *findOrMakeVar(struct htmlPage *page, char *name,
struct hash *hash, struct htmlTag *tag, struct htmlFormVar **pVarList)
/* Find variable of existing name if it exists, otherwise
* make a new one and add to hash and list. Add reference
* to this tag to var. */
{
struct htmlFormVar *var = hashFindVal(hash, name);
if (var == NULL)
{
AllocVar(var);
var->name = name;
var->tagName = tag->name;
hashAdd(hash, name, var);
slAddHead(pVarList, var);
}
else
{
if (!sameWord(var->tagName, tag->name))
{
tagWarn(page, tag, "Mixing FORM variable tag types %s and %s",
var->tagName, tag->name);
var->tagName = tag->name;
}
}
refAdd(&var->tags, tag);
return var;
}
static void addChildren(struct joinerSet *js, struct slRef **pList)
/* Recursively add children to list. */
{
struct slRef *childRef;
for (childRef = js->children; childRef != NULL; childRef = childRef->next)
{
struct joinerSet *child = childRef->val;
refAdd(pList, child);
addChildren(child, pList);
}
}
static void rGetConstants(struct pfParse *pp, struct slRef **pRefs)
/* Get a list of all constants onto pRefs. */
{
if (pp->type == pptVarInit)
{
struct pfVar *var = pp->var;
if (var->ty->isConst)
refAdd(pRefs, var);
}
for (pp = pp->children; pp != NULL; pp = pp->next)
rGetConstants(pp, pRefs);
}
struct slRef *joinerSetInheritanceChain(struct joinerSet *js)
/* Return list of self, children, and parents (but not siblings).
* slFreeList result when done. */
{
struct slRef *list = NULL;
struct joinerSet *parent;
/* Add self and parents. */
for (parent = js; parent != NULL; parent = parent->parent)
refAdd(&list, parent);
addChildren(js, &list);
slReverse(&list);
return list;
}
static struct slRef *simpleSearchForTracksstruct(struct trix *trix,char **descWords,int descWordCount)
// Performs the simple search and returns the found tracks.
{
struct slRef *tracks = NULL;
struct trixSearchResult *tsList;
for(tsList = trixSearch(trix, descWordCount, descWords, TRUE); tsList != NULL; tsList = tsList->next)
{
struct track *track = (struct track *) hashFindVal(trackHash, tsList->itemId);
if (track != NULL) // It is expected that this is NULL (e.g. when the trix references trackDb tracks which have no tables)
{
refAdd(&tracks, track);
}
}
return tracks;
}
void cdwRetryJob(char *database, char *jobTable)
/* cdwRetryJob - Add jobs that failed back to a cdwJob format queue.. */
{
/* Figure out thresholds for age. */
long long now = cdwNow();
long long maxTimeThreshold = now - 24*3600 * maxTime;
/* Get list of all jobs ordered by ID with most recent job first. */
struct sqlConnection *conn = sqlConnect(database);
char query[512];
sqlSafef(query, sizeof(query), "select * from %s order by id desc", jobTable);
struct cdwJob *job, *jobList = cdwJobLoadByQuery(conn, query);
/* Loop through job list looking for commandLines that failed or timed out in their
* most recent attempt. */
struct hash *jobHash = hashNew(0);
struct slRef *failRef, *failRefList = NULL;
for (job = jobList; job != NULL; job = job->next)
{
if (hashLookup(jobHash, job->commandLine) == NULL)
{
hashAdd(jobHash, job->commandLine, job);
if (job->id >= minId && job->startTime != 0)
{
boolean timedOut = (job->startTime < maxTimeThreshold && job->endTime == 0);
if (job->returnCode != 0 || timedOut)
{
refAdd(&failRefList, job);
}
}
}
}
/* Loop through failed list printing or retrying */
for (failRef = failRefList; failRef != NULL; failRef = failRef->next)
{
job = failRef->val;
if (dry)
printf("%s\n", job->commandLine);
else
{
sqlSafef(query, sizeof(query),
"insert into %s (commandLine) values ('%s')", jobTable, job->commandLine);
sqlUpdate(conn, query);
}
}
}
static struct slRef *simpleSearchForTracksstruct(char *simpleEntry)
// Performs the simple search and returns the found tracks.
{
struct slRef *tracks = NULL;
// Prepare for trix search
if (!isEmpty(simpleEntry))
{
int trixWordCount = 0;
char *tmp = cloneString(simpleEntry);
char *val = nextWord(&tmp);
struct slName *el, *trixList = NULL;
while (val != NULL)
{
slNameAddTail(&trixList, val);
trixWordCount++;
val = nextWord(&tmp);
}
if (trixWordCount > 0)
{
// Unfortunately trixSearch can't handle the slName list
int i;
char **trixWords = needMem(sizeof(char *) * trixWordCount);
for (i = 0, el = trixList; el != NULL; i++, el = el->next)
trixWords[i] = strLower(el->name);
// Now open the trix file
char trixFile[HDB_MAX_PATH_STRING];
getSearchTrixFile(database, trixFile, sizeof(trixFile));
struct trix *trix = trixOpen(trixFile);
struct trixSearchResult *tsList = trixSearch(trix, trixWordCount, trixWords, TRUE);
for ( ; tsList != NULL; tsList = tsList->next)
{
struct track *track = (struct track *) hashFindVal(trackHash, tsList->itemId);
if (track != NULL) // It is expected that this is NULL
{ // (e.g. when trix references trackDb tracks which have no tables)
refAdd(&tracks, track);
}
}
//trixClose(trix); // don't bother (this is a CGI that is about to end)
}
}
return tracks;
}
void bwgMakeChromInfo(struct bwgSection *sectionList, struct hash *chromSizeHash,
int *retChromCount, struct bbiChromInfo **retChromArray,
int *retMaxChromNameSize)
/* Fill in chromId field in sectionList. Return array of chromosome name/ids.
* The chromSizeHash is keyed by name, and has int values. */
{
/* Build up list of unique chromosome names. */
struct bwgSection *section;
char *chromName = "";
int chromCount = 0;
int maxChromNameSize = 0;
struct slRef *uniq, *uniqList = NULL;
for (section = sectionList; section != NULL; section = section->next)
{
if (!sameString(section->chrom, chromName))
{
chromName = section->chrom;
refAdd(&uniqList, chromName);
++chromCount;
int len = strlen(chromName);
if (len > maxChromNameSize)
maxChromNameSize = len;
}
section->chromId = chromCount-1;
}
slReverse(&uniqList);
/* Allocate and fill in results array. */
struct bbiChromInfo *chromArray;
AllocArray(chromArray, chromCount);
int i;
for (i = 0, uniq = uniqList; i < chromCount; ++i, uniq = uniq->next)
{
chromArray[i].name = uniq->val;
chromArray[i].id = i;
chromArray[i].size = hashIntVal(chromSizeHash, uniq->val);
}
/* Clean up, set return values and go home. */
slFreeList(&uniqList);
*retChromCount = chromCount;
*retChromArray = chromArray;
*retMaxChromNameSize = maxChromNameSize;
}
void hubCommandAndPrint(char *command)
/* Send command to hub, and print response until blank line. */
{
char *line = NULL;
struct slRef *list = NULL, *ref;
struct paraMessage pm;
struct paraMultiMessage pmm;
int count = 0;
char *row[256];
/* Issue command and suck down response quickly into memory. */
if (!commandHubExt(command, &pm, &pmm))
errAbort("Couldn't send '%s' command to paraHub", command);
/* ensure the multi-message response comes from the correct ip and has no duplicate msgs*/
for (;;)
{
if (!pmmReceive(&pmm, hubRudp))
break;
if (pm.size == 0)
break;
count = chopByChar(pm.data, '\n', row, sizeof(row));
if (count > 1) --count; /* for multiline, count is inflated by one */
int i;
for(i=0; i<count; ++i)
refAdd(&list, cloneString(row[i]));
}
slReverse(&list);
/* Print results. */
for (ref = list; ref != NULL; ref = ref->next)
{
line = ref->val;
puts(line);
}
}
static void loadHashT3Ranges(struct gfRange *rangeList,
char *tSeqDir, struct hash *tFileCache, int qSeqSize, boolean isRc,
struct hash **retT3Hash, struct dnaSeq **retSeqList,
struct slRef **retT3RefList)
/* Load DNA in ranges into memory, and put translation in a hash
* that gets returned. */
{
struct hash *t3Hash = newHash(10);
struct dnaSeq *targetSeq, *tSeqList = NULL;
struct slRef *t3RefList = NULL;
struct gfRange *range;
for (range = rangeList; range != NULL; range = range->next)
{
struct trans3 *t3, *oldT3;
targetSeq = gfiExpandAndLoadCached(range, tFileCache,
tSeqDir, qSeqSize*3, &range->tTotalSize, TRUE, isRc, usualExpansion);
slAddHead(&tSeqList, targetSeq);
freez(&targetSeq->name);
targetSeq->name = cloneString(range->tName);
t3 = trans3New(targetSeq);
refAdd(&t3RefList, t3);
t3->start = range->tStart;
t3->end = range->tEnd;
t3->nibSize = range->tTotalSize;
t3->isRc = isRc;
if ((oldT3 = hashFindVal(t3Hash, range->tName)) != NULL)
{
slAddTail(&oldT3->next, t3);
}
else
{
hashAdd(t3Hash, range->tName, t3);
}
}
*retT3Hash = t3Hash;
*retSeqList = tSeqList;
*retT3RefList = t3RefList;
}
void elandMultiOutput(struct splatAli *start, struct splatAli *end,
int bestScore, int bestCount, int subCounts[3], FILE *f)
/* Output information on read in multiple mapping format. */
{
fprintf(f, ">%s\t", start->readName);
char *bases = splatAliBasesOnly(start->alignedBases);
fprintf(f, "%s\t", bases);
freeMem(bases);
fprintf(f, "%d:%d:%d\t", subCounts[0], subCounts[1], subCounts[2]);
/* Create a reference list of mappings that are in the best slot for substitutions,
* sorted by chromosome location. */
int targetSub = minSubs(subCounts);
struct slRef *refList = NULL, *ref;
struct splatAli *splat;
for (splat = start; splat != end; splat = splat->next)
{
if (countSubs(splat->alignedBases) == targetSub)
refAdd(&refList, splat);
}
slSort(&refList, cmpSplatRefChromStart);
/* Output comma separated list of mappings. */
char *chrom = "";
for (ref = refList; ref != NULL; ref = ref->next)
{
splat = ref->val;
if (!sameString(chrom, splat->chrom))
{
chrom = splat->chrom;
fprintf(f, "%s:", chrom);
}
fprintf(f, "%d", splat->chromStart+1);
fprintf(f, "%c", (splat->strand[0] == '-' ? 'R' : 'F'));
fprintf(f, "%d", targetSub);
if (ref->next != NULL)
fprintf(f, ",");
}
fprintf(f, "\n");
}
static struct slRef *advancedSearchForTracks(struct sqlConnection *conn,struct group *groupList,
char *nameSearch, char *typeSearch, char *descSearch,
char *groupSearch, struct slPair *mdbPairs)
// Performs the advanced search and returns the found tracks.
{
int tracksFound = 0;
struct slRef *tracks = NULL;
int numMetadataNonEmpty = 0;
struct slPair *pair = mdbPairs;
for (; pair!= NULL;pair=pair->next)
{
if (!isEmpty((char *)(pair->val)))
numMetadataNonEmpty++;
}
if (!isEmpty(groupSearch) && sameString(groupSearch,ANYLABEL))
groupSearch = NULL;
if (!isEmpty(typeSearch) && sameString(typeSearch,ANYLABEL))
typeSearch = NULL;
if (isEmpty(nameSearch) && isEmpty(typeSearch) && isEmpty(descSearch)
&& isEmpty(groupSearch) && numMetadataNonEmpty == 0)
return NULL;
// First do the metaDb searches, which can be done quickly for all tracks with db queries.
struct hash *matchingTracks = NULL;
if (numMetadataNonEmpty)
{
struct mdbObj *mdbObj, *mdbObjs = mdbObjRepeatedSearch(conn,mdbPairs,TRUE,FALSE);
if (mdbObjs)
{
for (mdbObj = mdbObjs; mdbObj != NULL; mdbObj = mdbObj->next)
{
if (matchingTracks == NULL)
matchingTracks = newHash(0);
hashAddInt(matchingTracks, mdbObj->obj, 1);
}
mdbObjsFree(&mdbObjs);
}
if (matchingTracks == NULL)
return NULL;
}
// Set the word lists up once
struct slName *nameList = NULL;
if (!isEmpty(nameSearch))
nameList = slNameListOfUniqueWords(cloneString(nameSearch),TRUE); // TRUE means respect quotes
struct slName *descList = NULL;
if (!isEmpty(descSearch))
descList = slNameListOfUniqueWords(cloneString(descSearch),TRUE);
struct group *group;
for (group = groupList; group != NULL; group = group->next)
{
if (isEmpty(groupSearch) || sameString(group->name, groupSearch))
{
if (group->trackList == NULL)
continue;
struct trackRef *tr;
for (tr = group->trackList; tr != NULL; tr = tr->next)
{
struct track *track = tr->track;
char *trackType = cloneFirstWord(track->tdb->type); // will be spilled
if ((matchingTracks == NULL || hashLookup(matchingTracks, track->track) != NULL)
&& ( isEmpty(typeSearch)
|| (sameWord(typeSearch, trackType) && !tdbIsComposite(track->tdb)))
&& (isEmpty(nameSearch) || searchNameMatches(track->tdb, nameList))
&& (isEmpty(descSearch) || searchDescriptionMatches(track->tdb, descList)))
{
if (track != NULL)
{
tracksFound++;
refAdd(&tracks, track);
}
else
warn("found group track is NULL.");
}
if (track->subtracks != NULL)
{
struct track *subTrack;
for (subTrack = track->subtracks; subTrack != NULL; subTrack = subTrack->next)
{
trackType = cloneFirstWord(subTrack->tdb->type); // will be spilled
if ( (matchingTracks == NULL
|| hashLookup(matchingTracks, subTrack->track) != NULL)
&& (isEmpty(typeSearch) || sameWord(typeSearch, trackType))
&& (isEmpty(nameSearch) || searchNameMatches(subTrack->tdb, nameList))
&& (isEmpty(descSearch) // subtracks inherit description
|| searchDescriptionMatches(subTrack->tdb, descList)
|| (tdbIsCompositeChild(subTrack->tdb) && subTrack->parent
&& searchDescriptionMatches(subTrack->parent->tdb, descList))))
{
if (track != NULL)
{
tracksFound++;
refAdd(&tracks, subTrack);
}
else
warn("found subtrack is NULL.");
}
}
}
}
}
}
return tracks;
}
static void rFindMulti(struct bptFile *bpt, bits64 blockStart, void *key, struct slRef **pList)
/* Find values corresponding to key and add them to pList. You'll need to
* Do a slRefFreeListAndVals() on the list when done. */
{
/* Seek to start of block. */
udcSeek(bpt->udc, blockStart);
/* Read block header. */
UBYTE isLeaf;
UBYTE reserved;
bits16 i, childCount;
udcMustReadOne(bpt->udc, isLeaf);
udcMustReadOne(bpt->udc, reserved);
boolean isSwapped = bpt->isSwapped;
childCount = udcReadBits16(bpt->udc, isSwapped);
int keySize = bpt->keySize;
UBYTE keyBuf[keySize]; /* Place to put a key, buffered on stack. */
UBYTE valBuf[bpt->valSize]; /* Place to put a value, buffered on stack. */
if (isLeaf)
{
for (i=0; i<childCount; ++i)
{
udcMustRead(bpt->udc, keyBuf, keySize);
udcMustRead(bpt->udc, valBuf, bpt->valSize);
if (memcmp(key, keyBuf, keySize) == 0)
{
void *val = cloneMem(valBuf, bpt->valSize);
refAdd(pList, val);
}
}
}
else
{
/* Read first key and first file offset. */
udcMustRead(bpt->udc, keyBuf, keySize);
bits64 lastFileOffset = udcReadBits64(bpt->udc, isSwapped);
bits64 fileOffset = lastFileOffset;
int lastCmp = memcmp(key, keyBuf, keySize);
/* Loop through remainder. */
for (i=1; i<childCount; ++i)
{
udcMustRead(bpt->udc, keyBuf, keySize);
fileOffset = udcReadBits64(bpt->udc, isSwapped);
int cmp = memcmp(key, keyBuf, keySize);
if (lastCmp >= 0 && cmp <= 0)
{
bits64 curPos = udcTell(bpt->udc);
rFindMulti(bpt, lastFileOffset, key, pList);
udcSeek(bpt->udc, curPos);
}
if (cmp < 0)
return;
lastCmp = cmp;
lastFileOffset = fileOffset;
}
/* If made it all the way to end, do last one too. */
rFindMulti(bpt, fileOffset, key, pList);
}
}
static void addRefWithContext(void *item, void *context)
/* Add item it itList. */
{
struct slRef **pList = context;
refAdd(pList, item);
}
static void addRef(void *item)
/* Add item it itList. */
{
refAdd(&itList, item);
}
static struct slRef *advancedSearchForTracks(struct sqlConnection *conn,struct group *groupList, char **descWords,int descWordCount, char *nameSearch, char *typeSearch, char *descSearch, char *groupSearch,
int numMetadataNonEmpty,int numMetadataSelects,char **mdbVar,char **mdbVal)
// Performs the advanced search and returns the found tracks.
{
int tracksFound = 0;
struct slRef *tracks = NULL;
if(!isEmpty(nameSearch) || typeSearch != NULL || descSearch != NULL || groupSearch != NULL || numMetadataNonEmpty)
{
// First do the metaDb searches, which can be done quickly for all tracks with db queries.
struct hash *matchingTracks = newHash(0);
struct slName *el, *metaTracks = NULL;
int i;
for(i = 0; i < numMetadataSelects; i++)
{
if(!isEmpty(mdbVal[i]))
{
#ifdef CV_SEARCH_SUPPORTS_FREETEXT
enum mdbCvSearchable searchBy = mdbCvSearchMethod(mdbVar[i]);
struct slName *tmp = NULL;
// If select is by free text then like
if (searchBy == cvsSearchByMultiSelect)
{
// TO BE IMPLEMENTED
// The mdbVal[1] will hve to be filled cartOptionalSlNameList(cart,???)
struct slName *choices = (struct slName *)mdbVal[i];
if (slCount(choices) == 1)
{
tmp = mdbObjSearch(conn, mdbVar[i], choices->name, "is", MDB_VAL_STD_TRUNCATION, TRUE, FALSE);
}
else if(choices != NULL)
{
// Then slNames will need to be assembled into a string in the form of 'a','b','c'
struct dyString *dyList = dyStringNew(256);
dyStringPrintf(dyList,"'%s'",choices->name);
struct slName *choice = choices->next;
for(;choice!=NULL;choice=choice->next)
dyStringPrintf(dyList,",'%s'",choice->name);
tmp = mdbObjSearch(conn, mdbVar[i], dyStringContents(dyList), "in", MDB_VAL_STD_TRUNCATION, TRUE, FALSE);
dyStringFree(&dyList);
}
}
else if (searchBy == cvsSearchBySingleSelect)
{
tmp = mdbObjSearch(conn, mdbVar[i], mdbVal[i], "is", MDB_VAL_STD_TRUNCATION, TRUE, FALSE);
}
else if (searchBy == cvsSearchByFreeText)
{
tmp = mdbObjSearch(conn, mdbVar[i], mdbVal[i], "like", MDB_VAL_STD_TRUNCATION, TRUE, FALSE);
}
else if (searchBy == cvsSearchByDateRange || searchBy == cvsSearchByIntegerRange)
{
// TO BE IMPLEMENTED
// Requires new mdbObjSearch API and more than one mdbVal[i]
}
if (tmp != NULL)
{
if(metaTracks == NULL)
metaTracks = tmp;
else
metaTracks = slNameIntersection(metaTracks, tmp);
}
#else///ifndif CV_SEARCH_SUPPORTS_FREETEXT
struct slName *tmp = mdbObjSearch(conn, mdbVar[i], mdbVal[i], "is", MDB_VAL_STD_TRUNCATION, TRUE, FALSE);
if(metaTracks == NULL)
metaTracks = tmp;
else
metaTracks = slNameIntersection(metaTracks, tmp);
#endif///ndef CV_SEARCH_SUPPORTS_FREETEXT
}
}
for (el = metaTracks; el != NULL; el = el->next)
hashAddInt(matchingTracks, el->name, 1);
struct group *group;
for (group = groupList; group != NULL; group = group->next)
{
if(groupSearch == NULL || sameString(group->name, groupSearch))
{
if (group->trackList != NULL)
{
struct trackRef *tr;
for (tr = group->trackList; tr != NULL; tr = tr->next)
{
struct track *track = tr->track;
#ifdef TRACK_SEARCH_ON_TYPE
char *trackType = cloneFirstWord(track->tdb->type); // will be spilled
#endif///def TRACK_SEARCH_ON_TYPE
if((isEmpty(nameSearch) || isNameMatch(track, nameSearch, "contains")) &&
#ifdef TRACK_SEARCH_ON_TYPE
(isEmpty(typeSearch) || (sameWord(typeSearch, trackType) && !tdbIsComposite(track->tdb))) &&
#endif///def TRACK_SEARCH_ON_TYPE
(isEmpty(descSearch) || isDescriptionMatch(track, descWords, descWordCount)) &&
(!numMetadataNonEmpty || hashLookup(matchingTracks, track->track) != NULL))
{
if (track != NULL)
{
tracksFound++;
refAdd(&tracks, track);
}
else
warn("found group track is NULL.");
}
if (track->subtracks != NULL)
{
struct track *subTrack;
for (subTrack = track->subtracks; subTrack != NULL; subTrack = subTrack->next)
{
#ifdef TRACK_SEARCH_ON_TYPE
trackType = cloneFirstWord(subTrack->tdb->type); // will be spilled
#endif///def TRACK_SEARCH_ON_TYPE
if((isEmpty(nameSearch) || isNameMatch(subTrack, nameSearch, "contains")) &&
#ifdef TRACK_SEARCH_ON_TYPE
(isEmpty(typeSearch) || sameWord(typeSearch, trackType)) &&
#endif///def TRACK_SEARCH_ON_TYPE
(isEmpty(descSearch) || isDescriptionMatch(subTrack, descWords, descWordCount)) &&
(!numMetadataNonEmpty || hashLookup(matchingTracks, subTrack->track) != NULL))
{
// XXXX to parent hash. - use tdb->parent instead.
//hashAdd(parents, subTrack->track, track);
if (track != NULL)
{
tracksFound++;
refAdd(&tracks, subTrack);
}
else
warn("found subtrack is NULL.");
}
}
}
}
}
}
}
}
return tracks;
}
static void multiWigDraw(struct track *tg, int seqStart, int seqEnd,
struct hvGfx *hvg, int xOff, int yOff, int width,
MgFont *font, Color color, enum trackVisibility vis)
/* Draw items in multiWig container. */
{
struct track *subtrack;
boolean errMsgShown = FALSE;
int y = yOff;
boolean errMsgFound = FALSE;
int numTracks = 0;
// determine if any subtracks had errors and count them up
for (subtrack = tg->subtracks; subtrack != NULL; subtrack = subtrack->next)
{
if (isSubtrackVisible(subtrack) )
{
numTracks++;
if (subtrack->networkErrMsg)
errMsgFound = TRUE;
}
}
if (errMsgFound)
{
Color yellow = hvGfxFindRgb(hvg, &undefinedYellowColor);
hvGfxBox(hvg, xOff, yOff, width, tg->height, yellow);
}
struct wigCartOptions *wigCart = tg->wigCartData;
struct wigGraphOutput *wgo = setUpWgo(xOff, yOff, width, tg->height, numTracks, wigCart, hvg);
// we want to the order to be the same in all the modes
if (wigCart->aggregateFunction == wiggleAggregateStacked)
slReverse(&tg->subtracks);
/* Cope with autoScale and stacked bars - we do it here rather than in the child tracks, so that
* all children can be on same scale. */
double minVal, maxVal;
/* Force load of all predraw arrays so can do calcs. Build up list, and then
* figure out max/min. No worries about multiple loading, the loaders protect
* themselves. */
struct slRef *refList = NULL;
for (subtrack = tg->subtracks; subtrack != NULL; subtrack = subtrack->next)
{
if (isSubtrackVisible(subtrack))
{
struct preDrawContainer *pre = subtrack->loadPreDraw(subtrack, seqStart, seqEnd, width);
if (pre != NULL) // pre maybe null if the load fails
{
preDrawWindowFunction(pre->preDraw, pre->preDrawSize, wigCart->windowingFunction,
wigCart->transformFunc, wigCart->doNegative);
preDrawSmoothing(pre->preDraw, pre->preDrawSize, wigCart->smoothingWindow);
pre->smoothingDone = TRUE;
refAdd(&refList, pre);
}
}
}
slReverse(&refList);
minMaxVals(refList, &minVal, &maxVal, wigCart->windowingFunction, wigCart->alwaysZero, wgo->yOffsets);
slFreeList(&refList);
if (!wigCart->autoScale)
{
minVal = wigCart->minY;
maxVal = wigCart->maxY;
}
/* Loop through again setting up the wigCarts of the children to have minY/maxY for
* our limits and autoScale off. */
for (subtrack = tg->subtracks; subtrack != NULL; subtrack = subtrack->next)
{
if (!isSubtrackVisible(subtrack))
continue;
struct wigCartOptions *wigCart = subtrack->wigCartData;
wigCart->minY = minVal;
wigCart->maxY = maxVal;
wigCart->autoScale = wiggleScaleManual;
struct preDrawContainer *pre = subtrack->preDrawContainer;
if (pre != NULL) // pre maybe null if the load fails
{
pre->graphUpperLimit = maxVal;
pre->graphLowerLimit = minVal;
}
}
int numTrack = 0;
for (subtrack = tg->subtracks; subtrack != NULL; subtrack = subtrack->next)
{
if (isSubtrackVisible(subtrack))
{
if (!subtrack->networkErrMsg || !errMsgShown)
{
if (subtrack->networkErrMsg)
errMsgShown = TRUE;
wgo->numTrack = numTrack++;
subtrack->wigGraphOutput = wgo;
int height = subtrack->totalHeight(subtrack, vis);
hvGfxSetClip(hvg, xOff, y, width, height);
if (wigCart->aggregateFunction != wiggleAggregateNone)
subtrack->lineHeight = tg->lineHeight;
subtrack->drawItems(subtrack, seqStart, seqEnd, hvg, xOff, y, width, font, color, vis);
if (wigCart->aggregateFunction == wiggleAggregateNone)
{
y += height + 1;
wgo->yOff = y;
}
hvGfxUnclip(hvg);
}
}
}
if (wigCart->aggregateFunction == wiggleAggregateTransparent)
{
floatPicIntoHvg(wgo->image, xOff, yOff, hvg);
floatPicFree((struct floatPic **)&wgo->image);
}
char *url = trackUrl(tg->track, chromName);
mapBoxHgcOrHgGene(hvg, seqStart, seqEnd, xOff, yOff, width, tg->height, tg->track, tg->track, NULL,
url, TRUE, NULL);
}
void txCdsRepick(char *inputBed, char *inputTxg, char *inputCluster,
char *inputInfo, char *inputCds, char *outputCds, char *outputPp)
/* txCdsRepick - After we have clustered based on the preliminary coding
* regions we can make a more intelligent choice here about the final coding
* regions. */
{
/* Read input bed into hash. Also calculate number with CDS set. */
struct hash *bedHash = hashNew(16);
struct bed *bed, *bedList = bedLoadNAll(inputBed, 12);
int txWithCdsCount = 0;
for (bed = bedList; bed != NULL; bed = bed->next)
{
if (bed->thickStart < bed->thickEnd)
txWithCdsCount += 1;
hashAdd(bedHash, bed->name, bed);
}
verbose(2, "Read %d beds from %s\n", bedHash->elCount, inputBed);
/* Read input transcript graphs into list, and into a hash
* keyed by transcript names. */
struct hash *graphHash = hashNew(16);
struct txGraph *txg, *txgList = txGraphLoadAll(inputTxg);
for (txg = txgList; txg != NULL; txg = txg->next)
{
int i;
for (i=0; i<txg->sourceCount; ++i)
hashAdd(graphHash, txg->sources[i].accession, txg);
}
verbose(2, "Read %d graphs (%d transcripts) from %s\n", slCount(txgList),
graphHash->elCount, inputTxg);
/* Read input protein cluster into list, and into a hash
* keyed by transcript name */
struct hash *clusterHash = hashNew(16);
struct txCluster *cluster, *clusterList = txClusterLoadAll(inputCluster);
for (cluster = clusterList; cluster != NULL; cluster = cluster->next)
{
int i;
for (i=0; i<cluster->txCount; ++i)
hashAdd(clusterHash, cluster->txArray[i], cluster);
}
verbose(2, "Read %d protein clusters (%d transcripts) from %s\n",
slCount(clusterList), clusterHash->elCount, inputCluster);
/* Read in txInfo into a hash keyed by transcript name */
struct hash *infoHash = hashNew(16);
struct txInfo *info, *infoList = txInfoLoadAll(inputInfo);
for (info = infoList; info != NULL; info = info->next)
hashAdd(infoHash, info->name, info);
verbose(2, "Read info on %d transcripts from %s\n", infoHash->elCount,
inputInfo);
/* Read in input cds evidence into a hash keyed by transcript name
* who's values are a sorted *list* of evidence. */
struct hash *evHash = hashNew(16);
struct cdsEvidence *ev, *nextEv, *evList = cdsEvidenceLoadAll(inputCds);
int evCount = 0;
for (ev = evList; ev != NULL; ev = nextEv)
{
nextEv = ev->next;
struct hashEl *hel = hashLookup(evHash, ev->name);
if (hel == NULL)
hel = hashAdd(evHash, ev->name, NULL);
slAddTail(&hel->val, ev);
++evCount;
}
verbose(2, "Read %d pieces of cdsEvidence on %d transcripts from %s\n",
evCount, evHash->elCount, inputCds);
/* Create a hash containing what looks to be the best protein-coding
* transcript in each protein cluster. This is keyed by cluster name
* with transcript names for values. */
FILE *f = mustOpen(outputPp, "w");
struct hash *bestInClusterHash = hashNew(16);
for (cluster = clusterList; cluster != NULL; cluster = cluster->next)
{
double bestScore = -BIGNUM;
char *bestTx = NULL;
int i;
for (i=0; i<cluster->txCount; ++i)
{
char *tx = cluster->txArray[i];
info = hashMustFindVal(infoHash, tx);
double score = infoCodingScore(info, TRUE);
if (score > bestScore)
{
bestTx = tx;
bestScore = score;
}
}
hashAdd(bestInClusterHash, cluster->name, bestTx);
fprintf(f, "%s\t%s\n", cluster->name, bestTx);
}
carefulClose(&f);
verbose(2, "Picked best protein for each protein cluster\n");
/* Loop through each transcript cluster (graph). Make a list of
* protein clusters associated with that graph. Armed with this
* information call repick routine on each transcript in the graph. */
f = mustOpen(outputCds, "w");
for (txg = txgList; txg != NULL; txg = txg->next)
{
/* Build up list of protein clusters associated with transcript cluster. */
struct slRef *protClusterRefList = NULL, *protClusterRef;
int i;
for (i=0; i<txg->sourceCount; ++i)
{
char *tx = txg->sources[i].accession;
struct txCluster *protCluster = hashFindVal(clusterHash, tx);
if (protCluster != NULL)
refAddUnique(&protClusterRefList, protCluster);
}
/* Figure out best scoring protein in RNA cluster, and set threshold
* to eliminate ones scoring less than half this much. */
double bestProtScore = 0;
for (protClusterRef = protClusterRefList; protClusterRef != NULL;
protClusterRef = protClusterRef->next)
{
struct txCluster *protCluster = protClusterRef->val;
char *protTx = hashMustFindVal(bestInClusterHash, protCluster->name);
struct txInfo *info = hashMustFindVal(infoHash, protTx);
double score = infoCodingScore(info, FALSE);
bestProtScore = max(score, bestProtScore);
}
double protScoreThreshold = bestProtScore * 0.5;
/* Get list of references to beds of proteins over that threshold. */
struct slRef *protRefList = NULL;
for (protClusterRef = protClusterRefList; protClusterRef != NULL;
protClusterRef = protClusterRef->next)
{
struct txCluster *protCluster = protClusterRef->val;
char *protTx = hashMustFindVal(bestInClusterHash, protCluster->name);
struct txInfo *info = hashMustFindVal(infoHash, protTx);
double score = infoCodingScore(info, FALSE);
if (score >= protScoreThreshold)
{
struct bed *bed = hashMustFindVal(bedHash, protTx);
refAdd(&protRefList, bed);
}
}
/* Go repick each CDS in RNA cluster */
for (i=0; i<txg->sourceCount; ++i)
{
char *tx = txg->sources[i].accession;
struct bed *bed = hashMustFindVal(bedHash, tx);
struct cdsEvidence *evList = hashFindVal(evHash, tx);
if (evList != NULL && bed->thickStart < bed->thickEnd)
{
info = hashMustFindVal(infoHash, bed->name);
pickCompatableCds(bed, protRefList, evList, info, f);
}
}
slFreeList(&protClusterRefList);
}
carefulClose(&f);
verbose(1, "repicked %d, removed %d, no change to %d\n",
pickedBetter, pickedNone, txWithCdsCount - pickedBetter - pickedNone);
}
void fsAdd(void *item)
/* Add item to fsList. */
{
refAdd(&fsList, item);
}
