// After splitting and ejecting some contains, check for discontinuous unitigs.
//
void splitDiscontinuousUnitigs(UnitigVector &unitigs, uint32 minOverlap) {
writeLog("==> SPLIT DISCONTINUOUS\n");
uint32 numTested = 0;
uint32 numSplit = 0;
uint32 numCreated = 0;
uint32 splitFragsLen = 0;
uint32 splitFragsMax = 0;
ufNode *splitFrags = NULL;
for (uint32 ti=0; ti<unitigs.size(); ti++) {
Unitig *tig = unitigs[ti];
if ((tig == NULL) || (tig->ufpath.size() < 2))
continue;
// Unitig must be sorted. Someone upstream os screwing this up.
tig->sort();
// We'll want to build an array of new fragments to split out. This can be up
// to the size of the largest unitig.
splitFragsMax = MAX(splitFragsMax, tig->ufpath.size());
// Check that the unitig starts at position zero. Not critical for the next loop, but
// needs to be dome sometime.
int32 minPos = MIN(tig->ufpath[0].position.bgn, tig->ufpath[0].position.end);
if (minPos == 0)
continue;
writeLog("splitDiscontinuous()-- tig "F_U32" offset messed up; reset by "F_S32".\n", tig->id(), minPos);
for (uint32 fi=0; fi<tig->ufpath.size(); fi++) {
ufNode *frg = &tig->ufpath[fi];
frg->position.bgn -= minPos;
frg->position.end -= minPos;
}
}
splitFrags = new ufNode [splitFragsMax];
// Now, finally, we can check for gaps in unitigs.
for (uint32 ti=0; ti<unitigs.size(); ti++) {
Unitig *tig = unitigs[ti];
if ((tig == NULL) || (tig->ufpath.size() < 2))
continue;
// We don't expect many unitigs to be broken, so we'll do a first quick pass to just
// test if it is.
int32 maxEnd = MAX(tig->ufpath[0].position.bgn, tig->ufpath[0].position.end);
bool isBroken = false;
for (uint32 fi=0; fi<tig->ufpath.size(); fi++) {
ufNode *frg = &tig->ufpath[fi];
int32 bgn = MIN(frg->position.bgn, frg->position.end);
int32 end = MAX(frg->position.bgn, frg->position.end);
if (bgn > maxEnd - minOverlap) {
isBroken = true;
break;
}
maxEnd = MAX(maxEnd, end);
}
numTested++;
if (isBroken == false)
continue;
numSplit++;
// Dang, busted unitig. Fix it up.
splitFragsLen = 0;
maxEnd = 0;
if (logFileFlagSet(LOG_MATE_SPLIT_DISCONTINUOUS))
writeLog("splitDiscontinuous()-- discontinuous tig "F_U32" with "F_SIZE_T" fragments broken into:\n",
tig->id(), tig->ufpath.size());
for (uint32 fi=0; fi<tig->ufpath.size(); fi++) {
ufNode *frg = &tig->ufpath[fi];
int32 bgn = MIN(frg->position.bgn, frg->position.end);
int32 end = MAX(frg->position.bgn, frg->position.end);
// Good thick overlap exists to this fragment, save it.
if (bgn <= maxEnd - minOverlap) {
assert(splitFragsLen < splitFragsMax);
splitFrags[splitFragsLen++] = *frg;
maxEnd = MAX(maxEnd, end);
continue;
}
// No thick overlap found. We need to break right here before the current fragment.
// If there is exactly one fragment, and it's contained, and it's not mated, move it to the
// container. (This has a small positive benefit over just making every read a singleton).
//
if ((splitFragsLen == 1) &&
(FI->mateIID(splitFrags[0].ident) == 0) &&
(splitFrags[0].contained != 0)) {
Unitig *dangler = unitigs[tig->fragIn(splitFrags[0].contained)];
// If the parent isn't in a unitig, we must have shattered the repeat unitig it was in.
// Do the same here.
if (dangler == NULL) {
if (logFileFlagSet(LOG_MATE_SPLIT_DISCONTINUOUS))
writeLog("splitDiscontinuous()-- singleton frag "F_U32" shattered.\n",
splitFrags[0].ident);
Unitig::removeFrag(splitFrags[0].ident);
} else {
assert(dangler->id() == tig->fragIn(splitFrags[0].contained));
if (logFileFlagSet(LOG_MATE_SPLIT_DISCONTINUOUS))
writeLog("splitDiscontinuous()-- old tig "F_U32" with "F_SIZE_T" fragments (contained frag "F_U32" moved here).\n",
dangler->id(), dangler->ufpath.size() + 1, splitFrags[0].ident);
BestContainment *bestcont = OG->getBestContainer(splitFrags[0].ident);
assert(bestcont->isContained == true);
dangler->addContainedFrag(splitFrags[0].ident, bestcont, false);
dangler->bubbleSortLastFrag();
assert(dangler->id() == Unitig::fragIn(splitFrags[0].ident));
}
}
// Otherwise, make an entirely new unitig for these fragments.
else {
numCreated++;
makeNewUnitig(unitigs, splitFragsLen, splitFrags);
tig = unitigs[ti];
}
// Done with the split, save the current fragment. This resets everything.
splitFragsLen = 0;
splitFrags[splitFragsLen++] = *frg;
maxEnd = end;
}
// If we did any splitting, then the length of the frags in splitFrags will be less than the length
// of the path in the current unitig. Make a final new unitig for the remaining fragments.
//
if (splitFragsLen != tig->ufpath.size()) {
numCreated++;
makeNewUnitig(unitigs, splitFragsLen, splitFrags);
delete unitigs[ti];
unitigs[ti] = NULL;
}
}
writeLog("splitDiscontinuous()-- Tested "F_U32" unitigs, split "F_U32" into "F_U32" new unitigs.\n",
numTested, numSplit, numCreated);
delete [] splitFrags;
}
