void RefineW(const MSA &msaIn, MSA &msaOut)
{
const unsigned uSeqCount = msaIn.GetSeqCount();
const unsigned uColCount = msaIn.GetColCount();
// Reserve same nr seqs, 20% more cols
const unsigned uReserveColCount = (uColCount*120)/100;
msaOut.SetSize(uSeqCount, uReserveColCount);
for (unsigned uSeqIndex = 0; uSeqIndex < uSeqCount; ++uSeqIndex)
{
msaOut.SetSeqName(uSeqIndex, msaIn.GetSeqName(uSeqIndex));
msaOut.SetSeqId(uSeqIndex, msaIn.GetSeqId(uSeqIndex));
}
const unsigned uWindowCount = (uColCount + g_uRefineWindow.get() - 1)/g_uRefineWindow.get();
if (0 == g_uWindowTo.get())
g_uWindowTo.get() = uWindowCount - 1;
#if MEMDEBUG
_CrtSetBreakAlloc(1560);
#endif
if (g_uWindowOffset.get() > 0)
{
MSA msaTmp;
MSAFromColRange(msaIn, 0, g_uWindowOffset.get(), msaOut);
}
if (!g_bQuiet.get())
fprintf(stderr, "\n");
for (unsigned uWindowIndex = g_uWindowFrom.get(); uWindowIndex <= g_uWindowTo.get(); ++uWindowIndex)
{
if (!g_bQuiet.get())
fprintf(stderr, "Window %d of %d \r", uWindowIndex, uWindowCount);
const unsigned uColFrom = g_uWindowOffset.get() + uWindowIndex*g_uRefineWindow.get();
unsigned uColTo = uColFrom + g_uRefineWindow.get() - 1;
if (uColTo >= uColCount)
uColTo = uColCount - 1;
assert(uColTo >= uColFrom);
SeqVect v;
SeqVectFromMSACols(msaIn, uColFrom, uColTo, v);
#if MEMDEBUG
_CrtMemState s1;
_CrtMemCheckpoint(&s1);
#endif
// Begin AED 5/20/06
// remove any empty seqs in this window
std::vector< size_t > empty_seqs;
SeqVect vr;
for( size_t seqI = 0; seqI < v.size(); ++seqI )
{
if( v[seqI]->size() == 0 )
empty_seqs.push_back(seqI);
else
vr.push_back(v[seqI]);
}
std::vector< unsigned > seqid_map( vr.size() );
for( size_t seqI = 0; seqI < vr.size(); ++seqI )
{
seqid_map[seqI] = vr[seqI]->GetId();
vr[seqI]->SetId(seqI);
}
MSA msaTmp;
if( vr.size() > 1 )
MUSCLE(vr, msaTmp);
// remap the seqids to their original state
for( size_t seqI = 0; seqI < vr.size(); ++seqI )
vr[seqI]->SetId(seqid_map[seqI]);
// merge empty seqs back in
{
const unsigned uSeqCount = msaOut.GetSeqCount();
const unsigned uColCount1 = msaOut.GetColCount();
const unsigned uColCount2 = vr.size() > 1 ? msaTmp.GetColCount() : vr[0]->size();
const unsigned uColCountCat = uColCount1 + uColCount2;
for( unsigned seqI = 0; seqI < vr.size(); ++seqI )
{
unsigned uSeqIndex = msaOut.GetSeqIndex(seqid_map[seqI]);
if( vr.size() > 1 )
{
unsigned uSeqIndex2 = msaTmp.GetSeqIndex(seqI);
for (unsigned uColIndex = 0; uColIndex < uColCount2; ++uColIndex)
{
const char c = msaTmp.GetChar(uSeqIndex2, uColIndex);
msaOut.SetChar(uSeqIndex, uColCount1 + uColIndex, c);
}
}else{
for (unsigned uColIndex = 0; uColIndex < uColCount2; ++uColIndex)
{
const char c = vr[0]->GetChar(uColIndex);
msaOut.SetChar(uSeqIndex, uColCount1 + uColIndex, c);
}
}
}
for( unsigned seqI = 0; seqI < empty_seqs.size(); ++seqI )
{
unsigned uSeqId2 = v[empty_seqs[seqI]]->GetId();
unsigned uSeqIndex = msaOut.GetSeqIndex(uSeqId2);
for (unsigned uColIndex = 0; uColIndex < uColCount2; ++uColIndex)
{
msaOut.SetChar(uSeqIndex, uColCount1 + uColIndex, '-');
}
}
vr.clear();
}
// AppendMSA(msaOut, msaTmp);
// end AED 5/20/06
if (uWindowIndex == g_uSaveWindow.get())
{
MSA msaInTmp;
unsigned uOutCols = msaOut.GetColCount();
unsigned un = uColTo - uColFrom + 1;
MSAFromColRange(msaIn, uColFrom, un, msaInTmp);
char fn[256];
sprintf(fn, "win%d_inaln.tmp", uWindowIndex);
TextFile fIn(fn, true);
msaInTmp.ToFile(fIn);
sprintf(fn, "win%d_inseqs.tmp", uWindowIndex);
TextFile fv(fn, true);
v.ToFile(fv);
sprintf(fn, "win%d_outaln.tmp", uWindowIndex);
TextFile fOut(fn, true);
msaTmp.ToFile(fOut);
}
#if MEMDEBUG
void FreeDPMemSPN();
FreeDPMemSPN();
_CrtMemState s2;
_CrtMemCheckpoint(&s2);
_CrtMemState s;
_CrtMemDifference(&s, &s1, &s2);
_CrtMemDumpStatistics(&s);
_CrtMemDumpAllObjectsSince(&s1);
exit(1);
#endif
//#if DEBUG
// AssertMSAEqIgnoreCaseAndGaps(msaInTmp, msaTmp);
//#endif
}
if (!g_bQuiet.get())
fprintf(stderr, "\n");
// AssertMSAEqIgnoreCaseAndGaps(msaIn, msaOut);//@@uncomment!
}
// Return true if any changes made
bool RefineVert(MSA &msaIn, const Tree &tree, unsigned uIters)
{
bool bAnyChanges = false;
const unsigned uColCountIn = msaIn.GetColCount();
const unsigned uSeqCountIn = msaIn.GetSeqCount();
if (uColCountIn < 3 || uSeqCountIn < 3)
return false;
unsigned *AnchorCols = new unsigned[uColCountIn];
unsigned uAnchorColCount;
SetMSAWeightsMuscle(msaIn);
FindAnchorCols(msaIn, AnchorCols, &uAnchorColCount);
const unsigned uRangeCount = uAnchorColCount + 1;
Range *Ranges = new Range[uRangeCount];
#if TRACE
Log("%u ranges\n", uRangeCount);
#endif
ColsToRanges(AnchorCols, uAnchorColCount, uColCountIn, Ranges);
ListVertSavings(uColCountIn, uAnchorColCount, Ranges, uRangeCount);
#if TRACE
{
Log("Anchor cols: ");
for (unsigned i = 0; i < uAnchorColCount; ++i)
Log(" %u", AnchorCols[i]);
Log("\n");
Log("Ranges:\n");
for (unsigned i = 0; i < uRangeCount; ++i)
Log("%4u - %4u\n", Ranges[i].m_uBestColLeft, Ranges[i].m_uBestColRight);
}
#endif
delete[] AnchorCols;
MSA msaOut;
msaOut.SetSize(uSeqCountIn, 0);
for (unsigned uSeqIndex = 0; uSeqIndex < uSeqCountIn; ++uSeqIndex)
{
const char *ptrName = msaIn.GetSeqName(uSeqIndex);
unsigned uId = msaIn.GetSeqId(uSeqIndex);
msaOut.SetSeqName(uSeqIndex, ptrName);
msaOut.SetSeqId(uSeqIndex, uId);
}
for (unsigned uRangeIndex = 0; uRangeIndex < uRangeCount; ++uRangeIndex)
{
MSA msaRange;
const Range &r = Ranges[uRangeIndex];
const unsigned uFromColIndex = r.m_uBestColLeft;
const unsigned uRangeColCount = r.m_uBestColRight - uFromColIndex;
if (0 == uRangeColCount)
continue;
else if (1 == uRangeColCount)
{
MSAFromColRange(msaIn, uFromColIndex, 1, msaRange);
MSAAppend(msaOut, msaRange);
continue;
}
MSAFromColRange(msaIn, uFromColIndex, uRangeColCount, msaRange);
#if TRACE
Log("\n-------------\n");
Log("Range %u - %u count=%u\n", r.m_uBestColLeft, r.m_uBestColRight, uRangeColCount);
Log("Before:\n");
msaRange.LogMe();
#endif
bool bLockLeft = (0 != uRangeIndex);
bool bLockRight = (uRangeCount - 1 != uRangeIndex);
bool bAnyChangesThisBlock = RefineHoriz(msaRange, tree, uIters, bLockLeft, bLockRight);
bAnyChanges = (bAnyChanges || bAnyChangesThisBlock);
#if TRACE
Log("After:\n");
msaRange.LogMe();
#endif
MSAAppend(msaOut, msaRange);
#if TRACE
Log("msaOut after Cat:\n");
msaOut.LogMe();
#endif
}
#if DEBUG
// Sanity check
AssertMSAEqIgnoreCaseAndGaps(msaIn, msaOut);
#endif
delete[] Ranges;
if (bAnyChanges)
msaIn.Copy(msaOut);
return bAnyChanges;
}
// Return true if any changes made
void AnchoredProfileProfile(MSA &msa1, MSA &msa2, MSA &msaOut)
{
const unsigned uColCountIn = msa1.GetColCount();
const unsigned uSeqCountIn = msa1.GetSeqCount() + msa2.GetSeqCount();
unsigned *AnchorCols = new unsigned[uColCountIn];
unsigned uAnchorColCount;
PrepareMSAforScoring(msa1);
PrepareMSAforScoring(msa2);
FindAnchorColsPP(msa1, msa2, AnchorCols, &uAnchorColCount);
const unsigned uRangeCount = uAnchorColCount + 1;
Range *Ranges = new Range[uRangeCount];
#if TRACE
Log("%u ranges\n", uRangeCount);
#endif
ColsToRanges(AnchorCols, uAnchorColCount, uColCountIn, Ranges);
ListVertSavings(uColCountIn, uAnchorColCount, Ranges, uRangeCount);
#if TRACE
{
Log("Anchor cols: ");
for (unsigned i = 0; i < uAnchorColCount; ++i)
Log(" %u", AnchorCols[i]);
Log("\n");
Log("Ranges:\n");
for (unsigned i = 0; i < uRangeCount; ++i)
Log("%4u - %4u\n", Ranges[i].m_uBestColLeft, Ranges[i].m_uBestColRight);
}
#endif
delete[] AnchorCols;
msaOut.SetSize(uSeqCountIn, 0);
for (unsigned uSeqIndex = 0; uSeqIndex < uSeqCountIn; ++uSeqIndex)
{
const char *ptrName;
unsigned uId;
if( uSeqIndex < msa1.GetSeqCount() )
{
msa1.SetSeqId(uSeqIndex, uSeqIndex);
ptrName = msa1.GetSeqName(uSeqIndex);
}
else
{
msa2.SetSeqId(uSeqIndex-msa1.GetSeqCount(), uSeqIndex);
ptrName = msa2.GetSeqName(uSeqIndex-msa1.GetSeqCount());
}
msaOut.SetSeqName(uSeqIndex, ptrName);
msaOut.SetSeqId(uSeqIndex, uSeqIndex);
}
for (unsigned uRangeIndex = 0; uRangeIndex < uRangeCount; ++uRangeIndex)
{
MSA msaRange1;
MSA msaRange2;
MSA msaRangeOut;
const Range &r = Ranges[uRangeIndex];
const unsigned uFromColIndex = r.m_uBestColLeft;
const unsigned uRangeColCount = r.m_uBestColRight - uFromColIndex;
if (0 == uRangeColCount)
continue;
/* else if (1 == uRangeColCount)
{
MSAFromColRange(msaIn, uFromColIndex, 1, msaRange);
MSAAppend(msaOut, msaRange);
continue;
}
*/
MSAFromColRange(msa1, uFromColIndex, uRangeColCount, msaRange1);
MSAFromColRange(msa2, uFromColIndex, uRangeColCount, msaRange2);
StripGapColumns(msaRange1);
StripGapColumns(msaRange2);
#if TRACE
Log("\n-------------\n");
Log("Range %u - %u count=%u\n", r.m_uBestColLeft, r.m_uBestColRight, uRangeColCount);
Log("Before:\n");
msaRange1.LogMe();
msaRange2.LogMe();
#endif
ProfileProfile(msaRange1, msaRange2, msaRangeOut);
#if TRACE
Log("After:\n");
msaRangeOut.LogMe();
#endif
for (unsigned uSeqIndex = 0; uSeqIndex < uSeqCountIn; ++uSeqIndex)
msaRangeOut.SetSeqId(uSeqIndex, uSeqIndex);
MSAAppend(msaOut, msaRangeOut);
#if TRACE
Log("msaOut after Cat:\n");
msaOut.LogMe();
#endif
}
delete[] Ranges;
}
void RefineW(const MSA &msaIn, MSA &msaOut)
{
const unsigned uSeqCount = msaIn.GetSeqCount();
const unsigned uColCount = msaIn.GetColCount();
// Reserve same nr seqs, 20% more cols
const unsigned uReserveColCount = (uColCount*120)/100;
msaOut.SetSize(uSeqCount, uReserveColCount);
for (unsigned uSeqIndex = 0; uSeqIndex < uSeqCount; ++uSeqIndex)
{
msaOut.SetSeqName(uSeqIndex, msaIn.GetSeqName(uSeqIndex));
msaOut.SetSeqId(uSeqIndex, msaIn.GetSeqId(uSeqIndex));
}
const unsigned uWindowCount = (uColCount + g_uRefineWindow - 1)/g_uRefineWindow;
if (0 == g_uWindowTo)
g_uWindowTo = uWindowCount - 1;
#if MEMDEBUG
_CrtSetBreakAlloc(1560);
#endif
if (g_uWindowOffset > 0)
{
MSA msaTmp;
MSAFromColRange(msaIn, 0, g_uWindowOffset, msaOut);
}
fprintf(stderr, "\n");
for (unsigned uWindowIndex = g_uWindowFrom; uWindowIndex <= g_uWindowTo; ++uWindowIndex)
{
fprintf(stderr, "Window %d of %d \r", uWindowIndex, uWindowCount);
const unsigned uColFrom = g_uWindowOffset + uWindowIndex*g_uRefineWindow;
unsigned uColTo = uColFrom + g_uRefineWindow - 1;
if (uColTo >= uColCount)
uColTo = uColCount - 1;
assert(uColTo >= uColFrom);
SeqVect v;
SeqVectFromMSACols(msaIn, uColFrom, uColTo, v);
#if MEMDEBUG
_CrtMemState s1;
_CrtMemCheckpoint(&s1);
#endif
MSA msaTmp;
MUSCLE(v, msaTmp);
AppendMSA(msaOut, msaTmp);
if (uWindowIndex == g_uSaveWindow)
{
MSA msaInTmp;
unsigned uOutCols = msaOut.GetColCount();
unsigned un = uColTo - uColFrom + 1;
MSAFromColRange(msaIn, uColFrom, un, msaInTmp);
char fn[256];
sprintf(fn, "win%d_inaln.tmp", uWindowIndex);
TextFile fIn(fn, true);
msaInTmp.ToFile(fIn);
sprintf(fn, "win%d_inseqs.tmp", uWindowIndex);
TextFile fv(fn, true);
v.ToFile(fv);
sprintf(fn, "win%d_outaln.tmp", uWindowIndex);
TextFile fOut(fn, true);
msaTmp.ToFile(fOut);
}
#if MEMDEBUG
void FreeDPMemSPN();
FreeDPMemSPN();
_CrtMemState s2;
_CrtMemCheckpoint(&s2);
_CrtMemState s;
_CrtMemDifference(&s, &s1, &s2);
_CrtMemDumpStatistics(&s);
_CrtMemDumpAllObjectsSince(&s1);
exit(1);
#endif
//#if DEBUG
// AssertMSAEqIgnoreCaseAndGaps(msaInTmp, msaTmp);
//#endif
}
fprintf(stderr, "\n");
// AssertMSAEqIgnoreCaseAndGaps(msaIn, msaOut);//@@uncomment!
}
// Return true if any changes made
bool RefineTask::RefineVertP(MSA* msaIn, unsigned uIters)
{
bool bAnyChanges = false;
const unsigned uColCountIn = msaIn->GetColCount();
const unsigned uSeqCountIn = msaIn->GetSeqCount();
if (uColCountIn < 3 || uSeqCountIn < 3)
return false;
unsigned *AnchorCols = new unsigned[uColCountIn];
unsigned uAnchorColCount;
SetMSAWeightsMuscle(*msaIn);
FindAnchorCols(*msaIn, AnchorCols, &uAnchorColCount);
const unsigned uRangeCount = uAnchorColCount + 1;
Range *Ranges = new Range[uRangeCount];
ColsToRanges(AnchorCols, uAnchorColCount, uColCountIn, Ranges);
ListVertSavings(uColCountIn, uAnchorColCount, Ranges, uRangeCount);
delete[] AnchorCols;
MSA msaOut;
msaOut.SetSize(uSeqCountIn, 0);
for (unsigned uSeqIndex = 0; uSeqIndex < uSeqCountIn ; ++uSeqIndex)
{
const char *ptrName = msaIn->GetSeqName(uSeqIndex);
unsigned uId = msaIn->GetSeqId(uSeqIndex);
msaOut.SetSeqName(uSeqIndex, ptrName);
msaOut.SetSeqId(uSeqIndex, uId);
}
MuscleContext* ctx = getMuscleContext();
workpool->uRangeCount = uRangeCount;
for (unsigned uRangeIndex = 0; uRangeIndex < uRangeCount && !ctx->isCanceled(); ++uRangeIndex)
{
workpool->uRangeIndex = uRangeIndex;
MSA msaRange;
const Range &r = Ranges[uRangeIndex];
const unsigned uFromColIndex = r.m_uBestColLeft;
const unsigned uRangeColCount = r.m_uBestColRight - uFromColIndex;
if (0 == uRangeColCount)
continue;
else if (1 == uRangeColCount)
{
MSAFromColRange(*msaIn, uFromColIndex, 1, msaRange);
MSAAppend(msaOut, msaRange);
continue;
}
MSAFromColRange(*msaIn, uFromColIndex, uRangeColCount, msaRange);
bool &bLockLeft = workpool->bLockLeft;
bool &bLockRight = workpool->bLockRight;
bLockLeft = (0 != uRangeIndex);
bLockRight = (uRangeCount - 1 != uRangeIndex);
bool bAnyChangesThisBlock = RefineHorizP(&msaRange, uIters, bLockLeft, bLockRight);
bAnyChanges = (bAnyChanges || bAnyChangesThisBlock);
MSAAppend(msaOut, msaRange);
}
delete[] Ranges;
if (ctx->isCanceled()) {
throw MuscleException("Canceled");
}
#if DEBUG
// Sanity check
AssertMSAEqIgnoreCaseAndGaps(*msaIn, msaOut);
#endif
if (bAnyChanges) {
msaIn->Copy(msaOut);
}
return bAnyChanges;
}
