Event *eventTree_getCommonAncestor(Event *event, Event *event2) { Event *ancestorEvent; struct List *list; assert(event != NULL); assert(event2 != NULL); assert(event_getEventTree(event) == event_getEventTree(event2)); list = constructEmptyList(0, NULL); ancestorEvent = event; while(ancestorEvent != NULL) { if(ancestorEvent == event2) { destructList(list); return event2; } listAppend(list, ancestorEvent); ancestorEvent = event_getParent(ancestorEvent); } ancestorEvent = event2; while((ancestorEvent = event_getParent(ancestorEvent)) != NULL) { if(listContains(list, ancestorEvent)) { destructList(list); return ancestorEvent; } } destructList(list); assert(FALSE); return NULL; }
void testEvent_getParent(CuTest* testCase) { cactusEventTestSetup(); CuAssertTrue(testCase, event_getParent(rootEvent) == NULL); CuAssertTrue(testCase, event_getParent(internalEvent) == rootEvent); CuAssertTrue(testCase, event_getParent(leafEvent1) == internalEvent); CuAssertTrue(testCase, event_getParent(leafEvent2) == internalEvent); cactusEventTestTeardown(); }
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 event_writeBinaryRepresentation(Event *event, void(*writeFn)( const void * ptr, size_t size, size_t count)) { binaryRepresentation_writeElementType(CODE_EVENT, writeFn); binaryRepresentation_writeName(event_getName(event_getParent(event)), writeFn); binaryRepresentation_writeName(event_getName(event), writeFn); binaryRepresentation_writeFloat(event_getBranchLength(event), writeFn); binaryRepresentation_writeString(event_getHeader(event), writeFn); binaryRepresentation_writeBool(event_isOutgroup(event), writeFn); }
void event_destruct(Event *event) { int64_t i; Event *childEvent; Event *parentEvent = event_getParent(event); if (parentEvent != NULL) { listRemove(parentEvent->children, event); } eventTree_removeEvent(event_getEventTree(event), event); for (i = 0; i < event->children->length; i++) { childEvent = event->children->list[i]; childEvent->parent = parentEvent; if (parentEvent != NULL) { listAppend(parentEvent->children, childEvent); } } destructList(event->children); free(event->header); free(event); }
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(); }