EventTree *eventTree_copyConstruct(EventTree *eventTree, int64_t (unaryEventFilterFn)(Event *event)) {
EventTree *eventTree2;
eventTree2 = eventTree_construct(eventTree_getCactusDisk(eventTree),
event_getName(eventTree_getRootEvent(eventTree)));
eventTree_copyConstructP(eventTree2, eventTree_getRootEvent(eventTree), unaryEventFilterFn);
return eventTree2;
}
static void sequenceSetup() {
metaSequence = metaSequence_construct(0, 10, "ACTGACTGAC", ">one",
event_getName(eventTree_getRootEvent(eventTree)), cactusDisk);
sequence = sequence_construct(metaSequence, flower);
metaSequence2 = metaSequence_construct(0, 10, "ACTGACTGAC", ">two",
event_getName(eventTree_getRootEvent(eventTree)), cactusDisk);
sequence2 = sequence_construct(metaSequence2, flower);
}
void event_check(Event *event) {
EventTree *eventTree = event_getEventTree(event);
Event *ancestorEvent = event_getParent(event);
//Check event and eventree properly linked
cactusCheck(eventTree_getEvent(event_getEventTree(event), event_getName(event)) == event);
//Event has parent, unless it is root.
if (eventTree_getRootEvent(eventTree) == event) {
cactusCheck(ancestorEvent == NULL);
} else { //not root, so must have ancestor.
cactusCheck(ancestorEvent != NULL);
}
//Each child event has event as parent.
int64_t i = 0;
for (i = 0; i < event_getChildNumber(event); i++) {
Event *childEvent = event_getChild(event, i);
cactusCheck(event_getParent(childEvent) == event);
}
//Ancestor-event --> event edge is consistent with any event tree that is in the parent of the containing flower.
Group *parentGroup = flower_getParentGroup(eventTree_getFlower(
event_getEventTree(event)));
if (parentGroup != NULL) {
EventTree *parentEventTree = flower_getEventTree(group_getFlower(
parentGroup));
Event *parentEvent = eventTree_getEvent(parentEventTree, event_getName(
event));
if (parentEvent != NULL) {
if (ancestorEvent == NULL) { //the case where they are both root.
cactusCheck(eventTree_getRootEvent(parentEventTree) == parentEvent);
} else {
//Check edge ancestorEvent --> event is in parent event tree.
while (1) {
Event *parentAncestorEvent = eventTree_getEvent(
parentEventTree, event_getName(ancestorEvent));
if (parentAncestorEvent != NULL) {
cactusCheck(event_isAncestor(parentEvent, parentAncestorEvent));
break;
}
ancestorEvent = event_getParent(ancestorEvent);
cactusCheck(ancestorEvent != NULL);
}
}
}
}
}
void testEventTree_serialisation(CuTest* testCase) {
cactusEventTreeTestSetup();
int64_t i;
void *vA = binaryRepresentation_makeBinaryRepresentation(eventTree,
(void (*)(void *, void (*)(const void *, size_t, size_t)))eventTree_writeBinaryRepresentation, &i);
CuAssertTrue(testCase, i > 0);
eventTree_destruct(eventTree);
void *vA2 = vA;
eventTree = eventTree_loadFromBinaryRepresentation(&vA2, flower);
rootEvent = eventTree_getRootEvent(eventTree);
internalEvent = event_getChild(rootEvent, 0);
leafEvent1 = event_getChild(internalEvent, 0);
leafEvent2 = event_getChild(internalEvent, 1);
free(vA);
nestedTest = 1;
testEventTree_copyConstruct(testCase);
testEventTree_getRootEvent(testCase);
testEventTree_getEvent(testCase);
testEventTree_getCommonAncestor(testCase);
testEventTree_getFlower(testCase);
testEventTree_getEventNumber(testCase);
testEventTree_getFirst(testCase);
testEventTree_makeNewickString(testCase);
testEventTree_iterator(testCase);
testEventTree_addSiblingUnaryEvent(testCase);
nestedTest = 0;
cactusEventTreeTestTeardown();
}
// Get species tree from event tree (labeled by the event Names),
// which requires ignoring the root event.
stTree *eventTree_getStTree(EventTree *eventTree) {
Event *rootEvent = eventTree_getRootEvent(eventTree);
// Need to skip the root event, since it is added onto the real
// species tree.
assert(event_getChildNumber(rootEvent) == 1);
Event *speciesRoot = event_getChild(rootEvent, 0);
return eventTree_getStTree_R(speciesRoot);
}
char *eventTree_makeNewickString(EventTree *eventTree) {
Event *rootEvent = eventTree_getRootEvent(eventTree);
char *cA = eventTree_makeNewickStringP(rootEvent);
char *cA2 = st_malloc(sizeof(char)*(strlen(cA) + 2));
sprintf(cA2, "%s;", cA);
free(cA);
return cA2;
}
void eventTree_writeBinaryRepresentation(EventTree *eventTree, void (*writeFn)(const void * ptr, size_t size, size_t count)) {
int64_t i;
Event *event;
event = eventTree_getRootEvent(eventTree);
binaryRepresentation_writeElementType(CODE_EVENT_TREE, writeFn);
binaryRepresentation_writeName(event_getName(event), writeFn);
for(i=0; i<event_getChildNumber(event); i++) {
eventTree_writeBinaryRepresentationP(event_getChild(event, i), writeFn);
}
binaryRepresentation_writeElementType(CODE_EVENT_TREE, writeFn);
}
static void cactusEventTreeTestSetup() {
if(!nestedTest) {
cactusEventTreeTestTeardown();
cactusDisk = testCommon_getTemporaryCactusDisk();
flower = flower_construct(cactusDisk);
eventTree = eventTree_construct2(flower);
rootEvent = eventTree_getRootEvent(eventTree);
internalEvent = event_construct3("INTERNAL", 0.5, rootEvent, eventTree);
leafEvent1 = event_construct3("LEAF1", 0.2, internalEvent, eventTree);
leafEvent2 = event_construct3("LEAF2", 1.3, internalEvent, eventTree);
event_setOutgroupStatus(leafEvent1, 1);
}
}
int64_t eventTree_getEventNumber(EventTree *eventTree) {
return event_getSubTreeEventNumber(eventTree_getRootEvent(eventTree)) + 1;
}
void testEventTree_getRootEvent(CuTest* testCase) {
cactusEventTreeTestSetup();
CuAssertTrue(testCase, eventTree_getRootEvent(eventTree) == rootEvent);
cactusEventTreeTestTeardown();
}
int main(int argc, char *argv[]) {
/*
* Open the database.
* Construct a flower.
* Construct an event tree representing the species tree.
* For each sequence contruct two ends each containing an cap.
* Make a file for the sequence.
* Link the two caps.
* Finish!
*/
int64_t key, j;
Group *group;
Flower_EndIterator *endIterator;
End *end;
bool makeEventHeadersAlphaNumeric = 0;
/*
* Arguments/options
*/
char * logLevelString = NULL;
char * speciesTree = NULL;
char * outgroupEvents = NULL;
///////////////////////////////////////////////////////////////////////////
// (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' }, {
"speciesTree", required_argument, 0, 'f' }, { "outgroupEvents", required_argument, 0, 'g' },
{ "help", no_argument, 0, 'h' }, { "makeEventHeadersAlphaNumeric", no_argument, 0, 'i' }, { 0, 0, 0, 0 } };
int option_index = 0;
key = getopt_long(argc, argv, "a:b:f:hg:i", long_options, &option_index);
if (key == -1) {
break;
}
switch (key) {
case 'a':
logLevelString = optarg;
break;
case 'b':
cactusDiskDatabaseString = optarg;
break;
case 'f':
speciesTree = optarg;
break;
case 'g':
outgroupEvents = optarg;
break;
case 'h':
usage();
return 0;
case 'i':
makeEventHeadersAlphaNumeric = 1;
break;
default:
usage();
return 1;
}
}
///////////////////////////////////////////////////////////////////////////
// (0) Check the inputs.
///////////////////////////////////////////////////////////////////////////
//assert(logLevelString == NULL || strcmp(logLevelString, "CRITICAL") == 0 || strcmp(logLevelString, "INFO") == 0 || strcmp(logLevelString, "DEBUG") == 0);
assert(cactusDiskDatabaseString != NULL);
assert(speciesTree != NULL);
//////////////////////////////////////////////
//Set up logging
//////////////////////////////////////////////
st_setLogLevelFromString(logLevelString);
//////////////////////////////////////////////
//Log (some of) the inputs
//////////////////////////////////////////////
st_logInfo("Flower disk name : %s\n", cactusDiskDatabaseString);
for (j = optind; j < argc; j++) {
st_logInfo("Sequence file/directory %s\n", argv[j]);
}
//////////////////////////////////////////////
//Load the database
//////////////////////////////////////////////
stKVDatabaseConf *kvDatabaseConf = kvDatabaseConf = stKVDatabaseConf_constructFromString(cactusDiskDatabaseString);
if (stKVDatabaseConf_getType(kvDatabaseConf) == stKVDatabaseTypeTokyoCabinet || stKVDatabaseConf_getType(kvDatabaseConf)
== stKVDatabaseTypeKyotoTycoon) {
assert(stKVDatabaseConf_getDir(kvDatabaseConf) != NULL);
cactusDisk = cactusDisk_construct2(kvDatabaseConf, "cactusSequences");
} else {
cactusDisk = cactusDisk_construct(kvDatabaseConf, 1);
}
st_logInfo("Set up the flower disk\n");
//////////////////////////////////////////////
//Construct the flower
//////////////////////////////////////////////
if (cactusDisk_getFlower(cactusDisk, 0) != NULL) {
cactusDisk_destruct(cactusDisk);
st_logInfo("The first flower already exists\n");
return 0;
}
flower = flower_construct2(0, cactusDisk);
assert(flower_getName(flower) == 0);
st_logInfo("Constructed the flower\n");
//////////////////////////////////////////////
//Construct the event tree
//////////////////////////////////////////////
st_logInfo("Going to build the event tree with newick string: %s\n", speciesTree);
stTree *tree = stTree_parseNewickString(speciesTree);
st_logInfo("Parsed the tree\n");
if (makeEventHeadersAlphaNumeric) {
makeEventHeadersAlphaNumericFn(tree);
}
stTree_setBranchLength(tree, INT64_MAX);
checkBranchLengthsAreDefined(tree);
eventTree = eventTree_construct2(flower); //creates the event tree and the root even
totalEventNumber = 1;
st_logInfo("Constructed the basic event tree\n");
// Construct a set of outgroup names so that ancestral outgroups
// get recognized.
stSet *outgroupNameSet = stSet_construct3(stHash_stringKey,
stHash_stringEqualKey,
free);
if(outgroupEvents != NULL) {
stList *outgroupNames = stString_split(outgroupEvents);
for(int64_t i = 0; i < stList_length(outgroupNames); i++) {
char *outgroupName = stList_get(outgroupNames, i);
stSet_insert(outgroupNameSet, stString_copy(outgroupName));
}
stList_destruct(outgroupNames);
}
//now traverse the tree
j = optind;
assignEventsAndSequences(eventTree_getRootEvent(eventTree), tree,
outgroupNameSet, argv, &j);
char *eventTreeString = eventTree_makeNewickString(eventTree);
st_logInfo(
"Constructed the initial flower with %" PRIi64 " sequences and %" PRIi64 " events with string: %s\n",
totalSequenceNumber, totalEventNumber, eventTreeString);
assert(event_getSubTreeBranchLength(eventTree_getRootEvent(eventTree)) >= 0.0);
free(eventTreeString);
//assert(0);
//////////////////////////////////////////////
//Label any outgroup events.
//////////////////////////////////////////////
if (outgroupEvents != NULL) {
stList *outgroupEventsList = stString_split(outgroupEvents);
for (int64_t i = 0; i < stList_length(outgroupEventsList); i++) {
char *outgroupEvent = makeEventHeadersAlphaNumeric ? makeAlphaNumeric(stList_get(outgroupEventsList, i)) : stString_copy(stList_get(outgroupEventsList, i));
Event *event = eventTree_getEventByHeader(eventTree, outgroupEvent);
if (event == NULL) {
st_errAbort("Got an outgroup string that does not match an event, outgroup string %s", outgroupEvent);
}
assert(!event_isOutgroup(event));
event_setOutgroupStatus(event, 1);
assert(event_isOutgroup(event));
free(outgroupEvent);
}
stList_destruct(outgroupEventsList);
}
//////////////////////////////////////////////
//Construct the terminal group.
//////////////////////////////////////////////
if (flower_getEndNumber(flower) > 0) {
group = group_construct2(flower);
endIterator = flower_getEndIterator(flower);
while ((end = flower_getNextEnd(endIterator)) != NULL) {
end_setGroup(end, group);
}
flower_destructEndIterator(endIterator);
assert(group_isLeaf(group));
// Create a one link chain if there is only one pair of attached ends..
group_constructChainForLink(group);
assert(!flower_builtBlocks(flower));
} else {
flower_setBuiltBlocks(flower, 1);
}
///////////////////////////////////////////////////////////////////////////
// Write the flower to disk.
///////////////////////////////////////////////////////////////////////////
//flower_check(flower);
cactusDisk_write(cactusDisk);
st_logInfo("Updated the flower on disk\n");
///////////////////////////////////////////////////////////////////////////
// Cleanup.
///////////////////////////////////////////////////////////////////////////
cactusDisk_destruct(cactusDisk);
return 0; //Exit without clean up is quicker, enable cleanup when doing memory leak detection.
stSet_destruct(outgroupNameSet);
stTree_destruct(tree);
stKVDatabaseConf_destruct(kvDatabaseConf);
return 0;
}
static void segmentsSetup() {
blocksSetup();
segment = segment_construct(block, eventTree_getRootEvent(eventTree));
segment2 = segment_construct(block2, eventTree_getRootEvent(eventTree));
}
static void capsSetup() {
endsSetup();
cap = cap_construct(end, eventTree_getRootEvent(eventTree));
cap2 = cap_construct(end2, eventTree_getRootEvent(eventTree));
}
