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 testCap_segmentCoordinatesReverseStrand(CuTest* testCase) {
/*
* Tests the coordinates of an segment and its 5 and 3 prime caps.
*/
cactusCapTestSetup();
Block *block = block_construct(3, flower);
Segment *segment = segment_construct2(block, 2, 0, sequence);
Cap *_5Cap = segment_get5Cap(segment);
Cap *_3Cap = segment_get3Cap(segment);
CuAssertTrue(testCase, cap_getSide(_5Cap));
CuAssertTrue(testCase, !cap_getSide(_3Cap));
CuAssertTrue(testCase, !cap_getStrand(_5Cap));
CuAssertTrue(testCase, !cap_getStrand(_3Cap));
CuAssertIntEquals(testCase, 4, cap_getCoordinate(_5Cap));
CuAssertIntEquals(testCase, 2, cap_getCoordinate(_3Cap));
CuAssertTrue(testCase, !segment_getStrand(segment));
CuAssertIntEquals(testCase, 4, segment_getStart(segment));
CuAssertIntEquals(testCase, 3, segment_getLength(segment));
CuAssertTrue(testCase, !cap_getSide(cap_getReverse(_5Cap)));
CuAssertTrue(testCase, cap_getSide(cap_getReverse(_3Cap)));
CuAssertTrue(testCase, cap_getStrand(cap_getReverse(_5Cap)));
CuAssertTrue(testCase, cap_getStrand(cap_getReverse(_3Cap)));
CuAssertIntEquals(testCase, 4, cap_getCoordinate(cap_getReverse(_5Cap)));
CuAssertIntEquals(testCase, 2, cap_getCoordinate(cap_getReverse(_3Cap)));
CuAssertTrue(testCase, segment_getStrand(segment_getReverse(segment)));
CuAssertIntEquals(testCase, 2, segment_getStart(segment_getReverse(segment)));
CuAssertIntEquals(testCase, 3, segment_getLength(segment_getReverse(segment)));
cactusCapTestTeardown();
}
void printPositions(stList *positions, const char *substitutionType, FILE *fileHandle) {
for (int64_t i = 0; i < stList_length(positions); i++) {
SegmentHolder *segmentHolder = stList_get(positions, i);
int64_t j = segment_getStart(segmentHolder->segment);
if (segment_getStrand(segmentHolder->segment)) {
j += segmentHolder->offset;
assert(
cap_getCoordinate(segment_get5Cap(segmentHolder->segment)) == segment_getStart(
segmentHolder->segment));
assert(
segment_getStart(segmentHolder->segment) + segment_getLength(segmentHolder->segment) - 1
== cap_getCoordinate(segment_get3Cap(segmentHolder->segment)));
} else {
j -= segmentHolder->offset;
assert(
segment_getStart(segmentHolder->segment) - segment_getLength(segmentHolder->segment) + 1
== cap_getCoordinate(segment_get3Cap(segmentHolder->segment)));
}
fprintf(fileHandle, "%s: %s_%" PRIi64 " %" PRIi64 " %c %c %c\n", substitutionType,
event_getHeader(segment_getEvent(segmentHolder->segment)),
sequence_getLength(segment_getSequence(segmentHolder->segment)), j,
segmentHolder->base1, segmentHolder->base2, segmentHolder->base3);
getMAFBlock(segment_getBlock(segmentHolder->segment), fileHandle);
}
}
bool getCapGetAtEndOfPath(Cap *cap, Cap **pathEndCap,
int64_t *pathLength, int64_t *nCount, stList *haplotypeEventStrings, stList *contaminationEventStrings) {
//Account for length of adjacency
*pathLength += getTerminalAdjacencyLength(cap);
*nCount += getNumberOfNsInAdjacency(cap);
Segment *segment = getAdjacentCapsSegment(cap);
if (segment == NULL) {
*pathEndCap = cap_getAdjacency(getTerminalCap(cap));
assert(*pathEndCap != NULL);
return 0;
}
Cap *adjacentCap = cap_getSide(cap) ? segment_get3Cap(segment)
: segment_get5Cap(segment);
assert(
cap_getName(adjacentCap) == cap_getName(
cap_getAdjacency(getTerminalCap(cap))));
End *adjacentEnd = cap_getEnd(adjacentCap);
if (hasCapInEvents(adjacentEnd, contaminationEventStrings) || hasCapInEvents(adjacentEnd, haplotypeEventStrings)) { //hasCapNotInEvent(adjacentEnd, event_getHeader(cap_getEvent(cap)))) { //isContaminationEnd(adjacentEnd) || isHaplotypeEnd(adjacentEnd)) {
*pathEndCap = adjacentCap;
return 1;
}
*pathLength += segment_getLength(segment);
*nCount += getNumberOfNsInSegment(segment);
return getCapGetAtEndOfPath(cap_getOtherSegmentCap(adjacentCap),
pathEndCap, pathLength, nCount, haplotypeEventStrings, contaminationEventStrings);
}
static int64_t traceThreadLength(Cap *cap, Cap **terminatingCap) {
/*
* Gets the length in bases of the thread in the flower, starting from a given attached stub cap.
* The thread length includes the lengths of adjacencies that it contains.
*
* Terminating cap is initialised with the final cap on the thread from cap.
*/
assert(end_isStubEnd(cap_getEnd(cap)));
int64_t threadLength = 0;
while (1) {
assert(cap_getCoordinate(cap) != INT64_MAX);
int64_t adjacencyLength = cap_getCoordinate(cap);
threadLength += adjacencyLength;
Cap *adjacentCap = cap_getAdjacency(cap);
assert(adjacentCap != NULL);
assert(adjacencyLength == cap_getCoordinate(adjacentCap));
//Traverse any block..
if (cap_getSegment(adjacentCap) != NULL) {
threadLength += segment_getLength(cap_getSegment(adjacentCap));
cap = cap_getOtherSegmentCap(adjacentCap);
assert(cap != NULL);
} else {
assert(end_isStubEnd(cap_getEnd(adjacentCap)));
*terminatingCap = adjacentCap;
return threadLength;
}
}
return 1;
}
static int64_t setCoordinates(Flower *flower, MetaSequence *metaSequence, Cap *cap, int64_t coordinate) {
/*
* Sets the coordinates of the reference thread and sets the bases of the actual sequence
* that of the consensus.
*/
Sequence *sequence = flower_getSequence(flower, metaSequence_getName(metaSequence));
if (sequence == NULL) {
sequence = sequence_construct(metaSequence, flower);
}
while (1) {
assert(cap_getStrand(cap));
assert(!cap_getSide(cap));
Cap *adjacentCap = cap_getAdjacency(cap);
assert(adjacentCap != NULL);
assert(cap_getStrand(adjacentCap));
assert(cap_getSide(adjacentCap));
int64_t adjacencyLength = cap_getCoordinate(cap);
assert(adjacencyLength == cap_getCoordinate(adjacentCap));
assert(adjacencyLength != INT64_MAX);
assert(adjacencyLength >= 0);
cap_setCoordinates(cap, coordinate, 1, sequence);
coordinate += adjacencyLength + 1;
cap_setCoordinates(adjacentCap, coordinate, 1, sequence);
//Traverse any block..
if ((cap = cap_getOtherSegmentCap(adjacentCap)) == NULL) {
break;
}
coordinate += segment_getLength(cap_getSegment(adjacentCap)) - 1;
}
return coordinate;
}
int64_t contigPathLength(stList *haplotypePath) {
int64_t k = 0;
for (int64_t j = 0; j < stList_length(haplotypePath); j++) {
Segment *segment = stList_get(haplotypePath, j);
k += segment_getLength(segment);
}
return k;
}
static Segment *getSegment(stSortedSet *sortedSegments, int64_t x, MetaSequence *metaSequence) {
segmentCompareFn_coordinate = x;
segmentCompareFn_metaSequence = metaSequence_getName(metaSequence);
Segment *segment = stSortedSet_searchLessThanOrEqual(sortedSegments,
&segmentCompareFn_coordinate);
assert((void *) segment != &segmentCompareFn_coordinate);
if (segment != NULL) {
if(sequence_getMetaSequence(segment_getSequence(segment)) == metaSequence) {
assert(segment_getStart(segment) <= x);
if (x < segment_getStart(segment) + segment_getLength(segment)) {
return segment;
}
}
}
return NULL;
}
