static struct trackDb * pruneOrphans(struct trackDb *tdbList, struct hash *trackHash)
/* Prune out orphans with no parents of the right release */
{
boolean done = FALSE;
struct trackDb *tdb;
struct trackDb *nonOrphanList = NULL;
while (!done)
{
done = TRUE;
nonOrphanList = NULL;
while ((tdb = slPopHead(&tdbList)) != NULL)
{
char *parentName = cloneFirstWord(trackDbLocalSetting(tdb, "parent"));
struct hashEl *hel = NULL;
if (parentName != NULL)
{
hel = hashLookup(trackHash, parentName);
}
if (parentName == NULL || hel != NULL)
{
slAddHead(&nonOrphanList, tdb);
}
else
{
verbose(3,"pruneOrphans: removing '%s'\n",
tdb->track);
hashRemove(trackHash, tdb->track);
done = FALSE;
}
freeMem(parentName);
}
tdbList = nonOrphanList;
}
return tdbList;
}
void printBiggestGap(char *database, struct sqlConnection *conn,
struct slName *chromList, struct hash *chromHash, char *track)
/* Look up track in database, figure out which type it is, call
* appropriate biggest gap finder, and then print result. */
{
struct trackDb *tdb = hTrackInfo(conn, track);
struct hTableInfo *hti = hFindTableInfo(database, chromList->name, tdb->table);
char *typeWord = cloneFirstWord(tdb->type);
boolean isBig = FALSE, isBigBed = FALSE;
struct bbiFile *bbi = NULL;
if (sameString(typeWord, "bigBed"))
{
isBig = TRUE;
isBigBed = TRUE;
bbi = bigBedFileOpen( bbiNameFromSettingOrTable(tdb, conn, tdb->table) );
}
else if (sameString(typeWord, "bigWig"))
{
isBig = TRUE;
bbi = bigWigFileOpen( bbiNameFromSettingOrTable(tdb, conn, tdb->table) );
}
char *biggestChrom = NULL;
int biggestSize = 0, biggestStart = 0, biggestEnd = 0;
struct slName *chrom;
for (chrom = chromList; chrom != NULL; chrom = chrom->next)
{
if (!allParts && strchr(chrom->name, '_')) // Generally skip weird chroms
continue;
if (female && sameString(chrom->name, "chrY"))
continue;
int chromSize = hashIntVal(chromHash, chrom->name);
struct rbTree *rt = rangeTreeNew();
int start = 0, end = 0, size = 0;
if (isBig)
bigCoverageIntoTree(tdb, bbi, chrom->name, chromSize, rt, isBigBed);
else
tableCoverageIntoTree(hti, tdb, conn, chrom->name, chromSize, rt);
if (rt->n > 0) // Want to keep completely uncovered chromosome uncovered
addGaps(conn, chrom->name, rt);
biggestGapFromRangeTree(rt, chromSize, &start, &end, &size);
if (size > biggestSize)
{
biggestSize = size;
biggestStart = start;
biggestEnd = end;
biggestChrom = chrom->name;
}
rangeTreeFree(&rt);
}
printf("%s\t%s:%d-%d\t", track, biggestChrom, biggestStart+1, biggestEnd);
if (noComma)
printf("%d", biggestSize);
else
printLongWithCommas(stdout, biggestSize);
putchar('\n');
freez(&typeWord);
bbiFileClose(&bbi);
}
static void extractRedirections(char *strLine, cmdLine *pCmdLine)
{
char *s = strLine;
while ( (s = strpbrk(s,"<>")) ) {
if (*s == '<') {
FREE(pCmdLine->inputRedirect);
pCmdLine->inputRedirect = cloneFirstWord(s+1);
}
else {
FREE(pCmdLine->outputRedirect);
pCmdLine->outputRedirect = cloneFirstWord(s+1);
}
*s++ = 0;
}
}
static void getVocab(struct trackDb *tdb, struct cart *cart,
char **vocabFile, struct hash **vocabHash)
/* Get vocabulary info from trackDb settings (CV or vocab tables) */
{
char *file = NULL;
struct hash *hash = NULL;
char *vocab = trackDbSetting(tdb, "controlledVocabulary");
if (vocabSettingIsEncode(vocab))
{
file = cloneFirstWord(vocab);
hash = getVocabHash(file);
}
else
{
hash = vocabBasicFromSetting(tdb, cart);
}
if (vocabFile != NULL)
*vocabFile = file;
if (hash != NULL)
*vocabHash = hash;
}
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;
}
void doFactorSource(struct sqlConnection *conn, struct trackDb *tdb, char *item, int start, int end)
/* Display detailed info about a cluster of TFBS peaks from other tracks. */
{
char extraWhere[256];
safef(extraWhere, sizeof extraWhere, "name='%s'", item);
int rowOffset;
struct sqlResult *sr = hRangeQuery(conn, tdb->table, seqName, start, end, extraWhere, &rowOffset);
char **row = sqlNextRow(sr);
struct factorSource *cluster = NULL;
if (row != NULL)
cluster = factorSourceLoad(row + rowOffset);
sqlFreeResult(&sr);
if (cluster == NULL)
errAbort("Error loading cluster from track %s", tdb->track);
char *sourceTable = trackDbRequiredSetting(tdb, "sourceTable");
char *factorLink = cluster->name;
char *vocab = trackDbSetting(tdb, "controlledVocabulary");
if (vocab != NULL)
{
char *file = cloneFirstWord(vocab);
factorLink = wgEncodeVocabLink(file, "term", factorLink, factorLink, factorLink, "");
}
printf("<B>Factor:</B> %s<BR>\n", factorLink);
printf("<B>Cluster Score (out of 1000):</B> %d<BR>\n", cluster->score);
printPos(cluster->chrom, cluster->chromStart, cluster->chromEnd, NULL, TRUE, item);
/* Get list of tracks we'll look through for input. */
char *inputTrackTable = trackDbRequiredSetting(tdb, "inputTrackTable");
char query[256];
sqlSafef(query, sizeof(query), "select tableName from %s where factor='%s' order by source",
inputTrackTable,
cluster->name);
/* Next do the lists of hits and misses. We have the hits from the non-zero signals in
* cluster->expScores. We need to figure out the sources actually assayed though
* some other way. We'll do this by one of two techniques. */
char *inputTableFieldDisplay = trackDbSetting(tdb, "inputTableFieldDisplay");
if (inputTableFieldDisplay != NULL)
{
struct slName *fieldList = stringToSlNames(inputTableFieldDisplay);
char *vocab = trackDbSetting(tdb, "controlledVocabulary");
/* In a new section put up list of hits. */
webNewSection("Assays for %s in Cluster", cluster->name);
webPrintLinkTableStart();
printClusterTableHeader(fieldList, TRUE, FALSE, TRUE);
printFactorSourceTableHits(cluster, conn, sourceTable,
inputTrackTable, fieldList, FALSE, vocab);
webPrintLinkTableEnd();
webNewSectionHeaderStart();
char sectionTitle[128];
safef(sectionTitle,
sizeof(sectionTitle),"Assays for %s Without Hits in Cluster", cluster->name);
jsBeginCollapsibleSectionOldStyle(cart, tdb->track, "cellNoHits", sectionTitle, FALSE);
webNewSectionHeaderEnd();
webPrintLinkTableStart();
printClusterTableHeader(fieldList, TRUE, FALSE, FALSE);
printFactorSourceTableHits(cluster, conn, sourceTable,
inputTrackTable, fieldList, TRUE, vocab);
webPrintLinkTableEnd();
jsEndCollapsibleSection();
}
else
{
errAbort("Missing required trackDb setting %s for track %s",
"inputTableFieldDisplay", tdb->track);
}
webNewSectionHeaderStart();
jsBeginCollapsibleSectionOldStyle(cart, tdb->track, "cellSources", "Cell Abbreviations", FALSE);
webNewSectionHeaderEnd();
hPrintFactorSourceAbbrevTable(conn, tdb);
jsEndCollapsibleSection();
doClusterMotifDetails(conn, tdb, cluster);
}
static void printFactorSourceTableHits(struct factorSource *cluster, struct sqlConnection *conn,
char *sourceTable, char *inputTrackTable,
struct slName *fieldList, boolean invert, char *vocab)
/* Put out a lines in an html table that shows assayed sources that have hits in this
* cluster, or if invert is set, that have misses. */
{
char *vocabFile = NULL;
if (vocab)
{
vocabFile = cloneFirstWord(vocab);
}
/* Make the monster SQL query to get all assays*/
struct dyString *query = dyStringNew(0);
sqlDyStringPrintf(query, "select %s.id,%s.name,%s.tableName", sourceTable, sourceTable,
inputTrackTable);
struct slName *field;
for (field = fieldList; field != NULL; field = field->next)
sqlDyStringPrintf(query, ",%s.%s", inputTrackTable, field->name);
sqlDyStringPrintf(query, " from %s,%s ", inputTrackTable, sourceTable);
sqlDyStringPrintf(query, " where %s.source = %s.description", inputTrackTable, sourceTable);
sqlDyStringPrintf(query, " and factor='%s' order by %s.source", cluster->name, inputTrackTable);
boolean encodeStanford = FALSE;
if (startsWith("encode3", sourceTable) || startsWith("encode4", sourceTable))
encodeStanford = TRUE;
int displayNo = 0;
int fieldCount = slCount(fieldList);
struct sqlResult *sr = sqlGetResult(conn, query->string);
char **row;
while ((row = sqlNextRow(sr)) != NULL)
{
int sourceId = sqlUnsigned(row[0]);
boolean hit = FALSE;
int i;
double signal = 0.0;
for (i=0; i<cluster->expCount; i++)
{
if (cluster->expNums[i] == sourceId)
{
hit = TRUE;
signal = cluster->expScores[i];
break;
}
}
if (hit ^ invert)
{
printf("</TR><TR>\n");
webPrintIntCell(++displayNo);
if (!invert)
webPrintDoubleCell(signal);
webPrintLinkCell(row[1]);
int i = 0;
// find position of CV metadata in field list
int offset = 3;
struct slName *field = fieldList;
for (i=0; i<fieldCount && field != NULL; ++i, field = field->next)
{
char *fieldVal = row[i+offset];
if (vocab)
{
char *link = cloneString(factorSourceVocabLink(vocabFile, field->name, fieldVal));
webPrintLinkCell(link);
}
else
webPrintLinkCell(fieldVal);
}
char *table = row[2];
if (encodeStanford)
{
char *file = stringIn("ENCFF", table);
if (!file)
webPrintLinkCell(table);
else
{
webPrintLinkCellStart();
printf("<A target='_blank'"
"href='https://www.encodeproject.org/files/%s'>%s</A>", file, file);
webPrintLinkCellEnd();
}
}
else
printMetadataForTable(table);
}
}
sqlFreeResult(&sr);
freez(&vocabFile);
dyStringFree(&query);
}
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;
}
