static void recenterLocalScaffold(Node * node, Coordinate oldLength)
{
MiniConnection *localConnect;
Coordinate distance_shift = (getNodeLength(node) - oldLength) / 2;
Coordinate min_distance =
getNodeLength(node) / 2 - BACKTRACK_CUTOFF;
NodeList *nodeList, *next;
IDnum node2ID;
Node *node2;
for (nodeList = markedNodes; nodeList != NULL; nodeList = next) {
next = nodeList->next;
node2 = nodeList->node;
if (node2 == node) {
setSingleNodeStatus(node2, 1);
continue;
}
node2ID = getNodeID(node2);
localConnect = &localScaffold[node2ID + nodeCount(graph)];
localConnect->distance -= distance_shift;
if (localConnect->distance < min_distance
&& localConnect->backReference == NULL
&& localConnect->frontReference == NULL)
unmarkNode(node2, localConnect);
else if (getNodeStatus(node2) > 0)
setSingleNodeStatus(node2, 1);
else if (getNodeStatus(node2) < 0)
setSingleNodeStatus(node2, -1);
}
}
void EliminateSmallBranches::unmarkNode(vtkIdType id_node, int layer)
{
if (layer <= m_NumLayers+2) {
for (int i = 0; i < m_Part.n2cGSize(id_node); ++i) {
vtkIdType id_cell = m_Part.n2cGG(id_node, i);
if (isVolume(id_cell, m_Grid)) {
m_DeleteCell[id_cell] = false;
}
}
for (int i = 0; i < m_Part.n2nGSize(id_node); ++i) {
unmarkNode(m_Part.n2nGG(id_node, i), layer+1);
}
}
}
static void recenterNode(Node * node, Coordinate oldLength)
{
IDnum nodeID = getNodeID(node);
Connection *connect, *next;
Coordinate distance_shift = (getNodeLength(node) - oldLength) / 2;
Coordinate min_distance =
getNodeLength(node) / 2 - BACKTRACK_CUTOFF;
MiniConnection *localConnect;
//velvetLog("Recentering node\n");
for (connect = getConnection(node); connect != NULL;
connect = next) {
next = getNextConnection(connect);
incrementConnectionDistance(connect, -distance_shift);
if (getConnectionDistance(connect) < min_distance) {
//velvetLog("Unrecording %li\n",
// -getNodeID(getConnectionDestination(connect)));
localConnect =
&localScaffold[-getNodeID(getConnectionDestination(connect))
+ nodeCount(graph)];
localConnect->frontReference = NULL;
unmarkNode(getTwinNode(getConnectionDestination(connect)),
localConnect);
destroyConnection(connect, nodeID);
} else if (getTwinConnection(connect) != NULL)
incrementConnectionDistance(getTwinConnection(connect), -distance_shift);
}
for (connect = getConnection(getTwinNode(node)); connect != NULL;
connect = next) {
next = getNextConnection(connect);
incrementConnectionDistance(connect, distance_shift);
if (getTwinConnection(connect) != NULL)
incrementConnectionDistance(getTwinConnection(connect), distance_shift);
}
}
static boolean pushNeighbours(Node * node, Node * oppositeNode,
Coordinate distance, boolean force_jumps)
{
Node *candidate;
Coordinate oldLength = getNodeLength(node);
MiniConnection *localConnect;
NodeList *path, *tmp;
if ((path = pathIsClear(node, oppositeNode, distance))) {
while (path) {
candidate = path->node;
tmp = path->next;
deallocateNodeList(path);
path = tmp;
///////////////////////////////////////
// Stepping forward to destination //
///////////////////////////////////////
if (getUniqueness(candidate)) {
concatenateReadStarts(node, candidate,
graph);
concatenateLongReads(node, candidate,
graph);
absorbExtension(node, candidate);
// Scaffold changes
recenterNode(node, oldLength);
recenterLocalScaffold(node, oldLength);
absorbExtensionInScaffold(node, candidate);
// Read coverage
#ifndef SINGLE_COV_CAT
Category cat;
for (cat = 0; cat < CATEGORIES; cat++) {
incrementVirtualCoverage(node, cat,
getVirtualCoverage(candidate, cat));
incrementOriginalVirtualCoverage(node, cat,
getOriginalVirtualCoverage(candidate, cat));
}
#else
incrementVirtualCoverage(node, getVirtualCoverage(candidate));
#endif
if (getNodeStatus(candidate)) {
localConnect =
&localScaffold[getNodeID
(candidate) +
nodeCount
(graph)];
if (localConnect->frontReference) {
destroyConnection
(localConnect->
frontReference,
getNodeID(node));
localConnect->
frontReference = NULL;
}
if (localConnect->backReference) {
destroyConnection
(localConnect->
backReference,
-getNodeID(node));
localConnect->
backReference = NULL;
}
unmarkNode(candidate,
localConnect);
}
if (getNodeStatus(getTwinNode(candidate))) {
localConnect =
&localScaffold[-getNodeID
(candidate) +
nodeCount
(graph)];
if (localConnect->frontReference) {
destroyConnection
(localConnect->
frontReference,
getNodeID(node));
localConnect->
frontReference = NULL;
}
if (localConnect->backReference) {
destroyConnection
(localConnect->
backReference,
-getNodeID(node));
localConnect->
backReference = NULL;
}
unmarkNode(getTwinNode(candidate),
localConnect);
}
destroyNode(candidate, graph);
return true;
} else {
adjustShortReads(node, candidate);
adjustLongReads(node, getNodeLength(candidate));
absorbExtension(node, candidate);
}
}
}
if (force_jumps && oppositeNode
&& abs_ID(getNodeID(oppositeNode)) < abs_ID(getNodeID(node))) {
distance -= getNodeLength(node) / 2;
distance -= getNodeLength(oppositeNode) / 2;
if (distance > 10) {
adjustShortReadsByLength(node, distance);
adjustLongReads(node, distance);
appendGap(node, distance, graph);
} else {
adjustShortReadsByLength(node, 10);
adjustLongReads(node, 10);
appendGap(node, 10, graph);
}
concatenateReadStarts(node, oppositeNode, graph);
concatenateLongReads(node, oppositeNode, graph);
absorbExtension(node, oppositeNode);
// Scaffold changes
recenterNode(node, oldLength);
recenterLocalScaffold(node, oldLength);
absorbExtensionInScaffold(node, oppositeNode);
// Read coverage
#ifndef SINGLE_COV_CAT
Category cat;
for (cat = 0; cat < CATEGORIES; cat++)
incrementVirtualCoverage(node, cat,
getVirtualCoverage(oppositeNode, cat));
#else
incrementVirtualCoverage(node, getVirtualCoverage(oppositeNode));
#endif
if (getNodeStatus(oppositeNode)) {
localConnect =
&localScaffold[getNodeID(oppositeNode) +
nodeCount(graph)];
if (localConnect->frontReference) {
destroyConnection(localConnect->
frontReference,
getNodeID(node));
localConnect->frontReference = NULL;
}
if (localConnect->backReference) {
destroyConnection(localConnect->
backReference,
-getNodeID(node));
localConnect->backReference = NULL;
}
unmarkNode(oppositeNode, localConnect);
}
if (getNodeStatus(getTwinNode(oppositeNode))) {
localConnect =
&localScaffold[-getNodeID(oppositeNode) +
nodeCount(graph)];
if (localConnect->frontReference) {
destroyConnection(localConnect->
frontReference,
getNodeID(node));
localConnect->frontReference = NULL;
}
if (localConnect->backReference) {
destroyConnection(localConnect->
backReference,
-getNodeID(node));
localConnect->backReference = NULL;
}
unmarkNode(getTwinNode(oppositeNode),
localConnect);
}
destroyNode(oppositeNode, graph);
}
return false;
}
static void absorbExtensionInScaffold(Node * node, Node * source)
{
IDnum nodeID = getNodeID(node);
IDnum sourceID = getNodeID(source);
IDnum sourceIndex = sourceID + nodeCount(graph);
Node *twinSource = getTwinNode(source);
IDnum twinSourceIndex = getNodeID(twinSource) + nodeCount(graph);
Connection *connect, *original;
Node *destination;
IDnum destinationID;
Coordinate distance_shift =
(getNodeLength(node) - getNodeLength(source)) / 2;
Coordinate min_distance =
getNodeLength(node) / 2 - BACKTRACK_CUTOFF;
MiniConnection *localConnect;
Coordinate distance;
double variance;
IDnum direct_count;
IDnum paired_count;
while ((connect = getConnection(source))) {
destination = getTwinNode(getConnectionDestination(connect));
if (destination == getTwinNode(node)) {
localConnect = &localScaffold[twinSourceIndex];
localConnect->frontReference = NULL;
unmarkNode(twinSource, localConnect);
destroyConnection(connect, sourceID);
continue;
}
if (destination == node) {
localConnect = &localScaffold[sourceIndex];
localConnect->backReference = NULL;
unmarkNode(source, localConnect);
destroyConnection(connect, sourceID);
continue;
}
destinationID = getNodeID(destination);
localConnect =
&localScaffold[destinationID + nodeCount(graph)];
incrementConnectionDistance(connect, distance_shift);
distance = getConnectionDistance(connect);
variance = getConnectionVariance(connect);
direct_count = getConnectionDirectCount(connect);
paired_count = getConnectionPairedCount(connect);
if (getNodeStatus(destination)) {
readjustMiniConnection(destination, localConnect,
distance, min_distance,
variance, NULL, NULL);
if ((original = localConnect->frontReference))
readjustConnection(original, distance,
variance, direct_count,
paired_count);
else
localConnect->frontReference =
createNewConnection(nodeID,
-destinationID,
direct_count,
paired_count,
distance,
variance);
} else
resetMiniConnection(destination, localConnect,
distance, variance,
createNewConnection(nodeID,
-destinationID,
direct_count,
paired_count,
distance,
variance),
NULL, true);
integrateDerivativeDistances(connect, min_distance, true);
destroyConnection(connect, sourceID);
}
// Loop thru twin's primary scaffold
while ((connect = getConnection(getTwinNode(source)))) {
destination = getConnectionDestination(connect);
if (destination == node) {
localConnect = &localScaffold[sourceIndex];
localConnect->frontReference = NULL;
unmarkNode(source, localConnect);
destroyConnection(connect, -sourceID);
continue;
}
if (destination == getTwinNode(node)) {
localConnect = &localScaffold[twinSourceIndex];
localConnect->backReference = NULL;
unmarkNode(twinSource, localConnect);
destroyConnection(connect, -sourceID);
continue;
}
destinationID = getNodeID(destination);
localConnect =
&localScaffold[destinationID + nodeCount(graph)];
incrementConnectionDistance(connect, -distance_shift);
distance = getConnectionDistance(connect);
variance = getConnectionVariance(connect);
direct_count = getConnectionDirectCount(connect);
paired_count = getConnectionPairedCount(connect);
if (distance > min_distance && getNodeStatus(destination) < 0) {
readjustMiniConnection(destination, localConnect,
-distance, min_distance,
variance, NULL, NULL);
if ((original = localConnect->backReference))
readjustConnection(original, distance,
variance, direct_count,
paired_count);
} else if (getNodeStatus(destination) < 0) {
if ((original = localConnect->backReference)) {
destroyConnection(original, -nodeID);
localConnect->backReference = NULL;
}
unmarkNode(destination, localConnect);
} else if (getNodeStatus(destination) > 0) {
if ((original = localConnect->frontReference)) {
destroyConnection(original, nodeID);
localConnect->frontReference = NULL;
}
unmarkNode(destination, localConnect);
} else if (distance > min_distance) {
resetMiniConnection(destination, localConnect,
-distance, variance, NULL,
createNewConnection(-nodeID,
destinationID,
direct_count,
paired_count,
distance,
variance),
-1);
integrateDerivativeDistances(connect, min_distance, true);
}
destroyConnection(connect, -sourceID);
}
}
