static void testBulkSetRecords(CuTest *testCase) {
/*
* Tests doing a bulk update of a set of records.
*/
setup();
int64_t i = 100, j = 110, k = 120, l = 130;
stKVDatabase_insertRecord(database, 1, &i, sizeof(int64_t));
stList *requests = stList_construct3(0, (void(*)(void *)) stKVDatabaseBulkRequest_destruct);
stList_append(requests, stKVDatabaseBulkRequest_constructInsertRequest(2, &j, sizeof(int64_t)));
stList_append(requests, stKVDatabaseBulkRequest_constructSetRequest(3, &k, sizeof(int64_t)));
stList_append(requests, stKVDatabaseBulkRequest_constructUpdateRequest(1, &l, sizeof(int64_t)));
stKVDatabase_bulkSetRecords(database, requests);
stList_destruct(requests);
int64_t *m = stKVDatabase_getRecord(database, 1);
CuAssertTrue(testCase, m != NULL);
CuAssertTrue(testCase, l == *m);
free(m);
m = stKVDatabase_getRecord(database, 2);
CuAssertTrue(testCase, m != NULL);
CuAssertTrue(testCase, j == *m);
free(m);
m = stKVDatabase_getRecord(database, 3);
CuAssertTrue(testCase, m != NULL);
CuAssertTrue(testCase, k == *m);
free(m);
teardown();
}
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 stList *mergeSubstrings(stList *substrings, int64_t proximityToMerge) {
/*
* Merge set of substrings into fewer substrings, if they overlap by less than proximityToMerge
*/
stList *mergedSubstrings = stList_construct3(0, (void (*)(void *)) substring_destruct);
if (stList_length(substrings) == 0) {
return mergedSubstrings;
}
stList_sort(substrings, (int (*)(const void *, const void *)) substring_cmp);
Substring *pSubsequence = substring_clone(stList_get(substrings, 0));
stList_append(mergedSubstrings, pSubsequence);
for (int64_t i = 1; i < stList_length(substrings); i++) {
Substring *substring = stList_get(substrings, i);
if (pSubsequence->name == substring->name
&& pSubsequence->start + pSubsequence->length + proximityToMerge >= substring->start) { //Merge
if (pSubsequence->start + pSubsequence->length < substring->start + substring->length) {
pSubsequence->length = substring->start + substring->length - pSubsequence->start;
}
} else {
pSubsequence = substring_clone(substring);
stList_append(mergedSubstrings, pSubsequence);
}
}
return mergedSubstrings;
}
static void setup() {
teardown();
assert(nodeNumber == -1);
while(nodeNumber % 2 != 0) {
nodeNumber = st_randomInt(0, 100);
}
assert(nodeNumber >= 0);
assert(nodeNumber % 2 == 0);
stubs = stList_construct3(0, (void (*)(void *))stIntTuple_destruct);
chains = stList_construct3(0, (void (*)(void *))stIntTuple_destruct);
for(int64_t i=0; i<nodeNumber/2; i++) {
assert(nodeNumber/2 > 0);
stIntTuple *edge = stIntTuple_construct2(i, nodeNumber/2 + i);
if(stList_length(stubs) == 0 || st_random() > 0.9) {
stList_append(stubs, edge);
}
else {
stList_append(chains, edge);
}
}
zMatrix = st_calloc(nodeNumber*nodeNumber, sizeof(float));
for(int64_t i=0; i<nodeNumber; i++) {
for(int64_t j=i+1; j<nodeNumber; j++) {
double score = st_random();
zMatrix[i * nodeNumber + j] = score;
zMatrix[j * nodeNumber + i] = score;
}
}
st_logDebug("To test the adjacency problem we've created a problem with %" PRIi64 " nodes %" PRIi64 " stubs and %" PRIi64 " chains\n", nodeNumber, stList_length(stubs), stList_length(chains));
}
static void doBestMergeOfTwoSimpleCycles(stList *cycles,
stList *nonZeroWeightAdjacencyEdges, stSortedSet *allAdjacencyEdges) {
/*
* Merge two simple cycles, using the best possible adjacency switch. Modifies components list in place,
* destroying two old components and adding a new one. If new adjacency edges are needed then they are
* added to the adjacency edges list.
*/
assert(stList_length(cycles) > 1);
/*
* Get the best adjacency switch.
*/
AdjacencySwitch *adjacencySwitch = getBestAdjacencySwitch(cycles,
nonZeroWeightAdjacencyEdges, allAdjacencyEdges);
assert(adjacencySwitch != NULL);
/*
* Find the two components to merge.
*/
stList *cyclesToMerge = stList_construct3(0,
(void(*)(void *)) stList_destruct);
for (int64_t i = 0; i < stList_length(cycles); i++) {
stList *cycle = stList_get(cycles, i);
if (stList_contains(cycle, adjacencySwitch->oldEdge1)) {
assert(!stList_contains(cycle, adjacencySwitch->oldEdge2));
stList_append(cyclesToMerge, cycle);
} else if (stList_contains(cycle, adjacencySwitch->oldEdge2)) {
stList_append(cyclesToMerge, cycle);
}
}
/*
* Now construct the new component and modify the list of components in place.
*/
assert(stList_length(cyclesToMerge) == 2);
stList *newComponent = stList_join(cyclesToMerge);
assert(!stList_contains(newComponent, NULL));
//Cleanup the old components
assert(stList_contains(cycles, stList_get(cyclesToMerge, 0)));
stList_removeItem(cycles, stList_get(cyclesToMerge, 0));
assert(stList_contains(cycles, stList_get(cyclesToMerge, 1)));
stList_removeItem(cycles, stList_get(cyclesToMerge, 1));
stList_destruct(cyclesToMerge);
//Now remove the old edges and add the new ones
assert(stList_contains(newComponent, adjacencySwitch->oldEdge1));
stList_removeItem(newComponent, adjacencySwitch->oldEdge1);
assert(stList_contains(newComponent, adjacencySwitch->oldEdge2));
stList_removeItem(newComponent, adjacencySwitch->oldEdge2);
assert(!stList_contains(newComponent, adjacencySwitch->newEdge1));
stList_append(newComponent, adjacencySwitch->newEdge1);
assert(!stList_contains(newComponent, adjacencySwitch->newEdge2));
stList_append(newComponent, adjacencySwitch->newEdge2);
adjacencySwitch_destruct(adjacencySwitch); //Clean the adjacency switch.
//Finally add the component to the list of components
stList_append(cycles, newComponent);
}
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_stPosetAlignment_addAndIsPossible(CuTest *testCase) {
for(int64_t trial=0; trial<100; trial++) {
setup();
//Make random number of sequences.
stList *sequenceLengths = stList_construct3(0, (void (*)(void *))stIntTuple_destruct);
for(int64_t i=0; i<sequenceNumber; i++) {
stList_append(sequenceLengths, stIntTuple_construct1( st_randomInt(0, MAX_SEQUENCE_SIZE)));
}
//Propose random alignment pairs...
stList *pairs = stList_construct3(0, (void(*)(void *))stIntTuple_destruct);
int64_t maxAlignedPairs = st_randomInt(0, MAX_ALIGNMENTS);
if(sequenceNumber > 0) {
for(int64_t i=0; i<maxAlignedPairs; i++) {
int64_t seq1 = st_randomInt(0, sequenceNumber);
int64_t seqLength1 = stIntTuple_get(stList_get(sequenceLengths, seq1), 0);
if(seqLength1 == 0) {
continue;
}
int64_t position1 = st_randomInt(0, seqLength1);
int64_t seq2 = st_randomInt(0, sequenceNumber);
int64_t seqLength2 = stIntTuple_get(stList_get(sequenceLengths, seq1), 0);
if(seqLength2 == 0) {
continue;
}
int64_t position2 = st_randomInt(0, seqLength2);
if(seq1 != seq2) {
stList_append(pairs, stIntTuple_construct4( seq1, position1, seq2, position2));
if(stPosetAlignment_isPossible(posetAlignment, seq1, position1, seq2, position2)) {
st_logInfo("In %" PRIi64 " %" PRIi64 " %" PRIi64 " %" PRIi64 " \n", seq1, position1, seq2, position2);
//For each accepted pair check it doesn't create a cycle.
CuAssertTrue(testCase, !containsACycle(pairs, sequenceNumber));
CuAssertTrue(testCase, stPosetAlignment_add(posetAlignment, seq1, position1, seq2, position2));
}
else {
st_logInfo("Out %" PRIi64 " %" PRIi64 " %" PRIi64 " %" PRIi64 " \n", seq1, position1, seq2, position2);
//For each rejected pair check it creates a cycle..
CuAssertTrue(testCase, containsACycle(pairs, sequenceNumber));
CuAssertTrue(testCase, !stPosetAlignment_isPossible(posetAlignment, seq1, position1, seq2, position2));
stIntTuple_destruct(stList_pop(pairs)); //remove the pair which created the cycle.
CuAssertTrue(testCase, !containsACycle(pairs, sequenceNumber)); //Check we're back to being okay..
}
}
}
}
//Cleanup
stList_destruct(sequenceLengths);
stList_destruct(pairs);
teardown();
st_logInfo("Passed a random ordering test with %" PRIi64 " sequences and %" PRIi64 " aligned pairs\n", sequenceNumber, maxAlignedPairs);
}
}
/*
* Fill in a hashtable which to every node associates
* alist of lifted edges
*/
static stHash *buildFaces_computeLiftedEdges(Flower * flower) {
stHash *liftedEdgesTable = stHash_construct3(buildFaces_hashfunction,
buildFaces_key_eq_fn, NULL, buildFaces_destructValue);
Flower_CapIterator *iter = flower_getCapIterator(flower);
Cap *cap, *attachedAncestor;
Cap *adjacency, *adjacencyAncestor;
stList *liftedEdges;
LiftedEdge *liftedEdge;
// Iterate through potential bottom nodes
while ((cap = flower_getNextCap(iter))) {
// ... check if connected
if ((adjacency = cap_getAdjacency(cap))) {
// ... lift
attachedAncestor = cap_getTopCap(cap);
adjacencyAncestor = cap_getTopCap(cap_getPositiveOrientation(
adjacency));
#ifndef NDEBUG
assert((attachedAncestor && adjacencyAncestor) || (!attachedAncestor && !adjacencyAncestor));
#endif
// If root node
if (attachedAncestor == NULL)
continue;
// ... create lifted edge
liftedEdge = st_malloc(sizeof(LiftedEdge));
liftedEdge->destination = adjacencyAncestor;
liftedEdge->bottomNode = cap;
#ifndef NDEBUG
// Self loop
if (adjacencyAncestor == attachedAncestor)
abort();
#endif
// ... add it to the hashtable
if ((liftedEdges
= stHash_search(liftedEdgesTable, attachedAncestor))) {
stList_append(liftedEdges, liftedEdge);
} else {
liftedEdges = stList_construct3(2,
buildFaces_stList_destructElem);
stList_append(liftedEdges, liftedEdge);
stHash_insert(liftedEdgesTable, attachedAncestor, liftedEdges);
}
}
}
flower_destructCapIterator(iter);
return liftedEdgesTable;
}
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);
}
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;
}
static stList *readMatching(FILE *fileHandle, stList *originalEdges) {
/*
* Reads the matching created by Blossum.
*/
stHash *originalEdgesHash = putEdgesInHash(originalEdges);
char *line = stFile_getLineFromFile(fileHandle);
assert(line != NULL);
int64_t nodeNumber, edgeNumber;
int64_t i = sscanf(line, "%" PRIi64 " %" PRIi64 "\n", &nodeNumber, &edgeNumber);
assert(i == 2);
free(line);
stList *chosenEdges = stList_construct();
for(int64_t j=0; j<edgeNumber; j++) {
line = stFile_getLineFromFile(fileHandle);
int64_t node1, node2;
i = sscanf(line, "%" PRIi64 " %" PRIi64 "", &node1, &node2);
assert(i == 2);
free(line);
assert(node1 >= 0);
assert(node1 < nodeNumber);
assert(node2 >= 0);
assert(node2 < nodeNumber);
stIntTuple *edge = constructEdge(node1, node2);
stIntTuple *originalEdge = stHash_search(originalEdgesHash, edge);
if(originalEdge != NULL) {
stList_append(chosenEdges, originalEdge);
}
stIntTuple_destruct(edge);
}
stHash_destruct(originalEdgesHash);
return chosenEdges;
}
/*
* Recursive function which fills a givenlist with the
* connected nodes within a module
*/
static void buildFaces_fillTopNodeList(Cap * cap, stList *list,
stHash *liftedEdgesTable) {
stList *liftedEdges;
int64_t index;
// Limit of recursion
if (stList_contains(list, cap))
return;
// Actual filling
st_logInfo("Adding cap %p to face\n", cap);
stList_append(list, cap);
// Recursion through lifted edges
if ((liftedEdges = stHash_search(liftedEdgesTable, cap)))
for (index = 0; index < stList_length(liftedEdges); index++)
buildFaces_fillTopNodeList(
((LiftedEdge *) stList_get(liftedEdges, index))->destination,
list, liftedEdgesTable);
// Recursion through adjacency
if (cap_getAdjacency(cap))
buildFaces_fillTopNodeList(cap_getAdjacency(cap),list,
liftedEdgesTable);
}
static stList *getRandomPairwiseAlignments() {
stList *pairwiseAlignments = stList_construct3(0, (void(*)(void *)) destructPairwiseAlignment);
int64_t randomAlignmentNumber = st_randomInt(0, 10);
for (int64_t i = 0; i < randomAlignmentNumber; i++) {
char *contig1 = stString_print("%" PRIi64 "", i);
char *contig2 = stString_print("%" PRIi64 "", i * 10);
int64_t start1 = st_randomInt(100000, 1000000);
int64_t start2 = st_randomInt(100000, 1000000);
int64_t strand1 = st_random() > 0.5;
int64_t strand2 = st_random() > 0.5;
int64_t end1 = start1;
int64_t end2 = start2;
struct List *operationList = constructEmptyList(0, NULL);
while (st_random() > 0.1) {
int64_t length = st_randomInt(0, 10);
int64_t type = st_randomInt(0, 3);
assert(type < 3);
listAppend(operationList, constructAlignmentOperation(type, length, 0));
if (type != PAIRWISE_INDEL_Y) {
end1 += strand1 ? length : -length;
}
if (type != PAIRWISE_INDEL_X) {
end2 += strand2 ? length : -length;
}
}
stList_append(pairwiseAlignments,
constructPairwiseAlignment(contig1, start1, end1, strand1, contig2, start2, end2, strand2, 0.0, operationList));
free(contig1);
free(contig2);
}
return pairwiseAlignments;
}
void stCaf_addAdjacencies(Flower *flower) {
//Build a list of caps.
stList *list = stList_construct();
Flower_EndIterator *endIterator = flower_getEndIterator(flower);
End *end;
while ((end = flower_getNextEnd(endIterator)) != NULL) {
End_InstanceIterator *instanceIterator = end_getInstanceIterator(end);
Cap *cap;
while ((cap = end_getNext(instanceIterator)) != NULL) {
if (!cap_getStrand(cap)) {
cap = cap_getReverse(cap);
}
stList_append(list, cap);
}
end_destructInstanceIterator(instanceIterator);
}
flower_destructEndIterator(endIterator);
assert(stList_length(list) % 2 == 0);
//Sort the list of caps.
stList_sort(list, (int(*)(const void *, const void *)) addAdjacenciesPP);
//Now make the adjacencies.
for (int64_t i = 1; i < stList_length(list); i += 2) {
Cap *cap = stList_get(list, i - 1);
Cap *cap2 = stList_get(list, i);
cap_makeAdjacent(cap, cap2);
}
//Clean up.
stList_destruct(list);
}
static stList *getSubstringsForFlowerSegments(stList *flowers) {
/*
* Get the set of substrings representing the strings in the segments of the given flowers.
*/
stList *substrings = stList_construct3(0, (void (*)(void *)) substring_destruct);
for (int64_t i = 0; i < stList_length(flowers); i++) {
Flower *flower = stList_get(flowers, i);
Flower_EndIterator *blockIt = flower_getBlockIterator(flower);
Block *block;
while ((block = flower_getNextBlock(blockIt)) != NULL) {
Block_InstanceIterator *instanceIt = block_getInstanceIterator(block);
Segment *segment;
while ((segment = block_getNext(instanceIt)) != NULL) {
Sequence *sequence;
if ((sequence = segment_getSequence(segment)) != NULL) {
segment = segment_getStrand(segment) ? segment : segment_getReverse(segment);
assert(segment_getLength(segment) > 0);
stList_append(substrings,
substring_construct(sequence_getMetaSequence(sequence)->stringName,
segment_getStart(segment) - sequence_getStart(sequence),
segment_getLength(segment)));
}
}
block_destructInstanceIterator(instanceIt);
}
flower_destructBlockIterator(blockIt);
}
return substrings;
}
void test_stList_append(CuTest *testCase) {
setup();
stList_append(list, NULL);
CuAssertTrue(testCase, stList_length(list) == stringNumber+1);
CuAssertTrue(testCase, stList_get(list, stringNumber) == NULL);
teardown();
}
static void setup() {
teardown();
list = stList_construct();
int64_t i;
for(i=0; i<stringNumber; i++) {
stList_append(list, strings[i]);
}
}
void stTree_setParent(stTree *tree, stTree *parent) {
if(stTree_getParent(tree) != NULL) {
stList_removeItem(stTree_getParent(tree)->nodes, tree);
}
tree->parent = parent;
if(parent != NULL) {
stList_append(parent->nodes, tree);
}
}
stList *stSet_getKeys(stSet *set) {
stList *list = stList_construct();
stSetIterator *iterator = stSet_getIterator(set);
void *item;
while ((item = stSet_getNext(iterator)) != NULL) {
stList_append(list, item);
}
stSet_destructIterator(iterator);
return list;
}
static AdjacencySwitch *getBest2EdgeAdjacencySwitch(stList *components,
stSortedSet *allAdjacencyEdges) {
/*
* Look for the two lowest value adjacency edges in all current edges that are in a separate component and returns them as an adjacency switch
* with now new adjacency edges.
*/
/*
* Get lowest scoring edge for each component.
*/
stList *lowestScoringEdgeFromEachComponent = stList_construct();
for (int64_t i = 0; i < stList_length(components); i++) {
stList_append(lowestScoringEdgeFromEachComponent,
getLowestScoringEdge(stList_get(components, i)));
}
/*
* Get two lowest scoring edges.
*/
stList_sort(lowestScoringEdgeFromEachComponent,
getBest2EdgeAdjacencySwitchP);
stIntTuple *lowestScoreEdge1 = stList_get(
lowestScoringEdgeFromEachComponent, 0);
stIntTuple *lowestScoreEdge2 = stList_get(
lowestScoringEdgeFromEachComponent, 1);
assert(lowestScoreEdge1 != lowestScoreEdge2);
stList_destruct(lowestScoringEdgeFromEachComponent); //Cleanup
stIntTuple *newEdge1 = getWeightedEdgeFromSet(
stIntTuple_get(lowestScoreEdge1, 0),
stIntTuple_get(lowestScoreEdge2, 0), allAdjacencyEdges);
stIntTuple *newEdge2 = getWeightedEdgeFromSet(
stIntTuple_get(lowestScoreEdge1, 1),
stIntTuple_get(lowestScoreEdge2, 1), allAdjacencyEdges);
if (newEdge1 == NULL) {
assert(newEdge2 == NULL);
newEdge1 = getWeightedEdgeFromSet(
stIntTuple_get(lowestScoreEdge1, 0),
stIntTuple_get(lowestScoreEdge2, 1), allAdjacencyEdges);
newEdge2 = getWeightedEdgeFromSet(
stIntTuple_get(lowestScoreEdge1, 1),
stIntTuple_get(lowestScoreEdge2, 0), allAdjacencyEdges);
}
assert(newEdge1 != NULL);
assert(newEdge2 != NULL);
return adjacencySwitch_construct(
lowestScoreEdge1,
lowestScoreEdge2,
newEdge1,
newEdge2,
stIntTuple_get(lowestScoreEdge1, 2)
+ stIntTuple_get(lowestScoreEdge2, 2));
}
/* build a list of blocks, sorted by the root components */
static stList *buildRootSorted(struct malnSet *malnSet) {
stList *sorted = stList_construct();
struct malnBlkSetIterator *iter = malnBlkSet_getIterator(malnSet->blks);
struct malnBlk *blk;
while ((blk = malnBlkSetIterator_getNext(iter)) != NULL) {
stList_append(sorted, blk);
}
malnBlkSetIterator_destruct(iter);
stList_sort(sorted, blkCmpRootComp);
return sorted;
}
static void testBulkRemoveRecords(CuTest *testCase) {
/*
* Tests doing a bulk update of a set of records.
*/
setup();
int64_t i = 100, j = 110, k = 120, l = 130;
stKVDatabase_insertRecord(database, 1, &i, sizeof(int64_t));
stKVDatabase_insertRecord(database, 2, &j, sizeof(int64_t));
stKVDatabase_insertRecord(database, 3, &k, sizeof(int64_t));
stKVDatabase_insertRecord(database, 4, &l, sizeof(int64_t));
stKVDatabase_insertRecord(database, 5, &i, 0); //Test null record addition
CuAssertTrue(testCase, stKVDatabase_containsRecord(database, 1));
CuAssertTrue(testCase, stKVDatabase_containsRecord(database, 2));
CuAssertTrue(testCase, stKVDatabase_containsRecord(database, 3));
CuAssertTrue(testCase, stKVDatabase_containsRecord(database, 4));
CuAssertTrue(testCase, stKVDatabase_containsRecord(database, 5));
CuAssertTrue(testCase, stKVDatabase_getNumberOfRecords(database) == 5);
stList *requests = stList_construct3(0, (void(*)(void *)) stInt64Tuple_destruct);
// test empty request list
stKVDatabase_bulkRemoveRecords(database, requests);
stList_append(requests, stInt64Tuple_construct(1, (int64_t)1));
stList_append(requests, stInt64Tuple_construct(1, (int64_t)2));
stList_append(requests, stInt64Tuple_construct(1, (int64_t)3));
stList_append(requests, stInt64Tuple_construct(1, (int64_t)4));
stList_append(requests, stInt64Tuple_construct(1, (int64_t)5));
stKVDatabase_bulkRemoveRecords(database, requests);
CuAssertTrue(testCase, !stKVDatabase_containsRecord(database, 1));
CuAssertTrue(testCase, !stKVDatabase_containsRecord(database, 2));
CuAssertTrue(testCase, !stKVDatabase_containsRecord(database, 3));
CuAssertTrue(testCase, !stKVDatabase_containsRecord(database, 4));
CuAssertTrue(testCase, !stKVDatabase_containsRecord(database, 5));
CuAssertTrue(testCase, stKVDatabase_getNumberOfRecords(database) == 0);
stList_destruct(requests);
teardown();
}
void cactusDisk_addUpdateRequest(CactusDisk *cactusDisk, Flower *flower) {
int64_t recordSize;
void *vA = binaryRepresentation_makeBinaryRepresentation(flower,
(void (*)(void *, void (*)(const void * ptr, size_t size, size_t count))) flower_writeBinaryRepresentation,
&recordSize);
//Compression
vA = compress(vA, &recordSize);
if (containsRecord(cactusDisk, flower_getName(flower))) {
int64_t recordSize2;
void *vA2 = stCache_getRecord(cactusDisk->cache, flower_getName(flower), 0, INT64_MAX, &recordSize2);
if (!stCache_recordsIdentical(vA, recordSize, vA2, recordSize2)) { //Only rewrite if we actually did something
stList_append(cactusDisk->updateRequests,
stKVDatabaseBulkRequest_constructUpdateRequest(flower_getName(flower), vA, recordSize));
}
free(vA2);
} else {
stList_append(cactusDisk->updateRequests,
stKVDatabaseBulkRequest_constructInsertRequest(flower_getName(flower), vA, recordSize));
}
free(vA);
}
static stList *filterListsToExclude(stList *listOfLists, stSortedSet *set) {
/*
* Takes a list of lists and returns a new list of lists whose elements are the product of applying
* filterToExclude to each member of listOfLists in the same order.
*/
stList *listOfLists2 = stList_construct3(0,
(void(*)(void *)) stList_destruct);
for (int64_t i = 0; i < stList_length(listOfLists); i++) {
stList_append(listOfLists2,
stList_filterToExclude(stList_get(listOfLists, i), set));
}
return listOfLists2;
}
int main(int argc, char *argv[]) {
//////////////////////////////////////////////
//Parse the inputs
//////////////////////////////////////////////
parseBasicArguments(argc, argv, "linkageStats");
///////////////////////////////////////////////////////////////////////////
// Get the intervals
///////////////////////////////////////////////////////////////////////////
stList *haplotypeEventStrings = getEventStrings(
treatHaplotype1AsContamination ? NULL : hap1EventString,
treatHaplotype2AsContamination ? NULL : hap2EventString);
stList *assemblyEventStringInList = stList_construct();
stList_append(assemblyEventStringInList, assemblyEventString);
stList *intervals = stList_construct3(0, (void (*)(void *))sequenceInterval_destruct);
for(int64_t i=0; i<stList_length(haplotypeEventStrings); i++) {
const char *hapEventString = stList_get(haplotypeEventStrings, i);
st_logInfo("Getting contig paths for haplotype: %s", hapEventString);
stList *contigPaths = getContigPaths(flower, hapEventString, assemblyEventStringInList);
stList *hapIntervals = getSplitContigPathIntervals(flower, contigPaths, hapEventString,
assemblyEventStringInList);
stList_destruct(contigPaths);
st_logInfo("Getting contig paths\n");
stList_appendAll(intervals, hapIntervals);
stList_setDestructor(hapIntervals, NULL);
stList_destruct(hapIntervals);
}
st_logDebug("Got a total of %" PRIi64 " intervals\n", stList_length(intervals));
///////////////////////////////////////////////////////////////////////////
// Write it out.
///////////////////////////////////////////////////////////////////////////
FILE *fileHandle = fopen(outputFile, "w");
for (int64_t i = 0; i < stList_length(intervals); i++) {
SequenceInterval *sequenceInterval = stList_get(intervals, i);
st_logDebug("We have a path interval %s %" PRIi64 " %" PRIi64 "\n", sequenceInterval->sequenceName,
sequenceInterval->start, sequenceInterval->end);
fprintf(fileHandle, "%s %" PRIi64 " %" PRIi64 "\n", sequenceInterval->sequenceName,
sequenceInterval->start, sequenceInterval->end);
}
st_logInfo("Finished writing out the stats.\n");
fclose(fileHandle);
return 0;
}
static void setup() {
teardown();
//Make nodes
nodes = stList_construct3(0, (void(*)(void *)) stIntTuple_destruct);
int64_t nodeNumber = st_randomInt(0, 1000);
for (int64_t i = 0; i < nodeNumber; i++) {
stList_append(nodes, stIntTuple_construct1( i));
}
//Make edges
edges = stList_construct3(0, (void(*)(void *)) stIntTuple_destruct);
float edgeProb = st_random();
for (int64_t i = 0; i < nodeNumber; i++) {
for (int64_t j = i; j < nodeNumber; j++) {
if (st_random() <= edgeProb) {
stList_append(edges, stIntTuple_construct3( st_randomInt(1, 100), i, j));
}
}
}
//Max component size
maxComponentSize = 1 + log(nodeNumber) * 10; //(st_randomInt(0, nodeNumber+1);
}
static stList *getOddToEvenAdjacencyEdges(stSortedSet *oddNodes,
stList *adjacencyEdges) {
/*
* Gets edges that include one node in the set of oddNodes, but not both.
*/
stList *oddToEvenAdjacencyEdges = stList_construct();
for (int64_t i = 0; i < stList_length(adjacencyEdges); i++) {
stIntTuple *edge = stList_get(adjacencyEdges, i);
if (nodeInSet(oddNodes, stIntTuple_get(edge, 0)) ^ nodeInSet(
oddNodes, stIntTuple_get(edge, 1))) {
stList_append(oddToEvenAdjacencyEdges, edge);
}
}
return oddToEvenAdjacencyEdges;
}
static void getMaximalHaplotypePathsP3(Segment *segment,
stList *maximalHaplotypePath, stSortedSet *segmentSet, stList *eventStrings) {
stList_append(maximalHaplotypePath, segment);
assert(stSortedSet_search(segmentSet, segment) == NULL);
assert(stSortedSet_search(segmentSet, segment_getReverse(segment)) == NULL);
stSortedSet_insert(segmentSet, segment);
Cap *_3Cap = segment_get3Cap(segment);
if (trueAdjacency(_3Cap, eventStrings)) { //Continue on..
Segment *otherSegment = getAdjacentCapsSegment(_3Cap);
if (otherSegment != NULL) {
getMaximalHaplotypePathsP3(otherSegment, maximalHaplotypePath,
segmentSet, eventStrings);
}
}
}
static void test_stSet_removeAndFreeKey(CuTest* testCase) {
stSet *set2 = stSet_construct2(free);
stList *keys = stList_construct();
int64_t keyNumber = 1000;
for (int64_t i = 0; i < keyNumber; i++) {
int64_t *key = st_malloc(sizeof(*key));
stList_append(keys, key);
stSet_insert(set2, key);
}
for (int64_t i = 0; i < keyNumber; i++) {
int64_t *key = stList_get(keys, i);
CuAssertPtrEquals(testCase, key, stSet_removeAndFreeKey(set2, key));
}
CuAssertIntEquals(testCase, 0, stSet_size(set2));
stSet_destruct(set2);
stList_destruct(keys);
}
/*
* Fill uplist with bottom nodes for top node
*/
static void buildFaces_computeLiftedEdgesAtTopNode(Cap * cap, stList * liftedEdges) {
int64_t childIndex;
LiftedEdge * liftedEdge;
// Termination
if (cap_getAdjacency(cap)) {
liftedEdge = st_malloc(sizeof(LiftedEdge));
liftedEdge->bottomNode = cap_getPositiveOrientation(cap);
liftedEdge->destination = cap_getPositiveOrientation(cap_getTopCap(cap_getAdjacency(cap)));
stList_append(liftedEdges, liftedEdge);
return;
}
// Recursion through children
for (childIndex = 0; childIndex < cap_getChildNumber(cap); childIndex++)
buildFaces_computeLiftedEdgesAtTopNode(cap_getChild(cap, childIndex), liftedEdges);
}
