void computeTranscripts(Graph * argGraph, Locus * loci, IDnum locusCount) {
IDnum index;
Locus *locus;
IDnum distribution[4];
int configuration;
double *scores = callocOrExit(2 * nodeCount(argGraph), double);
graph = argGraph;
resetNodeStatus(graph);
prepareGraphForLocalCorrections2(graph);
for (index = 0; index < locusCount; index++) {
locus = getLocus(loci, index);
setLocusStatus(locus, true);
getDegreeDistribution(locus, distribution);
configuration = hasPlausibleTranscripts(distribution);
setLocusStatus(locus, true);
addTranscriptToLocus(locus, configuration, scores);
setLocusStatus(locus, false);
}
deactivateLocalCorrectionSettings2();
free(scores);
}
void computeASEvents(Locus * loci, IDnum locusCount)
{
IDnum index;
puts("Extracting identifiable AS events");
resetNodeStatus(graph);
for (index = 0; index < locusCount; index++)
extractLocusASEvents(&(loci[index]));
}
void readCoherentGraph(Graph * inGraph, boolean(*isUnique) (Node * node),
double coverage, ReadSet * reads)
{
IDnum nodeIndex;
Node *node;
IDnum previousNodeCount = 0;
graph = inGraph;
listMemory = newRecycleBin(sizeof(PassageMarkerList), 100000);
expected_coverage = coverage;
sequences = reads->tSequences;
velvetLog("Read coherency...\n");
resetNodeStatus(graph);
identifyUniqueNodes(isUnique);
trimLongReadTips();
previousNodeCount = 0;
while (previousNodeCount != nodeCount(graph)) {
previousNodeCount = nodeCount(graph);
for (nodeIndex = 1; nodeIndex <= nodeCount(graph);
nodeIndex++) {
node = getNodeInGraph(graph, nodeIndex);
if (node == NULL || !getUniqueness(node))
continue;
while (uniqueNodesConnect(node))
node = bypass();
node = getTwinNode(node);
while (uniqueNodesConnect(node))
node = bypass();
}
renumberNodes(graph);
}
destroyRecycleBin(listMemory);
destroyRecycleBin(nodeListMemory);
velvetLog("Confronted to %li multiple hits and %li null over %li\n",
(long) multCounter, (long) nullCounter, (long) dbgCounter);
velvetLog("Read coherency over!\n");
}
bool Building::setStatus(std::string id, std::list<int>& status) {
std::lock_guard<std::mutex> lock(buildingMutex);
std::shared_ptr<Node> node = getNode(id);
if (node == NULL) {
return false;
}
if (node->getType() == Node::SWITCH && status.front() == 0) {
std::list<std::shared_ptr<Node>> afterNodes = getSubTree(id);
for (std::list<std::shared_ptr<Node>>::const_iterator iterator =
afterNodes.begin(); iterator != afterNodes.end(); ++iterator) {
resetNodeStatus(*iterator);
}
}
node->setStatus(status);
return true;
}
static IDnum countConnectedComponents(Graph * graph)
{
IDnum index;
IDnum count = 0;
Node *node;
resetNodeStatus(graph);
for (index = 1; index <= nodeCount(graph); index++) {
node = getNodeInGraph(graph, index);
if (!getNodeStatus(node) && getUniqueness(node)) {
count++;
propagateComponent(node);
}
}
return count;
}
static Locus *extractConnectedComponents(IDnum locusCount)
{
Locus *loci = allocateLocusArray(locusCount);
Locus *locus;
IDnum index;
IDnum locusIndex = 0;
IDnum nodeIndex;
Node *node;
resetNodeStatus(graph);
for (index = 1; index <= nodeCount(graph); index++) {
node = getNodeInGraph(graph, index);
if (!getNodeStatus(node) && getUniqueness(node)) {
locus = getLocus(loci, locusIndex++);
clearLocus(locus);
// Long contigs
fillUpComponent(node);
setLongContigCount(locus, countMarkedNodes());
while (existsMarkedNode())
addContig(locus, popNodeRecord());
// Secondary contigs
extendComponent(locus);
setContigCount(locus, getLongContigCount(locus) + countMarkedNodes());
while (existsMarkedNode())
addContig(locus, popNodeRecord());
// Mark primary nodes so that their twins are not reused
for (nodeIndex = 0;
nodeIndex < getLongContigCount(locus);
nodeIndex++)
setNodeStatus(getContig(locus, nodeIndex), true);
// Unmark secondary nodes so that they are available to other loci
for (nodeIndex = getLongContigCount(locus);
nodeIndex < getContigCount(locus); nodeIndex++)
setNodeStatus(getContig(locus, nodeIndex), false);
}
}
return loci;
}
static void fillUpGraph(ReadSet * reads,
KmerOccurenceTable * kmerOccurences, Graph * graph,
boolean readTracking, boolean double_strand)
{
IDnum readIndex;
Category category;
resetNodeStatus(graph);
for (readIndex = 0; readIndex < reads->readCount; readIndex++) {
category = reads->categories[readIndex];
ghostThreadSequenceThroughGraph(reads->
tSequences[readIndex],
kmerOccurences,
graph, readIndex + 1,
category,
readTracking, double_strand);
}
createNodeReadStartArrays(graph);
for (readIndex = 0; readIndex < reads->readCount; readIndex++) {
category = reads->categories[readIndex];
if (readIndex % 100000 == 0)
printf("Threading through reads %d / %d\n",
readIndex, reads->readCount);
threadSequenceThroughGraph(reads->tSequences[readIndex],
kmerOccurences,
graph, readIndex + 1, category,
readTracking, double_strand);
}
orderNodeReadStartArrays(graph);
if (smallNodeListMemory != NULL)
destroyRecycleBin(smallNodeListMemory);
free(kmerOccurences->kmerTable);
free(kmerOccurences->accelerationTable);
free(kmerOccurences);
}
void exploitShortReadPairs(Graph * argGraph,
ReadSet * reads,
boolean * dubious,
boolean * shadows,
boolean force_jumps)
{
boolean modified = true;
graph = argGraph;
if (!readStartsAreActivated(graph))
return;
velvetLog("Starting pebble resolution...\n");
resetNodeStatus(graph);
// Prepare scaffold
buildScaffold(graph, reads, dubious, shadows);
// Prepare graph
prepareGraphForLocalCorrections(graph);
// Prepare local scaffold
localScaffold =
callocOrExit(2 * nodeCount(graph) + 1, MiniConnection);
// Loop until convergence
while (modified)
modified = expandLongNodes(force_jumps);
// Clean up memory
cleanMemory();
deactivateLocalCorrectionSettings();
sortGapMarkers(graph);
velvetLog("Pebble done.\n");
}
static void fillUpGraph(ReadSet * reads,
KmerOccurenceTable * kmerTable,
Graph * graph,
boolean readTracking,
boolean double_strand,
ReferenceMapping * referenceMappings,
Coordinate referenceMappingCount,
IDnum refCount,
char * roadmapFilename)
{
IDnum readIndex;
RoadMapArray *roadmap = NULL;
Coordinate *annotationOffset = NULL;
struct timeval start, end, diff;
if (referenceMappings)
{
roadmap = importRoadMapArray(roadmapFilename);
annotationOffset = callocOrExit(reads->readCount, Coordinate);
for (readIndex = 1; readIndex < reads->readCount; readIndex++)
annotationOffset[readIndex] = annotationOffset[readIndex - 1]
+ getAnnotationCount(getRoadMapInArray(roadmap, readIndex - 1));
}
resetNodeStatus(graph);
// Allocate memory for the read pairs
if (!readStartsAreActivated(graph))
activateReadStarts(graph);
gettimeofday(&start, NULL);
#ifdef OPENMP
initSmallNodeListMemory();
createNodeLocks(graph);
#pragma omp parallel for
#endif
for (readIndex = refCount; readIndex < reads->readCount; readIndex++)
{
Annotation * annotations = NULL;
IDnum annotationCount = 0;
Category category;
boolean second_in_pair;
if (readIndex % 1000000 == 0)
velvetLog("Ghost Threading through reads %ld / %ld\n",
(long) readIndex, (long) reads->readCount);
category = reads->categories[readIndex];
second_in_pair = reads->categories[readIndex] & 1 && isSecondInPair(reads, readIndex);
if (referenceMappings)
{
annotationCount = getAnnotationCount(getRoadMapInArray(roadmap, readIndex));
annotations = getAnnotationInArray(roadmap->annotations, annotationOffset[readIndex]);
}
ghostThreadSequenceThroughGraph(getTightStringInArray(reads->tSequences, readIndex),
kmerTable,
graph, readIndex + 1,
category,
readTracking, double_strand,
referenceMappings, referenceMappingCount,
refCount, annotations, annotationCount,
second_in_pair);
}
createNodeReadStartArrays(graph);
gettimeofday(&end, NULL);
timersub(&end, &start, &diff);
velvetLog(" === Ghost-Threaded in %ld.%06ld s\n", diff.tv_sec, diff.tv_usec);
gettimeofday(&start, NULL);
#ifdef OPENMP
int threads = omp_get_max_threads();
if (threads > 32)
threads = 32;
#pragma omp parallel for num_threads(threads)
#endif
for (readIndex = 0; readIndex < reads->readCount; readIndex++)
{
Annotation * annotations = NULL;
IDnum annotationCount = 0;
Category category;
boolean second_in_pair;
if (readIndex % 1000000 == 0)
velvetLog("Threading through reads %li / %li\n",
(long) readIndex, (long) reads->readCount);
category = reads->categories[readIndex];
second_in_pair = reads->categories[readIndex] % 2 && isSecondInPair(reads, readIndex);
if (referenceMappings)
{
annotationCount = getAnnotationCount(getRoadMapInArray(roadmap, readIndex));
annotations = getAnnotationInArray(roadmap->annotations, annotationOffset[readIndex]);
}
threadSequenceThroughGraph(getTightStringInArray(reads->tSequences, readIndex),
kmerTable,
graph, readIndex + 1, category,
readTracking, double_strand,
referenceMappings, referenceMappingCount,
refCount, annotations, annotationCount, second_in_pair);
}
gettimeofday(&end, NULL);
timersub(&end, &start, &diff);
velvetLog(" === Threaded in %ld.%06ld s\n", diff.tv_sec, diff.tv_usec);
#ifdef OPENMP
free(nodeLocks);
nodeLocks = NULL;
#endif
if (referenceMappings)
{
destroyRoadMapArray(roadmap);
free (annotationOffset);
}
orderNodeReadStartArrays(graph);
destroySmallNodeListMemmory();
destroyKmerOccurenceTable(kmerTable);
}
