static void projectFromNode(IDnum nodeID,
ReadOccurence ** readNodes,
IDnum * readNodeCounts,
IDnum * readPairs, Category * cats,
boolean * dubious, Coordinate * lengths)
{
IDnum index;
ShortReadMarker *nodeArray, *shortMarker;
PassageMarker *marker;
Node *node;
IDnum nodeReadCount;
node = getNodeInGraph(graph, nodeID);
if (node == NULL || !getUniqueness(node))
return;
nodeArray = getNodeReads(node, graph);
nodeReadCount = getNodeReadCount(node, graph);
for (index = 0; index < nodeReadCount; index++) {
shortMarker = getShortReadMarkerAtIndex(nodeArray, index);
if (dubious[getShortReadMarkerID(shortMarker) - 1])
continue;
projectFromShortRead(node, shortMarker, readPairs, cats,
readNodes, readNodeCounts, lengths);
}
for (marker = getMarker(node); marker != NULL;
marker = getNextInNode(marker)) {
if (getPassageMarkerSequenceID(marker) > 0)
projectFromLongRead(node, marker, readPairs, cats,
readNodes, readNodeCounts,
lengths);
}
}
static void computePartialReadToNodeMapping(IDnum nodeID,
ReadOccurence ** readNodes,
IDnum * readNodeCounts,
boolean * readMarker,
ReadSet * reads)
{
ShortReadMarker *shortMarker;
IDnum index, readIndex;
ReadOccurence *readArray, *readOccurence;
Node *node = getNodeInGraph(graph, nodeID);
ShortReadMarker *nodeArray = getNodeReads(node, graph);
IDnum nodeReadCount = getNodeReadCount(node, graph);
PassageMarkerI marker;
for (index = 0; index < nodeReadCount; index++) {
shortMarker = getShortReadMarkerAtIndex(nodeArray, index);
readIndex = getShortReadMarkerID(shortMarker);
readArray = readNodes[readIndex];
readOccurence = &readArray[readNodeCounts[readIndex]];
readOccurence->nodeID = nodeID;
readOccurence->position =
getShortReadMarkerPosition(shortMarker);
readOccurence->offset =
getShortReadMarkerOffset(shortMarker);
readNodeCounts[readIndex]++;
}
for (marker = getMarker(node); marker != NULL_IDX;
marker = getNextInNode(marker)) {
readIndex = getPassageMarkerSequenceID(marker);
if (readIndex <= 0 || reads->categories[readIndex - 1] == REFERENCE)
continue;
if (!readMarker[readIndex]) {
readArray = readNodes[readIndex];
readOccurence =
&readArray[readNodeCounts[readIndex]];
readOccurence->nodeID = nodeID;
readOccurence->position = getStartOffset(marker);
readOccurence->offset =
getPassageMarkerStart(marker);
readNodeCounts[readIndex]++;
readMarker[readIndex] = true;
} else {
readArray = readNodes[readIndex];
readOccurence =
&readArray[readNodeCounts[readIndex] - 1];
readOccurence->position = -1;
readOccurence->offset = -1;
}
}
for (marker = getMarker(node); marker != NULL_IDX;
marker = getNextInNode(marker)) {
readIndex = getPassageMarkerSequenceID(marker);
if (readIndex > 0)
readMarker[readIndex] = false;
}
}
static IDnum *computeReadToNodeCounts()
{
IDnum readIndex, nodeIndex;
IDnum maxNodeIndex = 2 * nodeCount(graph) + 1;
IDnum maxReadIndex = sequenceCount(graph) + 1;
IDnum *readNodeCounts = callocOrExit(maxReadIndex, IDnum);
boolean *readMarker = callocOrExit(maxReadIndex, boolean);
ShortReadMarker *nodeArray, *shortMarker;
PassageMarkerI marker;
Node *node;
IDnum nodeReadCount;
//puts("Computing read to node mapping array sizes");
for (nodeIndex = 0; nodeIndex < maxNodeIndex; nodeIndex++) {
node = getNodeInGraph(graph, nodeIndex - nodeCount(graph));
if (node == NULL)
continue;
// Short reads
if (readStartsAreActivated(graph)) {
nodeArray = getNodeReads(node, graph);
nodeReadCount = getNodeReadCount(node, graph);
for (readIndex = 0; readIndex < nodeReadCount; readIndex++) {
shortMarker =
getShortReadMarkerAtIndex(nodeArray,
readIndex);
readNodeCounts[getShortReadMarkerID
(shortMarker)]++;
}
}
// Long reads
for (marker = getMarker(node); marker != NULL_IDX;
marker = getNextInNode(marker)) {
readIndex = getPassageMarkerSequenceID(marker);
if (readIndex < 0)
continue;
if (readMarker[readIndex])
continue;
readNodeCounts[readIndex]++;
readMarker[readIndex] = true;
}
// Clean up marker array
for (marker = getMarker(node); marker != NULL_IDX;
marker = getNextInNode(marker)) {
readIndex = getPassageMarkerSequenceID(marker);
if (readIndex > 0)
readMarker[readIndex] = false;
}
}
free(readMarker);
return readNodeCounts;
}
void concatenateReadStarts(Node * target, Node * source, Graph * graph)
{
IDnum sourceLength, targetLength;
ShortReadMarker *sourceArray, *targetArray, *marker;
IDnum index;
Coordinate position, nodeLength;
if (!readStartsAreActivated(graph))
return;
if (target == NULL || source == NULL)
return;
// Update Coordinates
sourceArray = getNodeReads(source, graph);
sourceLength = getNodeReadCount(source, graph);
nodeLength = getNodeLength(target);
for (index = 0; index < sourceLength; index++) {
marker = getShortReadMarkerAtIndex(sourceArray, index);
position = getShortReadMarkerPosition(marker);
if (position != -1) {
position += nodeLength;
setShortReadMarkerPosition(marker, position);
}
}
// Same but for symmetrical reads
targetArray = getNodeReads(getTwinNode(target), graph);
targetLength = getNodeReadCount(getTwinNode(target), graph);
nodeLength = getNodeLength(source);
for (index = 0; index < targetLength; index++) {
marker = getShortReadMarkerAtIndex(targetArray, index);
position = getShortReadMarkerPosition(marker);
if (position != -1) {
position += nodeLength;
setShortReadMarkerPosition(marker, position);
}
}
// Merging lists
mergeNodeReads(target, source, graph);
mergeNodeReads(getTwinNode(target), getTwinNode(source), graph);
}
static void adjustShortReadsByLength(Node * target, Coordinate nodeLength)
{
ShortReadMarker *targetArray, *marker;
IDnum targetLength, index;
Coordinate position;
if (!readStartsAreActivated(graph))
return;
targetArray = getNodeReads(getTwinNode(target), graph);
targetLength = getNodeReadCount(getTwinNode(target), graph);
for (index = 0; index < targetLength; index++) {
marker = getShortReadMarkerAtIndex(targetArray, index);
position = getShortReadMarkerPosition(marker);
if (position != -1) {
position += nodeLength;
setShortReadMarkerPosition(marker, position);
}
}
}