void edwMetaManiToTdb(char *metaInput, char *manifestInput, char *varCommaList, char *tdbOutput)
/* edwMetaManiToTdb - Create a trackDb file based on input from meta file and manifest file.. */
{
struct encode2Manifest *manList = encode2ManifestShortLoadAll(manifestInput);
struct meta *metaForest = metaLoadAll(metaInput, "meta", "parent", TRUE, FALSE);
struct slName *varList = slNameListFromComma(varCommaList);
struct hash *hash = metaHash(metaForest);
struct composite *comp, *compList = makeCompositeList(manList, hash);
uglyf("%d elements in manList, %d in metaForest top level, %d total, %d vars, %d composites\n", slCount(manList), slCount(metaForest), hash->elCount, slCount(varList), slCount(compList));
FILE *f = mustOpen(tdbOutput, "w");
for (comp = compList; comp != NULL; comp = comp->next)
{
outputComposite(comp, varList, hash, f);
}
carefulClose(&f);
}
void encode2Meta(char *database, char *manifestIn, char *outMetaRa)
/* encode2Meta - Create meta files.. */
{
int dbIx = stringArrayIx(database, metaDbs, ArraySize(metaDbs));
if (dbIx < 0)
errAbort("Unrecognized database %s", database);
/* Create a three level meta.ra format file based on hgFixed.encodeExp
* and database.metaDb tables. The levels are composite, experiment, file */
struct metaNode *metaTree = metaTreeNew("encode2");
/* Load up the manifest. */
struct encode2Manifest *mi, *miList = encode2ManifestShortLoadAll(manifestIn);
struct hash *miHash = hashNew(18);
for (mi = miList; mi != NULL; mi = mi->next)
hashAdd(miHash, mi->fileName, mi);
verbose(1, "%d files in %s\n", miHash->elCount, manifestIn);
/* Load up encodeExp info. */
struct sqlConnection *expConn = sqlConnect(expDb);
struct encodeExp *expList = encodeExpLoadByQuery(expConn, "NOSQLINJ select * from encodeExp");
sqlDisconnect(&expConn);
verbose(1, "%d experiments in encodeExp\n", slCount(expList));
struct hash *compositeHash = hashNew(0);
/* Go through each organism database in turn. */
int i;
for (i=0; i<ArraySize(metaDbs); ++i)
{
char *db = metaDbs[i];
if (!sameString(database, db))
continue;
verbose(1, "exploring %s\n", db);
struct mdbObj *mdb, *mdbList = getMdbList(db);
verbose(1, "%d meta objects in %s\n", slCount(mdbList), db);
/* Get info on all composites. */
for (mdb = mdbList; mdb != NULL; mdb = mdb->next)
{
char *objType = mdbVarLookup(mdb->vars, "objType");
if (objType != NULL && sameString(objType, "composite"))
{
char compositeName[256];
safef(compositeName, sizeof(compositeName), "%s", mdb->obj);
struct metaNode *compositeNode = metaNodeNew(compositeName);
slAddHead(&metaTree->children, compositeNode);
compositeNode->parent = metaTree;
struct mdbVar *v;
for (v=mdb->vars; v != NULL; v = v->next)
{
metaNodeAddVar(compositeNode, v->var, v->val);
}
metaNodeAddVar(compositeNode, "assembly", db);
hashAdd(compositeHash, mdb->obj, compositeNode);
}
}
/* Make up one more for experiments with no composite. */
char *noCompositeName = "wgEncodeZz";
struct metaNode *noCompositeNode = metaNodeNew(noCompositeName);
slAddHead(&metaTree->children, noCompositeNode);
noCompositeNode->parent = metaTree;
hashAdd(compositeHash, noCompositeName, noCompositeNode);
/* Now go through objects trying to tie experiments to composites. */
struct hash *expToComposite = hashNew(16);
for (mdb = mdbList; mdb != NULL; mdb = mdb->next)
{
char *composite = mdbVarLookup(mdb->vars, "composite");
if (originalData(composite))
{
char *dccAccession = mdbVarLookup(mdb->vars, "dccAccession");
if (dccAccession != NULL)
{
char *oldComposite = hashFindVal(expToComposite, dccAccession);
if (oldComposite != NULL)
{
if (!sameString(oldComposite, composite))
verbose(2, "%s maps to %s ignoring mapping to %s", dccAccession, oldComposite, composite);
}
else
{
hashAdd(expToComposite, dccAccession, composite);
}
}
}
}
/* Now get info on all experiments in this organism. */
struct hash *expHash = hashNew(0);
struct encodeExp *exp;
for (exp = expList; exp != NULL; exp = exp->next)
{
if (sameString(exp->organism, organisms[i]))
{
if (exp->accession != NULL)
{
char *composite = hashFindVal(expToComposite, exp->accession);
struct metaNode *compositeNode;
if (composite != NULL)
{
compositeNode = hashMustFindVal(compositeHash, composite);
}
else
{
compositeNode = noCompositeNode;
}
struct metaNode *expNode = wrapNodeAroundExp(exp);
hashAdd(expHash, expNode->name, expNode);
slAddHead(&compositeNode->children, expNode);
expNode->parent = compositeNode;
}
}
}
for (mdb = mdbList; mdb != NULL; mdb = mdb->next)
{
char *fileName = NULL, *dccAccession = NULL;
char *objType = mdbVarLookup(mdb->vars, "objType");
if (objType != NULL && sameString(objType, "composite"))
continue;
dccAccession = mdbVarLookup(mdb->vars, "dccAccession");
if (dccAccession == NULL)
continue;
char *composite = hashFindVal(expToComposite, dccAccession);
if (composite == NULL)
errAbort("Can't find composite for %s", mdb->obj);
struct mdbVar *v;
for (v = mdb->vars; v != NULL; v = v->next)
{
char *var = v->var, *val = v->val;
if (sameString("fileName", var))
{
fileName = val;
char path[PATH_LEN];
char *comma = strchr(fileName, ',');
if (comma != NULL)
*comma = 0; /* Cut off comma separated list. */
safef(path, sizeof(path), "%s/%s/%s", db,
composite, fileName); /* Add database path */
fileName = val = v->val = cloneString(path);
}
}
if (fileName != NULL)
{
if (hashLookup(miHash, fileName))
{
struct metaNode *expNode = hashFindVal(expHash, dccAccession);
if (expNode != NULL)
{
struct metaNode *fileNode = metaNodeNew(mdb->obj);
slAddHead(&expNode->children, fileNode);
fileNode->parent = expNode;
struct mdbVar *v;
for (v=mdb->vars; v != NULL; v = v->next)
{
metaNodeAddVar(fileNode, v->var, v->val);
}
}
}
}
}
#ifdef SOON
#endif /* SOON */
}
struct hash *suppress = makeSuppress();
struct hash *closeEnoughTags = makeCloseEnoughTags();
metaTreeHoist(metaTree, closeEnoughTags);
metaTreeSortChildrenSortTags(metaTree);
FILE *f = mustOpen(outMetaRa, "w");
struct metaNode *node;
for (node = metaTree->children; node != NULL; node = node->next)
metaTreeWrite(0, 0, BIGNUM, FALSE, NULL, node, suppress, f);
carefulClose(&f);
/* Write warning about tags in highest parent. */
struct mdbVar *v;
for (v = metaTree->vars; v != NULL; v = v->next)
verbose(1, "Omitting universal %s %s\n", v->var, v->val);
}
void encode2MakeEncode3(char *sourceDir, char *sourceManifest, char *destDir, char *outMake,
char *outManifest, char *outRename)
/* encode2MakeEncode3 - Copy files in encode2 manifest and in case of tar'd files rezip them
* independently. */
{
struct encode2Manifest *fileList = encode2ManifestShortLoadAll(sourceManifest);
verbose(2, "Loaded information on %d files from %s\n", slCount(fileList), sourceManifest);
verboseTimeInit();
FILE *f = mustOpen(outMake, "w");
FILE *manF = mustOpen(outManifest, "w");
FILE *renameF = mustOpen(outRename, "w");
struct encode2Manifest *mi;
int destDirPrefixSize = strlen(destDir)+1; /* +1 for / */
struct hash *destDirHash = hashNew(0);
makeDirOnlyOnce(destDir, destDirHash);
/* Print first dependency in makefile - the one that causes all files to be made. */
fprintf(f, "startHere: all\n\techo all done\n\n");
/* Write out each file target, and save also list of all targets. */
struct slName *targetList = NULL;
int itemNo = 0;
for (mi = fileList; mi != NULL; mi = mi->next)
{
char *origFileName = cloneString(mi->fileName);
/* Keep a list of what all it goes to. */
struct slName *oneTargetList = NULL;
/* Make path to source file. */
char sourcePath[PATH_LEN];
safef(sourcePath, sizeof(sourcePath), "%s/%s", sourceDir, mi->fileName);
/* Make destination dir */
char localDir[PATH_LEN];
splitPath(mi->fileName, localDir, NULL, NULL);
char destSubDir[PATH_LEN];
safef(destSubDir, sizeof(destSubDir), "%s/%s", destDir, localDir);
makeDirOnlyOnce(destSubDir, destDirHash);
char destPath[PATH_LEN];
safef(destPath, sizeof(destPath), "%s/%s", destDir, mi->fileName);
processManifestItem(++itemNo, mi, sourceDir, destDir, &oneTargetList, f, manF);
/* Write out rename info. */
if (oneTargetList != NULL)
{
if (oneTargetList->next != NULL || !sameString(origFileName, oneTargetList->name + destDirPrefixSize))
{
fprintf(renameF, "%s", origFileName);
struct slName *target;
for (target = oneTargetList; target != NULL; target = target->next)
{
fprintf(renameF, " %s", target->name + destDirPrefixSize);
}
fprintf(renameF, "\n");
}
}
/* Save local target list to big one. */
targetList = slCat(oneTargetList, targetList);
}
slReverse(&targetList);
fprintf(f, "all:");
struct slName *target;
for (target = targetList; target != NULL; target = target->next)
fprintf(f, " %s", target->name);
fprintf(f, "\n");
carefulClose(&renameF);
carefulClose(&manF);
carefulClose(&f);
}
