static char *eventTree_makeNewickStringP(Event *event) { int64_t i; char *cA = NULL; char *cA3; if(event_getChildNumber(event) > 0) { for(i=0;i<event_getChildNumber(event); i++) { char *cA2 = eventTree_makeNewickStringP(event_getChild(event, i)); if(i > 0) { cA3 = st_malloc(sizeof(char)*(strlen(cA)+strlen(cA2)+2)); sprintf(cA3, "%s,%s", cA, cA2); free(cA); cA = cA3; } else { cA = st_malloc(sizeof(char)*(strlen(cA2)+2)); sprintf(cA, "(%s", cA2); } free(cA2); } cA3 = st_malloc(sizeof(char)*(strlen(cA) + strlen(event_getHeader(event)) + 30)); sprintf(cA3, "%s)%s:%g", cA, event_getHeader(event), event_getBranchLength(event)); free(cA); cA = cA3; } else { cA = st_malloc(sizeof(char)*(strlen(event_getHeader(event)) + 30)); sprintf(cA, "%s:%g", event_getHeader(event), event_getBranchLength(event)); } return cA; }
void testEvent_getChildNumber(CuTest* testCase) { cactusEventTestSetup(); CuAssertTrue(testCase, event_getChildNumber(rootEvent) == 1); CuAssertTrue(testCase, event_getChildNumber(internalEvent) == 2); CuAssertTrue(testCase, event_getChildNumber(leafEvent1) == 0); CuAssertTrue(testCase, event_getChildNumber(leafEvent2) == 0); cactusEventTestTeardown(); }
void eventTree_copyConstructP(EventTree *eventTree, Event *event, int64_t (unaryEventFilterFn)(Event *event)) { int64_t i; Event *event2; for(i=0; i<event_getChildNumber(event); i++) { event2 = event_getChild(event, i); while(event_getChildNumber(event2) == 1 && unaryEventFilterFn != NULL && !unaryEventFilterFn(event2)) { //skip the event event2 = event_getChild(event2, 0); } event_setOutgroupStatus(event_construct(event_getName(event2), event_getHeader(event2), event_getBranchLength(event2), eventTree_getEvent(eventTree, event_getName(event)), eventTree), event_isOutgroup(event2)); eventTree_copyConstructP(eventTree, event2, unaryEventFilterFn); } }
void eventTree_writeBinaryRepresentationP(Event *event, void (*writeFn)(const void * ptr, size_t size, size_t count)) { int64_t i; event_writeBinaryRepresentation(event, writeFn); for(i=0; i<event_getChildNumber(event); i++) { eventTree_writeBinaryRepresentationP(event_getChild(event, i), writeFn); } }
// 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); }
Event *event_getChild(Event *event, int64_t index) { #ifndef NDEBUG assert(event != NULL); assert(index >= 0); assert(index < event_getChildNumber(event)); #endif return event->children->list[index]; }
static stTree *eventTree_getStTree_R(Event *event) { stTree *ret = stTree_construct(); stTree_setLabel(ret, stString_print("%" PRIi64, event_getName(event))); stTree_setBranchLength(ret, event_getBranchLength(event)); for(int64_t i = 0; i < event_getChildNumber(event); i++) { Event *child = event_getChild(event, i); stTree *childStTree = eventTree_getStTree_R(child); stTree_setParent(childStTree, ret); } return ret; }
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); }
int64_t event_getSubTreeEventNumber(Event *event) { assert(event != NULL); int64_t i, j; Event *childEvent; j = 0.0; for (i = 0; i < event_getChildNumber(event); i++) { childEvent = event_getChild(event, i); j += event_getSubTreeEventNumber(childEvent) + 1; } return j; }
float event_getSubTreeBranchLength(Event *event) { assert(event != NULL); int64_t i; Event *childEvent; float branchLength; branchLength = 0.0; for (i = 0; i < event_getChildNumber(event); i++) { childEvent = event_getChild(event, i); branchLength += event_getSubTreeBranchLength(childEvent) + event_getBranchLength(childEvent); } return branchLength; }
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); } } } } }
static int64_t unaryEventFunction(Event *event) { assert(event != NULL); assert(event_getChildNumber(event) == 1); return 1; }
void testEventTree_addSiblingUnaryEvent(CuTest *testCase) { cactusEventTreeTestSetup(); //Create two sibling flowers with the basic event tree.. //then try adding events from on into the other. Group *group1 = group_construct2(flower); Group *group2 = group_construct2(flower); Flower *flower2 = flower_construct(cactusDisk); Flower *flower3 = flower_construct(cactusDisk); flower_setParentGroup(flower2, group1); flower_setParentGroup(flower3, group2); EventTree *eventTree2 = eventTree_copyConstruct(flower_getEventTree(flower), flower2, NULL); Event *parentUnaryEvent1 = event_construct4("UNARY1", 0.1, internalEvent, leafEvent1, eventTree); Event *parentUnaryEvent2 = event_construct4("UNARY2", 0.1, parentUnaryEvent1, leafEvent1, eventTree); Event *parentUnaryEvent3 = event_construct4("UNARY3", 0.1, internalEvent, leafEvent2, eventTree); //now event tree contains the added unary events. EventTree *eventTree3 = eventTree_copyConstruct(flower_getEventTree(flower), flower3, NULL); //add a couple of denovo events into the new event tree Event *internalEventChild = eventTree_getEvent(eventTree3, event_getName(internalEvent)); Event *unaryEvent1 = eventTree_getEvent(eventTree3, event_getName(parentUnaryEvent1)); Event *unaryEvent2 = eventTree_getEvent(eventTree3, event_getName(parentUnaryEvent2)); Event *unaryEvent3 = eventTree_getEvent(eventTree3, event_getName(parentUnaryEvent3)); Event *unaryEvent4 = event_construct4("UNARY4", 0.1, internalEventChild, unaryEvent3, eventTree3); Event *unaryEvent5 = event_construct4("UNARY5", 0.1, internalEventChild, unaryEvent4, eventTree3); //Now event-tree 2 does not contain the unary events but event-tree 3 does.. CuAssertTrue(testCase, eventTree_getEvent(eventTree2, event_getName(unaryEvent1)) == NULL); CuAssertTrue(testCase, eventTree_getEvent(eventTree2, event_getName(unaryEvent2)) == NULL); CuAssertTrue(testCase, eventTree_getEvent(eventTree2, event_getName(unaryEvent3)) == NULL); CuAssertTrue(testCase, eventTree_getEvent(eventTree2, event_getName(unaryEvent4)) == NULL); CuAssertTrue(testCase, eventTree_getEvent(eventTree2, event_getName(unaryEvent5)) == NULL); eventTree_addSiblingUnaryEvent(eventTree2, unaryEvent1); Event *unaryEvent12 = eventTree_getEvent(eventTree2, event_getName(unaryEvent1)); CuAssertTrue(testCase, unaryEvent12 != NULL); CuAssertTrue(testCase, event_getName(event_getParent(unaryEvent12)) == event_getName(internalEvent)); CuAssertTrue(testCase, event_getChildNumber(unaryEvent12) == 1); CuAssertTrue(testCase, event_getName(event_getChild(unaryEvent12, 0)) == event_getName(leafEvent1)); eventTree_addSiblingUnaryEvent(eventTree2, unaryEvent2); Event *unaryEvent22 = eventTree_getEvent(eventTree2, event_getName(unaryEvent2)); CuAssertTrue(testCase, unaryEvent22 != NULL); CuAssertTrue(testCase, event_getName(event_getParent(unaryEvent22)) == event_getName(unaryEvent1)); CuAssertTrue(testCase, event_getChildNumber(unaryEvent22) == 1); CuAssertTrue(testCase, event_getName(event_getChild(unaryEvent22, 0)) == event_getName(leafEvent1)); eventTree_addSiblingUnaryEvent(eventTree2, unaryEvent3); Event *unaryEvent32 = eventTree_getEvent(eventTree2, event_getName(unaryEvent3)); CuAssertTrue(testCase, unaryEvent32 != NULL); CuAssertTrue(testCase, event_getName(event_getParent(unaryEvent32)) == event_getName(internalEvent)); CuAssertTrue(testCase, event_getChildNumber(unaryEvent32) == 1); CuAssertTrue(testCase, event_getName(event_getChild(unaryEvent32, 0)) == event_getName(leafEvent2)); eventTree_addSiblingUnaryEvent(eventTree2, unaryEvent4); Event *unaryEvent42 = eventTree_getEvent(eventTree2, event_getName(unaryEvent4)); CuAssertTrue(testCase, unaryEvent42 != NULL); CuAssertTrue(testCase, event_getName(event_getParent(unaryEvent42)) == event_getName(internalEvent)); CuAssertTrue(testCase, event_getChildNumber(unaryEvent42) == 1); CuAssertTrue(testCase, event_getName(event_getChild(unaryEvent42, 0)) == event_getName(unaryEvent3)); eventTree_addSiblingUnaryEvent(eventTree2, unaryEvent5); Event *unaryEvent52 = eventTree_getEvent(eventTree2, event_getName(unaryEvent5)); CuAssertTrue(testCase, unaryEvent52 != NULL); CuAssertTrue(testCase, event_getName(event_getParent(unaryEvent52)) == event_getName(internalEvent)); CuAssertTrue(testCase, event_getChildNumber(unaryEvent52) == 1); CuAssertTrue(testCase, event_getName(event_getChild(unaryEvent52, 0)) == event_getName(unaryEvent4)); //uglyf("Event-tree-1 %s\n", eventTree_makeNewickString(eventTree)); //uglyf("Event-tree-2 %s\n", eventTree_makeNewickString(eventTree3)); //uglyf("Event-tree-3 %s\n", eventTree_makeNewickString(eventTree2)); cactusEventTreeTestTeardown(); }