static enum CapCode getHaplotypeSwitchCode(Cap *cap, stList *eventStrings) {
Cap *adjacentCap = cap_getAdjacency(getTerminalCap(cap));
assert(adjacentCap != NULL);
End *end = cap_getEnd(cap);
End *adjacentEnd = cap_getEnd(adjacentCap);
stSortedSet *eventStringsForEnd1 = getEventStrings(end, eventStrings);
stSortedSet *eventStringsForEnd2 = getEventStrings(adjacentEnd, eventStrings);
assert(stSortedSet_size(eventStringsForEnd1) > 0);
assert(stSortedSet_size(eventStringsForEnd2) > 0);
stSortedSet *intersectionOfEventStrings = stSortedSet_getIntersection(
eventStringsForEnd1, eventStringsForEnd2);
enum CapCode code1 = (stSortedSet_size(intersectionOfEventStrings)
!= stSortedSet_size(eventStringsForEnd1) || stSortedSet_size(
intersectionOfEventStrings)
!= stSortedSet_size(eventStringsForEnd2)) ? HAP_SWITCH
: HAP_NOTHING;
stSortedSet_destruct(eventStringsForEnd1);
stSortedSet_destruct(eventStringsForEnd2);
stSortedSet_destruct(intersectionOfEventStrings);
return code1;
}
static void sonLibSortedSetTestTeardown() {
if(sortedSet != NULL) {
stSortedSet_destruct(sortedSet);
stSortedSet_destruct(sortedSet2);
sortedSet = NULL;
}
}
/*
* Uses the functions above to build an adjacency list, then by DFS attempts to create
* a valid topological sort, returning non-zero if the graph contains a cycle.
*/
static int64_t containsACycle(stList *pairs, int64_t sequenceNumber) {
//Build an adjacency list structure..
stHash *adjacencyList = buildAdjacencyList(pairs, sequenceNumber);
//Do a topological sort of the adjacency list
stSortedSet *started = stSortedSet_construct3((int (*)(const void *, const void *))stIntTuple_cmpFn, NULL);
stSortedSet *done = stSortedSet_construct3((int (*)(const void *, const void *))stIntTuple_cmpFn, NULL);
int64_t cyclic = 0;
for(int64_t seq=0; seq<sequenceNumber; seq++) {
stIntTuple *seqPos = stIntTuple_construct2( seq, 0); //The following hacks avoid memory cleanup..
stSortedSet *column = stHash_search(adjacencyList, seqPos);
assert(column != NULL);
stIntTuple *seqPos2 = stSortedSet_search(column, seqPos);
assert(seqPos2 != NULL);
cyclic = cyclic || dfs(adjacencyList, seqPos2, started, done);
stIntTuple_destruct(seqPos);
}
//cleanup
stHashIterator *it = stHash_getIterator(adjacencyList);
stIntTuple *seqPos;
stSortedSet *columns = stSortedSet_construct2((void (*)(void *))stSortedSet_destruct);
while((seqPos = stHash_getNext(it)) != NULL) {
stSortedSet *column = stHash_search(adjacencyList, seqPos);
assert(column != NULL);
stSortedSet_insert(columns, column);
}
stHash_destructIterator(it);
stHash_destruct(adjacencyList);
stSortedSet_destruct(columns);
stSortedSet_destruct(started);
stSortedSet_destruct(done);
return cyclic;
}
static void checkComponents(CuTest *testCase, stList *filteredEdges) {
stHash *nodesToComponents = getComponents(filteredEdges);
//Check all components are smaller than threshold
stList *components = stHash_getValues(nodesToComponents);
for (int64_t i = 0; i < stList_length(components); i++) {
stSortedSet *component = stList_get(components, i);
CuAssertTrue(testCase, stSortedSet_size(component) <= maxComponentSize);
CuAssertTrue(testCase, stSortedSet_size(component) >= 1);
}
//Check no edges can be added from those filtered.
stSortedSet *filteredEdgesSet = stList_getSortedSet(filteredEdges, (int(*)(const void *, const void *)) stIntTuple_cmpFn);
for (int64_t i = 0; i < stList_length(edges); i++) {
stIntTuple *edge = stList_get(edges, i);
if (stSortedSet_search(filteredEdgesSet, edge) == NULL) {
stIntTuple *node1 = stIntTuple_construct1( stIntTuple_get(edge, 1));
stIntTuple *node2 = stIntTuple_construct1( stIntTuple_get(edge, 2));
stSortedSet *component1 = stHash_search(nodesToComponents, node1);
stSortedSet *component2 = stHash_search(nodesToComponents, node2);
CuAssertTrue(testCase, component1 != NULL && component2 != NULL);
CuAssertTrue(testCase, component1 != component2);
CuAssertTrue(testCase, stSortedSet_size(component1) + stSortedSet_size(component2) > maxComponentSize);
stIntTuple_destruct(node1);
stIntTuple_destruct(node2);
}
}
stSortedSet_destruct(filteredEdgesSet);
//Cleanup the components
stSortedSet *componentsSet = stList_getSortedSet(components, NULL);
stList_destruct(components);
stSortedSet_setDestructor(componentsSet, (void(*)(void *)) stSortedSet_destruct);
stSortedSet_destruct(componentsSet);
stHash_destruct(nodesToComponents);
}
static stHash *getComponents(stList *filteredEdges) {
/*
* A kind of stupid reimplementation of the greedy function, done just to trap typos.
*/
stHash *nodesToComponents = stHash_construct3((uint64_t(*)(const void *)) stIntTuple_hashKey,
(int(*)(const void *, const void *)) stIntTuple_equalsFn, NULL, NULL);
for (int64_t i = 0; i < stList_length(nodes); i++) {
stIntTuple *node = stList_get(nodes, i);
stSortedSet *component = stSortedSet_construct();
stSortedSet_insert(component, node);
stHash_insert(nodesToComponents, node, component);
}
for (int64_t i = 0; i < stList_length(filteredEdges); i++) {
stIntTuple *edge = stList_get(filteredEdges, i);
stIntTuple *node1 = stIntTuple_construct1( stIntTuple_get(edge, 1));
stIntTuple *node2 = stIntTuple_construct1( stIntTuple_get(edge, 2));
stSortedSet *component1 = stHash_search(nodesToComponents, node1);
stSortedSet *component2 = stHash_search(nodesToComponents, node2);
assert(component1 != NULL && component2 != NULL);
if (component1 != component2) {
stSortedSet *component3 = stSortedSet_getUnion(component1, component2);
stSortedSetIterator *setIt = stSortedSet_getIterator(component3);
stIntTuple *node3;
while ((node3 = stSortedSet_getNext(setIt)) != NULL) {
stHash_insert(nodesToComponents, node3, component3);
}
stSortedSet_destructIterator(setIt);
stSortedSet_destruct(component1);
stSortedSet_destruct(component2);
}
stIntTuple_destruct(node1);
stIntTuple_destruct(node2);
}
return nodesToComponents;
}
stList *chooseMatching_greedy(stList *edges, int64_t nodeNumber) {
/*
* Greedily picks the edge from the list such that each node has at most one edge.
*/
//First clone the list..
edges = stList_copy(edges, NULL);
stSortedSet *seen = getEmptyNodeOrEdgeSetWithCleanup();
stList *matching = stList_construct();
//Sort the adjacency pairs..
stList_sort(edges, chooseMatching_greedyP);
double strength = INT64_MAX;
while (stList_length(edges) > 0) {
stIntTuple *edge = stList_pop(edges);
double d = stIntTuple_get(edge, 2);
assert(d <= strength);
strength = d;
if(!nodeInSet(seen, stIntTuple_get(edge, 0)) && !nodeInSet(seen, stIntTuple_get(edge, 1))) {
addNodeToSet(seen, stIntTuple_get(edge, 0));
addNodeToSet(seen, stIntTuple_get(edge, 1));
stList_append(matching,edge);
}
}
assert(stList_length(edges) == 0);
stList_destruct(edges);
stSortedSet_destruct(seen);
return matching;
}
stList *getMatchingWithCyclicConstraints(stSortedSet *nodes,
stList *adjacencyEdges, stList *stubEdges, stList *chainEdges,
bool makeStubCyclesDisjoint,
stList *(*matchingAlgorithm)(stList *edges, int64_t nodeNumber)) {
/*
* Check the inputs.
*/
checkInputs(nodes, adjacencyEdges, stubEdges, chainEdges);
st_logDebug("Checked the inputs\n");
if (stSortedSet_size(nodes) == 0) { //Some of the following functions assume there are at least 2 nodes.
return stList_construct();
}
stList *chosenEdges = getPerfectMatching(nodes, adjacencyEdges, matchingAlgorithm);
stSortedSet *allAdjacencyEdges = stList_getSortedSet(adjacencyEdges,
(int(*)(const void *, const void *)) stIntTuple_cmpFn);
stList *nonZeroWeightAdjacencyEdges = getEdgesWithGreaterThanZeroWeight(
adjacencyEdges);
stList *updatedChosenEdges = makeMatchingObeyCyclicConstraints(nodes, chosenEdges, allAdjacencyEdges, nonZeroWeightAdjacencyEdges, stubEdges, chainEdges, makeStubCyclesDisjoint);
stList_destruct(chosenEdges);
chosenEdges = updatedChosenEdges;
stList_destruct(nonZeroWeightAdjacencyEdges);
stSortedSet_destruct(allAdjacencyEdges);
return chosenEdges;
}
static void splitIntoAdjacenciesStubsAndChains(stList *subCycle,
stList *adjacencyEdges, stList *stubEdges, stList *chainEdges,
stList **subAdjacencyEdges, stList **subStubEdges,
stList **subChainEdges) {
/*
* Splits run into cycles and chains..
*/
*subStubEdges = stList_construct();
*subChainEdges = stList_construct();
for (int64_t j = 0; j < stList_length(subCycle); j++) {
stIntTuple *edge = stList_get(subCycle, j);
if (stList_contains(stubEdges, edge)) {
stList_append(*subStubEdges, edge);
} else if (stList_contains(chainEdges, edge)) {
stList_append(*subChainEdges, edge);
}
}
*subAdjacencyEdges = stList_construct();
stSortedSet *nodes = getNodeSetOfEdges(subCycle);
for (int64_t j = 0; j < stList_length(adjacencyEdges); j++) {
stIntTuple *edge = stList_get(adjacencyEdges, j);
if (nodeInSet(nodes, stIntTuple_get(edge, 0)) && nodeInSet(
nodes, stIntTuple_get(edge, 1))) {
stList_append(*subAdjacencyEdges, edge);
}
}
stSortedSet_destruct(nodes);
}
static void makeMatchingPerfect(stList *chosenEdges, stList *adjacencyEdges,
stSortedSet *nodes) {
/*
* While the the number of edges is less than a perfect matching add random edges.
*/
stSortedSet *attachedNodes = getNodeSetOfEdges(chosenEdges);
stHash *nodesToAdjacencyEdges = getNodesToEdgesHash(adjacencyEdges);
stIntTuple *pNode = NULL;
stSortedSetIterator *it = stSortedSet_getIterator(nodes);
stIntTuple *node;
while((node = stSortedSet_getNext(it)) != NULL) {
if (stSortedSet_search(attachedNodes, node) == NULL) {
if (pNode == NULL) {
pNode = node;
} else {
stList_append(chosenEdges,
getEdgeForNodes(stIntTuple_get(pNode, 0), stIntTuple_get(node, 0), nodesToAdjacencyEdges));
pNode = NULL;
}
}
}
stSortedSet_destructIterator(it);
assert(pNode == NULL);
stSortedSet_destruct(attachedNodes);
assert(stList_length(chosenEdges) * 2 == stSortedSet_size(nodes));
stHash_destruct(nodesToAdjacencyEdges);
}
static void test_stSortedSetEquals(CuTest* testCase) {
sonLibSortedSetTestSetup();
CuAssertTrue(testCase, stSortedSet_equals(sortedSet, sortedSet));
int32_t i;
for(i=0; i<size; i++) {
stSortedSet_insert(sortedSet, stIntTuple_construct(1, input[i]));
}
CuAssertTrue(testCase, stSortedSet_equals(sortedSet, sortedSet));
CuAssertTrue(testCase, !stSortedSet_equals(sortedSet, sortedSet2));
for(i=1; i<size; i++) { //first argument is unique in input..
stSortedSet_insert(sortedSet2, stIntTuple_construct(1, input[i]));
}
CuAssertTrue(testCase, !stSortedSet_equals(sortedSet, sortedSet2));
stSortedSet_insert(sortedSet2, stIntTuple_construct(1, input[0]));
CuAssertTrue(testCase, stSortedSet_equals(sortedSet, sortedSet2));
stSortedSet *sortedSet3 = stSortedSet_construct(); //diff comparator..
CuAssertTrue(testCase, !stSortedSet_equals(sortedSet, sortedSet3));
for(i=0; i<size; i++) {
stSortedSet_insert(sortedSet3, stIntTuple_construct(1, input[i]));
}
CuAssertTrue(testCase, !stSortedSet_equals(sortedSet, sortedSet3));
stSortedSet_destruct(sortedSet3);
sonLibSortedSetTestTeardown();
}
static void checkIsValidReference(CuTest *testCase, stList *reference,
double totalScore) {
stList *chosenEdges = convertReferenceToAdjacencyEdges(reference);
//Check that everyone has a partner.
CuAssertIntEquals(testCase, nodeNumber, stList_length(chosenEdges) * 2);
stSortedSet *nodes = stSortedSet_construct3((int(*)(const void *, const void *)) stIntTuple_cmpFn,
(void(*)(void *)) stIntTuple_destruct);
for (int64_t i = 0; i < nodeNumber; i++) {
stSortedSet_insert(nodes, stIntTuple_construct1( i));
}
checkEdges(chosenEdges, nodes, 1, 0);
//Check that the score is correct
double totalScore2 = calculateZScoreOfReference(reference, nodeNumber, zMatrix);
CuAssertDblEquals(testCase, totalScore2, totalScore, 0.000001);
//Check that the stubs are properly connected.
stList *allEdges = stList_copy(chosenEdges, NULL);
stList_appendAll(allEdges, stubs);
stList_appendAll(allEdges, chains);
stList *components = getComponents(allEdges);
CuAssertIntEquals(testCase, stList_length(stubs), stList_length(reference));
CuAssertIntEquals(testCase, stList_length(stubs), stList_length(components));
//Cleanup
stList_destruct(components);
stSortedSet_destruct(nodes);
stList_destruct(allEdges);
stList_destruct(chosenEdges);
}
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 eventTree_destruct(EventTree *eventTree) {
Event *event;
while((event = eventTree_getFirst(eventTree)) != NULL) {
event_destruct(event);
}
stSortedSet_destruct(eventTree->events);
free(eventTree);
}
static stList *mergeSimpleCycles2(stList *chosenEdges,
stList *nonZeroWeightAdjacencyEdges, stSortedSet *allAdjacencyEdges,
stList *stubEdges, stList *chainEdges) {
/*
* Returns a new set of chosen edges, modified by adjacency switches such that every simple cycle
* contains at least one stub edge.
*/
/*
* Calculate components.
*/
stList *components = getComponents2(chosenEdges, stubEdges, chainEdges);
/*
* Divide the components by the presence of one or more stub edges.
*/
stSortedSet *stubEdgesSet = stList_getSortedSet(stubEdges,
(int(*)(const void *, const void *)) stIntTuple_cmpFn);
stList *stubContainingComponents = stList_construct();
stList *stubFreeComponents = stList_construct();
for (int64_t i = 0; i < stList_length(components); i++) {
stList *component = stList_get(components, i);
stList_append(
intersectionSize(stubEdgesSet, component) > 0 ? stubContainingComponents
: stubFreeComponents, component);
}
assert(stList_length(stubContainingComponents) > 0);
stSortedSet_destruct(stubEdgesSet);
/*
* Merge the stub containing components into one 'global' component
*/
stList *globalComponent = stList_join(stubContainingComponents);
stList_destruct(stubContainingComponents);
/*
* Remove the stub/chain edges from the components.
*/
stList_append(stubFreeComponents, globalComponent);
stList *adjacencyOnlyComponents = getStubAndChainEdgeFreeComponents(
stubFreeComponents, stubEdges, chainEdges);
stList_destruct(stubFreeComponents);
stList_destruct(globalComponent);
stList_destruct(components); //We only clean this up now, as this frees the components it contains.
/*
* Merge stub free components into the others.
*/
stList *updatedChosenEdges = mergeSimpleCycles(adjacencyOnlyComponents,
nonZeroWeightAdjacencyEdges, allAdjacencyEdges);
stList_destruct(adjacencyOnlyComponents);
return updatedChosenEdges;
}
static void test_stSortedSetIntersection(CuTest* testCase) {
sonLibSortedSetTestSetup();
//Check intersection of empty sets is okay..
stSortedSet *sortedSet3 = stSortedSet_getIntersection(sortedSet, sortedSet2);
CuAssertTrue(testCase, stSortedSet_size(sortedSet3) == 0);
stSortedSet_destruct(sortedSet3);
int32_t i;
for(i=0; i<size; i++) {
stSortedSet_insert(sortedSet, stIntTuple_construct(1, input[i]));
}
//Check intersection of empty and non-empty set is empty.
sortedSet3 = stSortedSet_getIntersection(sortedSet, sortedSet2);
CuAssertTrue(testCase, stSortedSet_size(sortedSet3) == 0);
stSortedSet_destruct(sortedSet3);
//Check intersection of two non-empty, overlapping sets in correct.
stSortedSet_insert(sortedSet2, stIntTuple_construct(1, 0));
stSortedSet_insert(sortedSet2, stIntTuple_construct(1, 1));
stSortedSet_insert(sortedSet2, stIntTuple_construct(1, 5));
sortedSet3 = stSortedSet_getIntersection(sortedSet, sortedSet2);
CuAssertTrue(testCase, stSortedSet_size(sortedSet3) == 2);
stIntTuple *intTuple = stIntTuple_construct(1, 1);
CuAssertTrue(testCase, stSortedSet_search(sortedSet3, intTuple) != NULL);
stIntTuple_destruct(intTuple);
intTuple = stIntTuple_construct(1, 5);
CuAssertTrue(testCase, stSortedSet_search(sortedSet3, intTuple) != NULL);
stIntTuple_destruct(intTuple);
stSortedSet_destruct(sortedSet3);
//Check we get an exception with sorted sets with different comparators.
stSortedSet *sortedSet4 = stSortedSet_construct();
stTry {
stSortedSet_getIntersection(sortedSet, sortedSet4);
} stCatch(except) {
CuAssertTrue(testCase, stExcept_getId(except) == SORTED_SET_EXCEPTION_ID);
}
stTryEnd
stSortedSet_destruct(sortedSet4);
sonLibSortedSetTestTeardown();
}
static void test_stSortedSetDifference(CuTest* testCase) {
sonLibSortedSetTestSetup();
//Check difference of empty sets is okay..
stSortedSet *sortedSet3 = stSortedSet_getDifference(sortedSet, sortedSet2);
CuAssertTrue(testCase, stSortedSet_size(sortedSet3) == 0);
stSortedSet_destruct(sortedSet3);
int32_t i;
for(i=0; i<size; i++) {
stSortedSet_insert(sortedSet, stIntTuple_construct(1, input[i]));
}
//Check difference of non-empty set / empty set is the non-empty.
sortedSet3 = stSortedSet_getDifference(sortedSet, sortedSet2);
CuAssertTrue(testCase, stSortedSet_equals(sortedSet, sortedSet3));
stSortedSet_destruct(sortedSet3);
//Check difference of two non-empty, overlapping sets in correct.
stSortedSet_insert(sortedSet2, stIntTuple_construct(1, 0));
stSortedSet_insert(sortedSet2, stIntTuple_construct(1, 1));
stSortedSet_insert(sortedSet2, stIntTuple_construct(1, 5));
sortedSet3 = stSortedSet_getDifference(sortedSet, sortedSet2);
CuAssertTrue(testCase, stSortedSet_size(sortedSet3) == stSortedSet_size(sortedSet) - 2);
CuAssertTrue(testCase, !stSortedSet_equals(sortedSet, sortedSet3));
stSortedSet_insert(sortedSet3, stIntTuple_construct(1, 1));
stSortedSet_insert(sortedSet3, stIntTuple_construct(1, 5));
CuAssertTrue(testCase, stSortedSet_equals(sortedSet, sortedSet3));
stSortedSet_destruct(sortedSet3);
//Check we get an exception when merging sorted sets with different comparators.
stSortedSet *sortedSet4 = stSortedSet_construct();
stTry {
stSortedSet_getDifference(sortedSet, sortedSet4);
CuAssertTrue(testCase, 0);
} stCatch(except) {
CuAssertTrue(testCase, stExcept_getId(except) == SORTED_SET_EXCEPTION_ID);
}
stTryEnd
stSortedSet_destruct(sortedSet4);
sonLibSortedSetTestTeardown();
}
void cactusDisk_destruct(CactusDisk *cactusDisk) {
Flower *flower;
MetaSequence *metaSequence;
while ((flower = stSortedSet_getFirst(cactusDisk->flowers)) != NULL) {
flower_destruct(flower, FALSE);
}
stSortedSet_destruct(cactusDisk->flowers);
stSortedSet_destruct(cactusDisk->flowerNamesMarkedForDeletion);
while ((metaSequence = stSortedSet_getFirst(cactusDisk->metaSequences)) != NULL) {
metaSequence_destruct(metaSequence);
}
stSortedSet_destruct(cactusDisk->metaSequences);
//close DB
stKVDatabase_destruct(cactusDisk->database);
//Close the sequences files.
if (cactusDisk->storeSequencesInAFile) {
free(cactusDisk->sequencesFileName);
free(cactusDisk->absSequencesFileName);
if (cactusDisk->sequencesReadFileHandle != NULL) {
fclose(cactusDisk->sequencesReadFileHandle);
}
if (cactusDisk->sequencesWriteFileHandle != NULL) {
fsync(fileno(cactusDisk->sequencesWriteFileHandle));
fclose(cactusDisk->sequencesWriteFileHandle);
}
} else {
assert(cactusDisk->sequencesFileName == NULL);
assert(cactusDisk->sequencesReadFileHandle == NULL);
assert(cactusDisk->absSequencesFileName == NULL);
}
stCache_destruct(cactusDisk->cache); //Get rid of the cache
stCache_destruct(cactusDisk->stringCache);
stList_destruct(cactusDisk->updateRequests);
free(cactusDisk);
}
stList *splitMultipleStubCycles(stList *chosenEdges,
stList *nonZeroWeightAdjacencyEdges, stSortedSet *allAdjacencyEdges,
stList *stubEdges, stList *chainEdges) {
/*
* Returns an updated list of adjacency edges, such that each stub edge is a member of exactly one cycle.
*/
/*
* Calculate components.
*/
stList *cycles = getComponents2(chosenEdges, stubEdges, chainEdges);
/*
* Find components with multiple stub edges.
*/
stList *singleStubEdgeCycles = stList_construct3(0,
(void(*)(void *)) stList_destruct);
for (int64_t i = 0; i < stList_length(cycles); i++) {
stList *subCycle = stList_get(cycles, i);
stList *subAdjacencyEdges;
stList *subStubEdges;
stList *subChainEdges;
splitIntoAdjacenciesStubsAndChains(subCycle,
nonZeroWeightAdjacencyEdges, stubEdges, chainEdges,
&subAdjacencyEdges, &subStubEdges, &subChainEdges);
stList *splitCycles = splitMultipleStubCycle(subCycle,
subAdjacencyEdges, allAdjacencyEdges, subStubEdges,
subChainEdges);
stList_appendAll(singleStubEdgeCycles, splitCycles);
stList_setDestructor(splitCycles, NULL); //Do this to avoid destroying the underlying lists
stList_destruct(splitCycles);
stList_destruct(subAdjacencyEdges);
stList_destruct(subStubEdges);
stList_destruct(subChainEdges);
}
stList_destruct(cycles);
/*
* Remove the stub/chain edges from the components.
*/
stSortedSet *stubAndChainEdgesSet = getSetOfMergedLists(stubEdges,
chainEdges);
stList *adjacencyOnlyComponents = filterListsToExclude(
singleStubEdgeCycles, stubAndChainEdgesSet);
stList_destruct(singleStubEdgeCycles);
stSortedSet_destruct(stubAndChainEdgesSet);
/*
* Merge the adjacency edges in the components into a single list.
*/
stList *updatedChosenEdges = stList_join(adjacencyOnlyComponents);
stList_destruct(adjacencyOnlyComponents);
return updatedChosenEdges;
}
static void testBreakUpComponentGreedily(CuTest *testCase) {
//return;
for (int64_t test = 0; test < 100; test++) {
st_logInfo("Starting break up giant components random test %" PRIi64 "\n", test);
setup();
stList *edgesToDelete = stCaf_breakupComponentGreedily(nodes, edges, maxComponentSize);
stSortedSet *edgesSet = stList_getSortedSet(edges, (int(*)(const void *, const void *)) stIntTuple_cmpFn);
stSortedSet *edgesToDeleteSet = stList_getSortedSet(edgesToDelete, (int(*)(const void *, const void *)) stIntTuple_cmpFn);
stSortedSet *filteredEdgesSet = stSortedSet_getDifference(edgesSet, edgesToDeleteSet);
stList *filteredEdges = stSortedSet_getList(filteredEdgesSet);
assert(stSortedSet_size(edgesToDeleteSet) + stSortedSet_size(filteredEdgesSet) == stSortedSet_size(edgesSet));
checkComponents(testCase, filteredEdges);
stSortedSet_destruct(edgesSet);
stSortedSet_destruct(edgesToDeleteSet);
stSortedSet_destruct(filteredEdgesSet);
stList_destruct(filteredEdges);
stList_destruct(edgesToDelete);
teardown();
}
}
stList *getStubAndChainEdgeFreeComponents(stList *listOfLists, stList *list1,
stList *list2) {
/*
* Returns a new list of lists, with each sub list filtered to exclude members of list1 and list2.
*/
stSortedSet *set = getSetOfMergedLists(list1, list2);
stList *filteredListOfLists = filterListsToExclude(listOfLists, set);
stSortedSet_destruct(set);
return filteredListOfLists;
}
void stPosetAlignment_destruct(stPosetAlignment *posetAlignment) {
for(int64_t i=0; i<posetAlignment->sequenceNumber; i++) {
for(int64_t j=0; j<posetAlignment->sequenceNumber; j++) {
if(i != j) {
stSortedSet_destruct(posetAlignment->constraintLists[i*posetAlignment->sequenceNumber + j]);
}
}
}
free(posetAlignment->constraintLists);
free(posetAlignment);
}
static void test_stSortedSet_copyConstruct(CuTest* testCase) {
sonLibSortedSetTestSetup();
CuAssertTrue(testCase, sortedSet != NULL);
int32_t i;
for(i=0; i<size; i++) {
stSortedSet_insert(sortedSet, stIntTuple_construct(1, input[i]));
}
stSortedSet *sortedSet2 = stSortedSet_copyConstruct(sortedSet, NULL);
CuAssertTrue(testCase, stSortedSet_size(sortedSet2) == stSortedSet_size(sortedSet));
CuAssertTrue(testCase, stSortedSet_equals(sortedSet2, sortedSet));
stSortedSet_destruct(sortedSet2);
sonLibSortedSetTestTeardown();
}
void test_stList_getSortedSet(CuTest *testCase) {
setup();
stSortedSet *sortedSet = stList_getSortedSet(list, (int (*)(const void *, const void *))strcmp);
CuAssertTrue(testCase, stSortedSet_size(sortedSet) == stringNumber);
stSortedSetIterator *iterator = stSortedSet_getIterator(sortedSet);
CuAssertStrEquals(testCase, "five", stSortedSet_getNext(iterator));
CuAssertStrEquals(testCase, "four", stSortedSet_getNext(iterator));
CuAssertStrEquals(testCase, "one", stSortedSet_getNext(iterator));
CuAssertStrEquals(testCase, "three", stSortedSet_getNext(iterator));
CuAssertStrEquals(testCase, "two", stSortedSet_getNext(iterator));
stSortedSet_destructIterator(iterator);
stSortedSet_destruct(sortedSet);
teardown();
}
void testCactusDisk_getUniqueID_Unique(CuTest* testCase) {
cactusDiskTestSetup();
stSortedSet *uniqueNames = stSortedSet_construct3(testCactusDisk_getUniqueID_UniqueP, free);
for (int64_t i = 0; i < 100000; i++) { //Gets a billion ids, checks we are good.
Name uniqueName = cactusDisk_getUniqueID(cactusDisk);
CuAssertTrue(testCase, uniqueName > 0);
CuAssertTrue(testCase, uniqueName < INT64_MAX);
CuAssertTrue(testCase, uniqueName != NULL_NAME);
char *cA = cactusMisc_nameToString(uniqueName);
CuAssertTrue(testCase, stSortedSet_search(uniqueNames, cA) == NULL);
CuAssertTrue(testCase, cactusMisc_stringToName(cA) == uniqueName);
stSortedSet_insert(uniqueNames, cA);
}
stSortedSet_destruct(uniqueNames);
cactusDiskTestTeardown();
}
void block_destruct(Block *block) {
Segment *segment;
//remove from flower.
flower_removeBlock(block_getFlower(block), block);
//remove instances
while((segment = block_getFirst(block)) != NULL) {
segment_destruct(segment);
}
//now the actual instances.
stSortedSet_destruct(block->blockContents->segments);
free(block->rBlock);
free(block->blockContents);
free(block);
}
static void getMAFBlock2(Block *block, FILE *fileHandle) {
if (block_getLength(block) >= minimumBlockLength) {
//Calculate bases in the reference and other reference sequence
Block_InstanceIterator *instanceIt = block_getInstanceIterator(block);
bool includesReference = 0;
bool includesOtherReference = 0;
Segment *segment;
while ((segment = block_getNext(instanceIt)) != NULL) {
const char *segmentEvent = event_getHeader(
segment_getEvent(segment));
if (strcmp(segmentEvent, referenceEventString) == 0) {
includesReference = 1;
} else if (strcmp(segmentEvent, otherReferenceEventString) == 0) {
includesOtherReference = 1;
}
}
block_destructInstanceIterator(instanceIt);
if (ignoreOtherReferenceBlocks && includesOtherReference) {
return;
}
stSortedSet *otherSampleEvents = stSortedSet_construct3(
(int(*)(const void *, const void *)) strcmp, NULL);
instanceIt = block_getInstanceIterator(block);
int32_t sampleNumber = 0;
while ((segment = block_getNext(instanceIt)) != NULL) {
const char *segmentEvent = event_getHeader(
segment_getEvent(segment));
if (strcmp(segmentEvent, sampleEventString) == 0) {
sampleNumber++;
} else if (strcmp(segmentEvent, referenceEventString) != 0) {
stSortedSet_insert(otherSampleEvents, (void *) segmentEvent);
}
}
block_destructInstanceIterator(instanceIt);
baseCoverages[stSortedSet_size(otherSampleEvents)] += block_getLength(
block) * sampleNumber;
stSortedSet_destruct(otherSampleEvents);
referenceBases += includesReference ? block_getLength(block)
* sampleNumber : 0;
otherReferenceBases += includesOtherReference ? block_getLength(block)
* sampleNumber : 0;
}
}
stList *getContigPaths(Flower *flower, const char *eventString, stList *eventStrings) {
stList *maximalHaplotypePaths = stList_construct3(0,
(void(*)(void *)) stList_destruct);
stSortedSet *segmentSet = stSortedSet_construct();
getMaximalHaplotypePathsP(flower, maximalHaplotypePaths, segmentSet, eventString, eventStrings);
//Do some debug checks..
st_logDebug("We have %" PRIi64 " maximal haplotype paths\n", stList_length(
maximalHaplotypePaths));
getMaximalHaplotypePathsCheck(flower, segmentSet, eventString, eventStrings);
for (int64_t i = 0; i < stList_length(maximalHaplotypePaths); i++) {
stList *maximalHaplotypePath = stList_get(maximalHaplotypePaths, i);
st_logDebug("We have a maximal haplotype path with length %" PRIi64 "\n",
stList_length(maximalHaplotypePath));
assert(stList_length(maximalHaplotypePath) > 0);
Segment *_5Segment = stList_get(maximalHaplotypePath, 0);
Segment *_3Segment = stList_get(maximalHaplotypePath, stList_length(
maximalHaplotypePath) - 1);
if (getAdjacentCapsSegment(segment_get5Cap(_5Segment)) != NULL) {
assert(!trueAdjacency(segment_get5Cap(_5Segment), eventStrings));
}
if (getAdjacentCapsSegment(segment_get3Cap(_3Segment)) != NULL) {
assert(!trueAdjacency(segment_get3Cap(_3Segment), eventStrings));
}
for (int64_t j = 0; j < stList_length(maximalHaplotypePath) - 1; j++) {
_5Segment = stList_get(maximalHaplotypePath, j);
_3Segment = stList_get(maximalHaplotypePath, j + 1);
assert(trueAdjacency(segment_get3Cap(_5Segment), eventStrings));
assert(trueAdjacency(segment_get5Cap(_3Segment), eventStrings));
assert(cap_getAdjacency(getTerminalCap(segment_get3Cap(_5Segment)))
== getTerminalCap(segment_get5Cap(_3Segment)));
assert(strcmp(event_getHeader(segment_getEvent(_5Segment)),
eventString) == 0);
assert(strcmp(event_getHeader(segment_getEvent(_3Segment)),
eventString) == 0);
assert(hasCapInEvents(cap_getEnd(segment_get5Cap(_5Segment)), eventStrings)); //isHaplotypeEnd(cap_getEnd(segment_get5Cap(_5Segment))));
assert(hasCapInEvents(cap_getEnd(segment_get5Cap(_3Segment)), eventStrings)); //isHaplotypeEnd(cap_getEnd(segment_get5Cap(_3Segment))));
}
}
stSortedSet_destruct(segmentSet);
return maximalHaplotypePaths;
}
static stList *getEdgesThatBridgeComponents(stList *components,
stHash *nodesToNonZeroWeightedAdjacencyEdges) {
/*
* Get set of adjacency edges that bridge between (have a node in two) components.
*/
stList *bridgingAdjacencyEdges = stList_construct();
for (int64_t i = 0; i < stList_length(components); i++) {
stSortedSet *componentNodes = getNodeSetOfEdges(
stList_get(components, i));
stSortedSetIterator *it = stSortedSet_getIterator(componentNodes);
stIntTuple *node;
while ((node = stSortedSet_getNext(it)) != NULL) {
stList *edges = stHash_search(nodesToNonZeroWeightedAdjacencyEdges,
node);
if (edges != NULL) {
for (int64_t j = 0; j < stList_length(edges); j++) {
stIntTuple *edge = stList_get(edges, j);
stIntTuple *node1 = stIntTuple_construct1(
stIntTuple_get(edge, 0));
stIntTuple *node2 = stIntTuple_construct1(
stIntTuple_get(edge, 1));
assert(
stSortedSet_search(componentNodes, node1) != NULL
|| stSortedSet_search(componentNodes, node2)
!= NULL);
if (stSortedSet_search(componentNodes, node1) == NULL
|| stSortedSet_search(componentNodes, node2)
== NULL) {
stList_append(bridgingAdjacencyEdges, edge);
}
stIntTuple_destruct(node1);
stIntTuple_destruct(node2);
}
}
}
stSortedSet_destructIterator(it);
stSortedSet_destruct(componentNodes);
}
return bridgingAdjacencyEdges;
}
void testCactusDisk_getUniqueID_UniqueIntervals(CuTest* testCase) {
cactusDiskTestSetup();
stSortedSet *uniqueNames = stSortedSet_construct3(testCactusDisk_getUniqueID_UniqueP, free);
for (int64_t i = 0; i < 10; i++) { //Gets a billion ids, checks we are good.
int64_t intervalSize = st_randomInt(0, 100000);
Name uniqueName = cactusDisk_getUniqueIDInterval(cactusDisk, intervalSize);
for(int64_t j=0; j<intervalSize; j++) {
CuAssertTrue(testCase, uniqueName > 0);
CuAssertTrue(testCase, uniqueName < INT64_MAX);
CuAssertTrue(testCase, uniqueName != NULL_NAME);
char *cA = cactusMisc_nameToString(uniqueName);
CuAssertTrue(testCase, stSortedSet_search(uniqueNames, cA) == NULL);
CuAssertTrue(testCase, cactusMisc_stringToName(cA) == uniqueName);
stSortedSet_insert(uniqueNames, cA);
uniqueName++;
}
}
stSortedSet_destruct(uniqueNames);
cactusDiskTestTeardown();
}
stList *getComponents(stList *edges) {
/*
* Gets a list of connected components, each connected component
* being represented as a list of the edges, such that each edge is in exactly one
* connected component. Allows for multi-graphs (multiple edges connecting two nodes).
*/
stHash *nodesToEdges = getNodesToEdgesHash(edges);
/*
* Traverse the edges greedily
*/
stList *components =
stList_construct3(0, (void(*)(void *)) stList_destruct);
stList *nodes = stHash_getKeys(nodesToEdges);
while (stList_length(nodes) > 0) {
stIntTuple *node = stList_pop(nodes);
stList *edges = stHash_search(nodesToEdges, node);
if (edges != NULL) { //We have a component to build
stSortedSet *component = stSortedSet_construct();
stHash_remove(nodesToEdges, node);
for (int64_t i = 0; i < stList_length(edges); i++) {
stIntTuple *edge = stList_get(edges, i);
getComponentsP(nodesToEdges, stIntTuple_get(edge, 0),
component);
getComponentsP(nodesToEdges, stIntTuple_get(edge, 1),
component);
}
stList_append(components, stSortedSet_getList(component));
//Cleanup
stSortedSet_destruct(component);
stList_destruct(edges);
}
stIntTuple_destruct(node);
}
assert(stHash_size(nodesToEdges) == 0);
stHash_destruct(nodesToEdges);
stList_destruct(nodes);
return components;
}
