static void getMaximalHaplotypePathsCheck(Flower *flower,
stSortedSet *segmentSet, const char *eventString, stList *eventStrings) {
/*
* Do debug checks that the haplotypes paths are well formed.
*/
Flower_SegmentIterator *segmentIt = flower_getSegmentIterator(flower);
Segment *segment;
while ((segment = flower_getNextSegment(segmentIt)) != NULL) {
if (strcmp(event_getHeader(segment_getEvent(segment)), eventString) == 0) {
if (hasCapInEvents(cap_getEnd(segment_get5Cap(segment)), eventStrings)) { //isHaplotypeEnd(cap_getEnd(segment_get5Cap(segment)))) {
assert(stSortedSet_search(segmentSet, segment) != NULL
|| stSortedSet_search(segmentSet, segment_getReverse(
segment)) != NULL);
}
}
}
flower_destructSegmentIterator(segmentIt);
Flower_GroupIterator *groupIt = flower_getGroupIterator(flower);
Group *group;
while ((group = flower_getNextGroup(groupIt)) != NULL) {
if (group_getNestedFlower(group) != NULL) {
getMaximalHaplotypePathsCheck(group_getNestedFlower(group),
segmentSet, eventString, eventStrings);
}
}
flower_destructGroupIterator(groupIt);
}
void flower_check(Flower *flower) {
eventTree_check(flower_getEventTree(flower));
Flower_GroupIterator *groupIterator = flower_getGroupIterator(flower);
Group *group;
while ((group = flower_getNextGroup(groupIterator)) != NULL) {
group_check(group);
}
flower_destructGroupIterator(groupIterator);
Flower_ChainIterator *chainIterator = flower_getChainIterator(flower);
Chain *chain;
while ((chain = flower_getNextChain(chainIterator)) != NULL) {
chain_check(chain);
}
flower_destructCapIterator(chainIterator);
//We check built trees in here.
Flower_EndIterator *endIterator = flower_getEndIterator(flower);
End *end;
while ((end = flower_getNextEnd(endIterator)) != NULL) {
end_check(end);
end_check(end_getReverse(end)); //We will test everything backwards also.
}
flower_destructEndIterator(endIterator);
if (flower_builtFaces(flower)) {
Flower_FaceIterator *faceIterator = flower_getFaceIterator(flower);
Face *face;
while ((face = flower_getNextFace(faceIterator)) != NULL) {
face_check(face);
}
flower_destructFaceIterator(faceIterator);
face_checkFaces(flower);
} else {
cactusCheck(flower_getFaceNumber(flower) == 0);
}
if (flower_builtBlocks(flower)) { //Note that a flower for which the blocks are not yet built must be a leaf.
Flower_BlockIterator *blockIterator = flower_getBlockIterator(flower);
Block *block;
while ((block = flower_getNextBlock(blockIterator)) != NULL) {
block_check(block);
block_check(block_getReverse(block)); //We will test everything backwards also.
}
flower_destructBlockIterator(blockIterator);
} else {
cactusCheck(flower_isLeaf(flower)); //Defensive
cactusCheck(flower_isTerminal(flower)); //Checks that a flower without built blocks is a leaf and does not
//contain any blocks.
}
Flower_SequenceIterator *sequenceIterator = flower_getSequenceIterator(flower);
Sequence *sequence;
while ((sequence = flower_getNextSequence(sequenceIterator)) != NULL) {
sequence_check(sequence);
}
flower_destructSequenceIterator(sequenceIterator);
}
void flower_destruct(Flower *flower, int64_t recursive) {
Flower_GroupIterator *iterator;
Sequence *sequence;
End *end;
Block *block;
Group *group;
Chain *chain;
Flower *nestedFlower;
if (recursive) {
iterator = flower_getGroupIterator(flower);
while ((group = flower_getNextGroup(iterator)) != NULL) {
nestedFlower = group_getNestedFlower(group);
if (nestedFlower != NULL) {
flower_destruct(nestedFlower, recursive);
}
}
flower_destructGroupIterator(iterator);
}
cactusDisk_removeFlower(flower->cactusDisk, flower);
flower_destructFaces(flower);
stSortedSet_destruct(flower->faces);
assert(flower_getEventTree(flower) != NULL);
eventTree_destruct(flower_getEventTree(flower));
while ((sequence = flower_getFirstSequence(flower)) != NULL) {
sequence_destruct(sequence);
}
stSortedSet_destruct(flower->sequences);
while ((chain = flower_getFirstChain(flower)) != NULL) {
chain_destruct(chain);
}
stSortedSet_destruct(flower->chains);
while ((end = flower_getFirstEnd(flower)) != NULL) {
end_destruct(end);
}
stSortedSet_destruct(flower->caps);
stSortedSet_destruct(flower->ends);
while ((block = flower_getFirstBlock(flower)) != NULL) {
block_destruct(block);
}
stSortedSet_destruct(flower->segments);
stSortedSet_destruct(flower->blocks);
while ((group = flower_getFirstGroup(flower)) != NULL) {
group_destruct(group);
}
stSortedSet_destruct(flower->groups);
free(flower);
}
void flower_writeBinaryRepresentation(Flower *flower, void(*writeFn)(const void * ptr, size_t size, size_t count)) {
Flower_SequenceIterator *sequenceIterator;
Flower_EndIterator *endIterator;
Flower_BlockIterator *blockIterator;
Flower_GroupIterator *groupIterator;
Flower_ChainIterator *chainIterator;
Sequence *sequence;
End *end;
Block *block;
Group *group;
Chain *chain;
binaryRepresentation_writeElementType(CODE_FLOWER, writeFn);
binaryRepresentation_writeName(flower_getName(flower), writeFn);
binaryRepresentation_writeBool(flower_builtBlocks(flower), writeFn);
binaryRepresentation_writeBool(flower_builtTrees(flower), writeFn);
binaryRepresentation_writeBool(flower_builtFaces(flower), writeFn);
binaryRepresentation_writeName(flower->parentFlowerName, writeFn);
if (flower_getEventTree(flower) != NULL) {
eventTree_writeBinaryRepresentation(flower_getEventTree(flower), writeFn);
}
sequenceIterator = flower_getSequenceIterator(flower);
while ((sequence = flower_getNextSequence(sequenceIterator)) != NULL) {
sequence_writeBinaryRepresentation(sequence, writeFn);
}
flower_destructSequenceIterator(sequenceIterator);
endIterator = flower_getEndIterator(flower);
while ((end = flower_getNextEnd(endIterator)) != NULL) {
end_writeBinaryRepresentation(end, writeFn);
}
flower_destructEndIterator(endIterator);
blockIterator = flower_getBlockIterator(flower);
while ((block = flower_getNextBlock(blockIterator)) != NULL) {
block_writeBinaryRepresentation(block, writeFn);
}
flower_destructBlockIterator(blockIterator);
groupIterator = flower_getGroupIterator(flower);
while ((group = flower_getNextGroup(groupIterator)) != NULL) {
group_writeBinaryRepresentation(group, writeFn);
}
flower_destructGroupIterator(groupIterator);
chainIterator = flower_getChainIterator(flower);
while ((chain = flower_getNextChain(chainIterator)) != NULL) {
chain_writeBinaryRepresentation(chain, writeFn);
}
flower_destructChainIterator(chainIterator);
binaryRepresentation_writeElementType(CODE_FLOWER, writeFn); //this avoids interpretting things wrong.
}
void flower_checkRecursive(Flower *flower) {
flower_check(flower);
Flower_GroupIterator *groupIt = flower_getGroupIterator(flower);
Group *group;
while ((group = flower_getNextGroup(groupIt)) != NULL) {
if (!group_isLeaf(group)) {
flower_checkRecursive(group_getNestedFlower(group));
}
}
flower_destructGroupIterator(groupIt);
}
bool flower_isLeaf(Flower *flower) {
Group *group;
Flower_GroupIterator *iterator = flower_getGroupIterator(flower);
while ((group = flower_getNextGroup(iterator)) != NULL) {
if (!group_isLeaf(group)) {
flower_destructGroupIterator(iterator);
return 0;
}
}
flower_destructGroupIterator(iterator);
return 1;
}
bool flower_removeIfRedundant(Flower *flower) {
if (!flower_isLeaf(flower) && flower_getParentGroup(flower) != NULL && flower_getBlockNumber(flower) == 0) { //We will remove this flower..
Group *parentGroup = flower_getParentGroup(flower); //This group will be destructed
//Deal with any parent chain..
if (group_isLink(parentGroup)) {
link_split(group_getLink(parentGroup));
}
Flower *parentFlower = group_getFlower(parentGroup); //We will add the groups in the flower to the parent
/*
* For each group in the flower we take its nested flower and attach it to the parent.
*/
Group *group;
Flower_GroupIterator *groupIt = flower_getGroupIterator(flower);
while ((group = flower_getNextGroup(groupIt)) != NULL) {
if (!group_isLeaf(group)) {
//Copy the group into the parent..
Flower *nestedFlower = group_getNestedFlower(group);
assert(nestedFlower != NULL);
Group *newParentGroup = group_construct(parentFlower, nestedFlower);
flower_setParentGroup(nestedFlower, newParentGroup);
group_constructChainForLink(newParentGroup);
} else {
Group *newParentGroup = group_construct2(parentFlower);
End *end;
Group_EndIterator *endIt = group_getEndIterator(group);
while ((end = group_getNextEnd(endIt)) != NULL) {
End *parentEnd = flower_getEnd(parentFlower, end_getName(end));
assert(parentEnd != NULL);
end_setGroup(parentEnd, newParentGroup);
}
group_destructEndIterator(endIt);
group_constructChainForLink(newParentGroup);
}
}
flower_destructGroupIterator(groupIt);
//The group attached to the flower should now be empty
assert(group_getEndNumber(parentGroup) == 0);
group_destruct(parentGroup);
//Now wipe the flower out..
cactusDisk_deleteFlowerFromDisk(flower_getCactusDisk(flower), flower);
flower_destruct(flower, 0);
return 1;
}
return 0;
}
void flower_makeTerminalNormal(Flower *flower) {
if (!flower_isTerminal(flower)) {
Flower_GroupIterator *groupIterator;
Group *group;
groupIterator = flower_getGroupIterator(flower);
while ((group = flower_getNextGroup(groupIterator)) != NULL) {
if (group_isLeaf(group)) {
//assert(group_getTotalBaseLength(group) == 0);
Flower *nestedFlower = group_makeNestedFlower(group);
flower_setBuiltBlocks(nestedFlower, flower_builtBlocks(flower));
flower_setBuiltTrees(nestedFlower, flower_builtTrees(flower));
flower_setBuildFaces(nestedFlower, flower_builtFaces(flower));
}
}
flower_destructGroupIterator(groupIterator);
}
}
void flower_delete2(Flower *flower, bool isOnDisk) {
Flower_GroupIterator *groupIt = flower_getGroupIterator(flower);
Group *group;
while ((group = flower_getNextGroup(groupIt)) != NULL) {
if (!group_isLeaf(group)) {
flower_delete2(group_getNestedFlower(group), isOnDisk);
}
}
flower_destructGroupIterator(groupIt);
Group *parentGroup = flower_getParentGroup(flower);
if(parentGroup != NULL) {
parentGroup->leafGroup = 1;
}
//This needs modification so that we don't do this directly..
if(isOnDisk) {
cactusDisk_deleteFlowerFromDisk(flower_getCactusDisk(flower), flower);
}
flower_destruct(flower, 0);
}
void flower_checkNotEmpty(Flower *flower, bool recursive) {
//First check the flower is not empty, unless it is the parent group.
if (flower_hasParentGroup(flower)) {
assert(flower_getGroupNumber(flower) > 0);
assert(flower_getEndNumber(flower) > 0);
assert(flower_getAttachedStubEndNumber(flower) > 0); //We must have some ends to tie us into the parent problem + flower_getBlockEndNumber(flower) > 0);
}
//Now Checks that each group contains at least one end and call recursive.
Group *group;
Flower_GroupIterator *groupIt = flower_getGroupIterator(flower);
while ((group = flower_getNextGroup(groupIt)) != NULL) {
assert(group_getEndNumber(group) > 0);
assert(group_getAttachedStubEndNumber(group) + group_getBlockEndNumber(group) > 0);
if (recursive && !group_isLeaf(group)) {
flower_checkNotEmpty(group_getNestedFlower(group), 1);
}
}
flower_destructGroupIterator(groupIt);
}
static void getMaximalHaplotypePathsP(Flower *flower,
stList *maximalHaplotypePaths, stSortedSet *segmentSet,
const char *eventString,
stList *eventStrings) {
/*
* Iterate through the segments in this flower.
*/
Flower_SegmentIterator *segmentIt = flower_getSegmentIterator(flower);
Segment *segment;
while ((segment = flower_getNextSegment(segmentIt)) != NULL) {
if (stSortedSet_search(segmentSet, segment) == NULL
&& stSortedSet_search(segmentSet, segment_getReverse(segment))
== NULL) { //Check we haven't yet seen this segment
if (strcmp(event_getHeader(segment_getEvent(segment)), eventString)
== 0) { //Check if the segment is in the assembly
if (hasCapInEvents(cap_getEnd(segment_get5Cap(segment)), eventStrings)) { //Is a block in a haplotype segment
assert(hasCapInEvents(cap_getEnd(segment_get3Cap(segment)), eventStrings)); //isHaplotypeEnd(cap_getEnd(segment_get3Cap(segment))));
stList *maximalHaplotypePath = stList_construct();
stList_append(maximalHaplotypePaths, maximalHaplotypePath);
getMaximalHaplotypePathsP2(segment, maximalHaplotypePath,
segmentSet, eventStrings);
} else {
assert(!hasCapInEvents(cap_getEnd(segment_get3Cap(segment)), eventStrings));//assert(!isHaplotypeEnd(cap_getEnd(segment_get3Cap(segment))));
}
}
}
}
flower_destructSegmentIterator(segmentIt);
/*
* Now recurse on the contained flowers.
*/
Flower_GroupIterator *groupIt = flower_getGroupIterator(flower);
Group *group;
while ((group = flower_getNextGroup(groupIt)) != NULL) {
if (group_getNestedFlower(group) != NULL) {
getMaximalHaplotypePathsP(group_getNestedFlower(group),
maximalHaplotypePaths, segmentSet, eventString, eventStrings);
}
}
flower_destructGroupIterator(groupIt);
}
static void getOrderedSegmentsP(Flower *flower,
stSortedSet *segments) {
Flower_SegmentIterator *segmentIt = flower_getSegmentIterator(flower);
Segment *segment;
while ((segment = flower_getNextSegment(segmentIt)) != NULL) {
if (!segment_getStrand(segment)) {
segment = segment_getReverse(segment);
}
assert(stSortedSet_search(segments, segment) == NULL);
stSortedSet_insert(segments, segment);
}
flower_destructSegmentIterator(segmentIt);
//Recurse over the flowers
Flower_GroupIterator *groupIt = flower_getGroupIterator(flower);
Group *group;
while ((group = flower_getNextGroup(groupIt)) != NULL) {
if (group_getNestedFlower(group) != NULL) {
getOrderedSegmentsP(group_getNestedFlower(group),
segments);
}
}
flower_destructGroupIterator(groupIt);
}
int main(int argc, char *argv[]) {
st_setLogLevelFromString(argv[1]);
st_logDebug("Set up logging\n");
stKVDatabaseConf *kvDatabaseConf = stKVDatabaseConf_constructFromString(argv[2]);
CactusDisk *cactusDisk = cactusDisk_construct(kvDatabaseConf, 0);
stKVDatabaseConf_destruct(kvDatabaseConf);
st_logDebug("Set up the flower disk\n");
Name flowerName = cactusMisc_stringToName(argv[3]);
Flower *flower = cactusDisk_getFlower(cactusDisk, flowerName);
int64_t totalBases = flower_getTotalBaseLength(flower);
int64_t totalEnds = flower_getEndNumber(flower);
int64_t totalFreeEnds = flower_getFreeStubEndNumber(flower);
int64_t totalAttachedEnds = flower_getAttachedStubEndNumber(flower);
int64_t totalCaps = flower_getCapNumber(flower);
int64_t totalBlocks = flower_getBlockNumber(flower);
int64_t totalGroups = flower_getGroupNumber(flower);
int64_t totalChains = flower_getChainNumber(flower);
int64_t totalLinkGroups = 0;
int64_t maxEndDegree = 0;
int64_t maxAdjacencyLength = 0;
int64_t totalEdges = 0;
Flower_EndIterator *endIt = flower_getEndIterator(flower);
End *end;
while((end = flower_getNextEnd(endIt)) != NULL) {
assert(end_getOrientation(end));
if(end_getInstanceNumber(end) > maxEndDegree) {
maxEndDegree = end_getInstanceNumber(end);
}
stSortedSet *ends = stSortedSet_construct();
End_InstanceIterator *capIt = end_getInstanceIterator(end);
Cap *cap;
while((cap = end_getNext(capIt)) != NULL) {
if(cap_getSequence(cap) != NULL) {
Cap *adjacentCap = cap_getAdjacency(cap);
assert(adjacentCap != NULL);
End *adjacentEnd = end_getPositiveOrientation(cap_getEnd(adjacentCap));
stSortedSet_insert(ends, adjacentEnd);
int64_t adjacencyLength = cap_getCoordinate(cap) - cap_getCoordinate(adjacentCap);
if(adjacencyLength < 0) {
adjacencyLength *= -1;
}
assert(adjacencyLength >= 1);
if(adjacencyLength >= maxAdjacencyLength) {
maxAdjacencyLength = adjacencyLength;
}
}
}
end_destructInstanceIterator(capIt);
totalEdges += stSortedSet_size(ends);
if(stSortedSet_search(ends, end) != NULL) { //This ensures we count self edges twice, so that the division works.
totalEdges += 1;
}
stSortedSet_destruct(ends);
}
assert(totalEdges % 2 == 0);
flower_destructEndIterator(endIt);
Flower_GroupIterator *groupIt = flower_getGroupIterator(flower);
Group *group;
while((group = flower_getNextGroup(groupIt)) != NULL) {
if(group_getLink(group) != NULL) {
totalLinkGroups++;
}
}
flower_destructGroupIterator(groupIt);
printf("flower name: %" PRIi64 " total bases: %" PRIi64 " total-ends: %" PRIi64 " total-caps: %" PRIi64 " max-end-degree: %" PRIi64 " max-adjacency-length: %" PRIi64 " total-blocks: %" PRIi64 " total-groups: %" PRIi64 " total-edges: %" PRIi64 " total-free-ends: %" PRIi64 " total-attached-ends: %" PRIi64 " total-chains: %" PRIi64 " total-link groups: %" PRIi64 "\n",
flower_getName(flower), totalBases, totalEnds, totalCaps, maxEndDegree, maxAdjacencyLength, totalBlocks, totalGroups, totalEdges/2, totalFreeEnds, totalAttachedEnds, totalChains, totalLinkGroups);
return 0;
}
void makeCactusTree_flower(Flower *flower, FILE *fileHandle, const char *parentNodeName,
const char *parentEdgeColour) {
if(flower_isTerminal(flower)) {
makeCactusTree_terminalNode(flower, fileHandle, parentNodeName, parentEdgeColour);
}
else {
//Write the flower nodes.
char *flowerNameString = cactusMisc_nameToString(flower_getName(flower));
const char *edgeColour = graphViz_getColour();
addNodeToGraph(flowerNameString, fileHandle, flower_getTotalBaseLength(flower)
/ totalProblemSize, "ellipse", flowerNameString);
//Write in the parent edge.
if (parentNodeName != NULL) {
graphViz_addEdgeToGraph(parentNodeName, flowerNameString, fileHandle, "",
parentEdgeColour, 10, 1, "forward");
}
//Create the chains.
Flower_ChainIterator *chainIterator = flower_getChainIterator(flower);
Chain *chain;
while ((chain = flower_getNextChain(chainIterator)) != NULL) {
makeCactusTree_chain(chain, fileHandle, flowerNameString, edgeColour);
}
flower_destructChainIterator(chainIterator);
//Create the diamond node
char *diamondNodeNameString = st_malloc(sizeof(char) * (strlen(
flowerNameString) + 2));
sprintf(diamondNodeNameString, "z%s", flowerNameString);
const char *diamondEdgeColour = graphViz_getColour();
//Create all the groups linked to the diamond.
Flower_GroupIterator *groupIterator = flower_getGroupIterator(flower);
Group *group;
double size = 0.0; //get the size of the group organising node..
int64_t nonTrivialGroupCount = 0;
while ((group = flower_getNextGroup(groupIterator)) != NULL) {
assert(!group_isLeaf(group));
if (group_isTangle(group)) {
size += group_getTotalBaseLength(group);
nonTrivialGroupCount++;
}
}
flower_destructGroupIterator(groupIterator);
if(nonTrivialGroupCount == 0) {
assert(flower_getParentGroup(flower) == 0);
}
else {
//assert(nonTrivialGroupCount > 0);
addNodeToGraph(diamondNodeNameString, fileHandle, size
/ totalProblemSize, "diamond", "");
graphViz_addEdgeToGraph(flowerNameString, diamondNodeNameString,
fileHandle, "", edgeColour, 10, 1, "forward");
groupIterator = flower_getGroupIterator(flower);
while ((group = flower_getNextGroup(groupIterator)) != NULL) {
if (group_isTangle(group)) {
assert(!group_isLeaf(group));
makeCactusTree_flower(group_getNestedFlower(group), fileHandle,
diamondNodeNameString, diamondEdgeColour);
}
}
flower_destructGroupIterator(groupIterator);
}
free(flowerNameString);
free(diamondNodeNameString);
}
}
int main(int argc, char *argv[]) {
/*
* Script for adding a reference genome to a flower.
*/
/*
* Arguments/options
*/
char * logLevelString = NULL;
char * cactusDiskDatabaseString = NULL;
char * secondaryDatabaseString = NULL;
char *referenceEventString = (char *) cactusMisc_getDefaultReferenceEventHeader();
bool bottomUpPhase = 0;
///////////////////////////////////////////////////////////////////////////
// (0) Parse the inputs handed by genomeCactus.py / setup stuff.
///////////////////////////////////////////////////////////////////////////
while (1) {
static struct option long_options[] = { { "logLevel", required_argument, 0, 'a' }, { "cactusDisk", required_argument, 0, 'b' }, { "secondaryDisk", required_argument, 0, 'd' }, { "referenceEventString", required_argument, 0, 'g' }, { "help", no_argument,
0, 'h' }, { "bottomUpPhase", no_argument, 0, 'j' }, { 0, 0, 0, 0 } };
int option_index = 0;
int key = getopt_long(argc, argv, "a:b:c:d:e:g:hi:j", long_options, &option_index);
if (key == -1) {
break;
}
switch (key) {
case 'a':
logLevelString = stString_copy(optarg);
break;
case 'b':
cactusDiskDatabaseString = stString_copy(optarg);
break;
case 'd':
secondaryDatabaseString = stString_copy(optarg);
break;
case 'g':
referenceEventString = stString_copy(optarg);
break;
case 'h':
usage();
return 0;
case 'j':
bottomUpPhase = 1;
break;
default:
usage();
return 1;
}
}
///////////////////////////////////////////////////////////////////////////
// (0) Check the inputs.
///////////////////////////////////////////////////////////////////////////
assert(cactusDiskDatabaseString != NULL);
//////////////////////////////////////////////
//Set up logging
//////////////////////////////////////////////
st_setLogLevelFromString(logLevelString);
//////////////////////////////////////////////
//Load the database
//////////////////////////////////////////////
st_logInfo("referenceEventString = %s\n", referenceEventString);
st_logInfo("bottomUpPhase = %i\n", bottomUpPhase);
stKVDatabaseConf *kvDatabaseConf = stKVDatabaseConf_constructFromString(cactusDiskDatabaseString);
CactusDisk *cactusDisk = cactusDisk_construct(kvDatabaseConf, false, true);
stKVDatabaseConf_destruct(kvDatabaseConf);
st_logInfo("Set up the flower disk\n");
stKVDatabase *sequenceDatabase = NULL;
if (secondaryDatabaseString != NULL) {
kvDatabaseConf = stKVDatabaseConf_constructFromString(secondaryDatabaseString);
sequenceDatabase = stKVDatabase_construct(kvDatabaseConf, 0);
stKVDatabaseConf_destruct(kvDatabaseConf);
}
FlowerStream *flowerStream = flowerWriter_getFlowerStream(cactusDisk, stdin);
Flower *flower;
while ((flower = flowerStream_getNext(flowerStream)) != NULL) {
st_logDebug("Processing flower %" PRIi64 "\n", flower_getName(flower));
///////////////////////////////////////////////////////////////////////////
// Get the appropriate event names
///////////////////////////////////////////////////////////////////////////
st_logInfo("%s\n", eventTree_makeNewickString(flower_getEventTree(flower)));
Event *referenceEvent = eventTree_getEventByHeader(flower_getEventTree(flower), referenceEventString);
if (referenceEvent == NULL) {
st_errAbort("Reference event %s not found in tree. Check your "
"--referenceEventString option", referenceEventString);
}
Name referenceEventName = event_getName(referenceEvent);
///////////////////////////////////////////////////////////////////////////
// Now do bottom up or top down, depending
///////////////////////////////////////////////////////////////////////////
stList *flowers = stList_construct();
stList_append(flowers, flower);
preCacheNestedFlowers(cactusDisk, flowers);
if (bottomUpPhase) {
assert(sequenceDatabase != NULL);
cactusDisk_preCacheSegmentStrings(cactusDisk, flowers);
bottomUp(flowers, sequenceDatabase, referenceEventName, !flower_hasParentGroup(flower), generateJukesCantorMatrix);
// Unload the nested flowers to save memory. They haven't
// been changed, so we don't write them to the cactus
// disk.
Flower_GroupIterator *groupIt = flower_getGroupIterator(flower);
Group *group;
while ((group = flower_getNextGroup(groupIt)) != NULL) {
if (!group_isLeaf(group)) {
flower_unload(group_getNestedFlower(group));
}
}
flower_destructGroupIterator(groupIt);
assert(!flower_isParentLoaded(flower));
// Write this flower to disk.
cactusDisk_addUpdateRequest(cactusDisk, flower);
} else {
topDown(flower, referenceEventName);
// We've changed the nested flowers, but not this
// flower. We write the nested flowers to disk, then
// unload them to save memory. This flower will be
// unloaded by the flower-stream code.
Flower_GroupIterator *groupIt = flower_getGroupIterator(flower);
Group *group;
while ((group = flower_getNextGroup(groupIt)) != NULL) {
if (!group_isLeaf(group)) {
cactusDisk_addUpdateRequest(cactusDisk, group_getNestedFlower(group));
flower_unload(group_getNestedFlower(group));
}
}
flower_destructGroupIterator(groupIt);
}
stList_destruct(flowers);
}
///////////////////////////////////////////////////////////////////////////
// Write the flower(s) back to disk.
///////////////////////////////////////////////////////////////////////////
cactusDisk_write(cactusDisk);
st_logInfo("Updated the flower on disk\n");
///////////////////////////////////////////////////////////////////////////
//Clean up.
///////////////////////////////////////////////////////////////////////////
if (sequenceDatabase != NULL) {
stKVDatabase_destruct(sequenceDatabase);
}
cactusDisk_destruct(cactusDisk);
return 0; //Exit without clean up is quicker, enable cleanup when doing memory leak detection.
free(cactusDiskDatabaseString);
free(referenceEventString);
free(logLevelString);
st_logInfo("Cleaned stuff up and am finished\n");
return 0;
}
