void testEventTree_getEvent(CuTest* testCase) {
cactusEventTreeTestSetup();
CuAssertTrue(testCase, eventTree_getEvent(eventTree, event_getName(rootEvent)) == rootEvent);
CuAssertTrue(testCase, eventTree_getEvent(eventTree, event_getName(internalEvent)) == internalEvent);
CuAssertTrue(testCase, eventTree_getEvent(eventTree, event_getName(leafEvent1)) == leafEvent1);
CuAssertTrue(testCase, eventTree_getEvent(eventTree, event_getName(leafEvent2)) == leafEvent2);
cactusEventTreeTestTeardown();
}
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 bottomUp(stList *flowers, stKVDatabase *sequenceDatabase, Name referenceEventName,
bool isTop, stMatrix *(*generateSubstitutionMatrix)(double)) {
/*
* A reference thread between the two caps
* in each flower f may be broken into two in the children of f.
* Therefore, for each flower f first identify attached stub ends present in the children of f that are
* not present in f and copy them into f, reattaching the reference caps as needed.
*/
stList *caps = getCaps(flowers, referenceEventName);
for (int64_t i = stList_length(caps) - 1; i >= 0; i--) { //Start from end, as we add to this list.
setAdjacencyLengthsAndRecoverNewCapsAndBrokenAdjacencies(stList_get(caps, i), caps);
}
for(int64_t i=0; i<stList_length(flowers); i++) {
recoverBrokenAdjacencies(stList_get(flowers, i), caps, referenceEventName);
}
//Build the phylogenetic event trees for base calling.
segmentWriteFn_flowerToPhylogeneticTreeHash = stHash_construct2(NULL, (void (*)(void *))cleanupPhylogeneticTree);
for(int64_t i=0; i<stList_length(flowers); i++) {
Flower *flower = stList_get(flowers, i);
Event *refEvent = eventTree_getEvent(flower_getEventTree(flower), referenceEventName);
assert(refEvent != NULL);
stHash_insert(segmentWriteFn_flowerToPhylogeneticTreeHash, flower, getPhylogeneticTreeRootedAtGivenEvent(refEvent, generateSubstitutionMatrix));
}
if (isTop) {
stList *threadStrings = buildRecursiveThreadsInList(sequenceDatabase, caps, segmentWriteFn,
terminalAdjacencyWriteFn);
assert(stList_length(threadStrings) == stList_length(caps));
int64_t nonTrivialSeqIndex = 0, trivialSeqIndex = stList_length(threadStrings); //These are used as indices for the names of trivial and non-trivial sequences.
for (int64_t i = 0; i < stList_length(threadStrings); i++) {
Cap *cap = stList_get(caps, i);
assert(cap_getStrand(cap));
assert(!cap_getSide(cap));
Flower *flower = end_getFlower(cap_getEnd(cap));
char *threadString = stList_get(threadStrings, i);
bool trivialString = isTrivialString(&threadString); //This alters the original string
MetaSequence *metaSequence = addMetaSequence(flower, cap, trivialString ? trivialSeqIndex++ : nonTrivialSeqIndex++,
threadString, trivialString);
free(threadString);
int64_t endCoordinate = setCoordinates(flower, metaSequence, cap, metaSequence_getStart(metaSequence) - 1);
(void) endCoordinate;
assert(endCoordinate == metaSequence_getLength(metaSequence) + metaSequence_getStart(metaSequence));
}
stList_setDestructor(threadStrings, NULL); //The strings are already cleaned up by the above loop
stList_destruct(threadStrings);
} else {
buildRecursiveThreads(sequenceDatabase, caps, segmentWriteFn, terminalAdjacencyWriteFn);
}
stHash_destruct(segmentWriteFn_flowerToPhylogeneticTreeHash);
stList_destruct(caps);
}
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);
}
}
Event *event_construct(Name name, const char *header, float branchLength, Event *parentEvent,
EventTree *eventTree) {
assert(eventTree_getEvent(eventTree, name) == NULL); //the event must not already exist in the tree.
Event *event;
event = st_malloc(sizeof(Event));
event->name = name;
event->parent = parentEvent;
event->children = constructEmptyList(0, NULL);
event->header = stString_copy(header == NULL ? "" : header);
event->branchLength = branchLength < 0.0 ? 0.0 : branchLength;
event->isOutgroup = 0;
if (parentEvent != NULL) {
listAppend(parentEvent->children, event);
}
event->eventTree = eventTree;
eventTree_addEvent(eventTree, event);
return event;
}
void testEventTree_copyConstruct(CuTest* testCase) {
cactusEventTreeTestSetup();
Flower *flower2 = flower_construct(cactusDisk);
EventTree *eventTree2 = eventTree_copyConstruct(eventTree, flower2, unaryEventFunction);
CuAssertIntEquals(testCase, eventTree_getEventNumber(eventTree), eventTree_getEventNumber(eventTree2));
CuAssertTrue(testCase, event_getName(eventTree_getEvent(eventTree2, event_getName(rootEvent))) == event_getName(rootEvent));
CuAssertTrue(testCase, event_getName(eventTree_getEvent(eventTree2, event_getName(internalEvent))) == event_getName(internalEvent));
CuAssertTrue(testCase, event_getName(eventTree_getEvent(eventTree2, event_getName(leafEvent1))) == event_getName(leafEvent1));
CuAssertTrue(testCase, event_getName(eventTree_getEvent(eventTree2, event_getName(leafEvent2))) == event_getName(leafEvent2));
CuAssertTrue(testCase, event_isOutgroup(eventTree_getEvent(eventTree2, event_getName(leafEvent1))));
CuAssertTrue(testCase, !event_isOutgroup(eventTree_getEvent(eventTree2, event_getName(leafEvent2))));
cactusEventTreeTestTeardown();
}
Event *event_loadFromBinaryRepresentation(void **binaryString,
EventTree *eventTree) {
Event *event, *parentEvent;
Name name;
float branchLength;
char *header;
event = NULL;
if (binaryRepresentation_peekNextElementType(*binaryString) == CODE_EVENT) {
binaryRepresentation_popNextElementType(binaryString);
parentEvent = eventTree_getEvent(eventTree,
binaryRepresentation_getName(binaryString));
assert(parentEvent != NULL);
name = binaryRepresentation_getName(binaryString);
branchLength = binaryRepresentation_getFloat(binaryString);
header = binaryRepresentation_getString(binaryString);
event
= event_construct(name, header, branchLength, parentEvent,
eventTree);
event_setOutgroupStatus(event, binaryRepresentation_getBool(binaryString));
free(header);
}
return 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();
}
Event *sequence_getEvent(Sequence *sequence) {
return eventTree_getEvent(flower_getEventTree(sequence_getFlower(sequence)), metaSequence_getEventName(sequence->metaSequence));
}
