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); }