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 linked(Segment *segmentX, Segment *segmentY, int64_t difference,
const char *eventString, bool *aligned) {
assert(segment_getStrand(segmentX));
assert(segment_getStrand(segmentY));
*aligned = 0;
if (segment_getStart(segmentX) < segment_getStart(segmentY)) {
Block *blockX = segment_getBlock(segmentX);
Block *blockY = segment_getBlock(segmentY);
Block_InstanceIterator *instanceItX = block_getInstanceIterator(blockX);
Segment *segmentX2;
while ((segmentX2 = block_getNext(instanceItX)) != NULL) {
if (strcmp(event_getHeader(segment_getEvent(segmentX2)),
eventString) == 0) {
Block_InstanceIterator *instanceItY =
block_getInstanceIterator(blockY);
Segment *segmentY2;
while ((segmentY2 = block_getNext(instanceItY)) != NULL) {
if (strcmp(event_getHeader(segment_getEvent(segmentY2)),
eventString) == 0) {
*aligned = 1;
if (sequence_getMetaSequence(
segment_getSequence(segmentX2))
== sequence_getMetaSequence(
segment_getSequence(segmentY2))) { //Have the same assembly sequence
//Now check if the two segments are connected by a path of adjacency from the 3' end of segmentX to the 5' end of segmentY.
int64_t separationDistance;
if (capsAreAdjacent(segment_get3Cap(segmentX2),
segment_get5Cap(segmentY2),
&separationDistance)) {
//if(difference < 10000 || (separationDistance <= difference * 1.5 && difference <= separationDistance * 1.5)) {
block_destructInstanceIterator(instanceItX);
block_destructInstanceIterator(instanceItY);
return 1;
//}
}
}
}
}
block_destructInstanceIterator(instanceItY);
}
}
block_destructInstanceIterator(instanceItX);
} else {
assert(segmentX == segmentY);
if(hasCapInEvent(block_get5End(segment_getBlock(segmentX)),
eventString)) {
*aligned = 1;
return 1;
}
}
return 0;
}
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;
}
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;
}
Segment *block_splitP(Segment *segment,
Block *leftBlock, Block *rightBlock) {
Segment *leftSegment = segment_getSequence(segment) != NULL
? segment_construct2(leftBlock, segment_getStart(segment), segment_getStrand(segment), segment_getSequence(segment))
: segment_construct(leftBlock, segment_getEvent(segment));
Segment *rightSegment = segment_getSequence(segment) != NULL
? segment_construct2(rightBlock, segment_getStart(segment) + block_getLength(leftBlock), segment_getStrand(segment), segment_getSequence(segment))
: segment_construct(rightBlock, segment_getEvent(segment));
//link together.
cap_makeAdjacent(segment_get3Cap(leftSegment), segment_get5Cap(rightSegment));
//update adjacencies.
Cap *_5Cap = segment_get5Cap(segment);
Cap *new5Cap = segment_get5Cap(leftSegment);
Cap *_3Cap = segment_get3Cap(segment);
Cap *new3Cap = segment_get3Cap(rightSegment);
if(cap_getAdjacency(_5Cap) != NULL) {
cap_makeAdjacent(cap_getAdjacency(_5Cap), new5Cap);
}
if(cap_getAdjacency(_3Cap) != NULL) {
cap_makeAdjacent(cap_getAdjacency(_3Cap), new3Cap);
}
return leftSegment;
}
static int segmentCompareFn(const void *segment1, const void *segment2) {
Name name1 = segment1 == &segmentCompareFn_coordinate ? segmentCompareFn_metaSequence : metaSequence_getName(sequence_getMetaSequence(segment_getSequence((Segment *)segment1)));
Name name2 = segment2 == &segmentCompareFn_coordinate ? segmentCompareFn_metaSequence : metaSequence_getName(sequence_getMetaSequence(segment_getSequence((Segment *)segment2)));
int i = cactusMisc_nameCompare(name1, name2);
if(i == 0) {
int64_t
x =
segment1 == &segmentCompareFn_coordinate ? segmentCompareFn_coordinate
: (int64_t) segment_getStart((void *) segment1);
int64_t
y =
segment2 == &segmentCompareFn_coordinate ? segmentCompareFn_coordinate
: (int64_t) segment_getStart((void *) segment2);
assert(
segment1 == &segmentCompareFn_coordinate || segment_getStrand(
(void *) segment1));
assert(
segment2 == &segmentCompareFn_coordinate || segment_getStrand(
(void *) segment2));
return x > y ? 1 : (x < y ? -1 : 0); //i > 0 ? 1 : i < 0 ? -1 : 0; //This was because of an overflow
}
return i;
}