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!
}
static SCORE ScoreSeqPair(const MSA &msa1, unsigned uSeqIndex1,
const MSA &msa2, unsigned uSeqIndex2, SCORE *ptrLetters, SCORE *ptrGaps)
{
g_ptrMSA1.get() = &msa1;
g_ptrMSA2.get() = &msa2;
g_uSeqIndex1.get() = uSeqIndex1;
g_uSeqIndex2.get() = uSeqIndex2;
const unsigned uColCount = msa1.GetColCount();
const unsigned uColCount2 = msa2.GetColCount();
if (uColCount != uColCount2)
Quit("ScoreSeqPair, different lengths");
#if TRACE
Log("ScoreSeqPair\n");
Log("%16.16s ", msa1.GetSeqName(uSeqIndex1));
for (unsigned i = 0; i < uColCount; ++i)
Log("%c", msa1.GetChar(uSeqIndex1, i));
Log("\n");
Log("%16.16s ", msa2.GetSeqName(uSeqIndex2));
for (unsigned i = 0; i < uColCount; ++i)
Log("%c", msa1.GetChar(uSeqIndex2, i));
Log("\n");
#endif
SCORE scoreTotal = 0;
// Substitution scores
unsigned uFirstLetter1 = uInsane;
unsigned uFirstLetter2 = uInsane;
unsigned uLastLetter1 = uInsane;
unsigned uLastLetter2 = uInsane;
for (unsigned uColIndex = 0; uColIndex < uColCount; ++uColIndex)
{
bool bGap1 = msa1.IsGap(uSeqIndex1, uColIndex);
bool bGap2 = msa2.IsGap(uSeqIndex2, uColIndex);
bool bWildcard1 = msa1.IsWildcard(uSeqIndex1, uColIndex);
bool bWildcard2 = msa2.IsWildcard(uSeqIndex2, uColIndex);
if (!bGap1)
{
if (uInsane == uFirstLetter1)
uFirstLetter1 = uColIndex;
uLastLetter1 = uColIndex;
}
if (!bGap2)
{
if (uInsane == uFirstLetter2)
uFirstLetter2 = uColIndex;
uLastLetter2 = uColIndex;
}
if (bGap1 || bGap2 || bWildcard1 || bWildcard2)
continue;
unsigned uLetter1 = msa1.GetLetter(uSeqIndex1, uColIndex);
unsigned uLetter2 = msa2.GetLetter(uSeqIndex2, uColIndex);
SCORE scoreMatch = (*g_ptrScoreMatrix.get())[uLetter1][uLetter2];
scoreTotal += scoreMatch;
#if TRACE
Log("%c <-> %c = %7.1f %10.1f\n",
msa1.GetChar(uSeqIndex1, uColIndex),
msa2.GetChar(uSeqIndex2, uColIndex),
scoreMatch,
scoreTotal);
#endif
}
*ptrLetters = scoreTotal;
// Gap penalties
unsigned uGapLength = uInsane;
unsigned uGapStartCol = uInsane;
bool bGapping1 = false;
bool bGapping2 = false;
for (unsigned uColIndex = 0; uColIndex < uColCount; ++uColIndex)
{
bool bGap1 = msa1.IsGap(uSeqIndex1, uColIndex);
bool bGap2 = msa2.IsGap(uSeqIndex2, uColIndex);
if (bGap1 && bGap2)
continue;
if (bGapping1)
{
if (bGap1)
++uGapLength;
else
{
bGapping1 = false;
bool bNTerm = (uFirstLetter2 == uGapStartCol);
bool bCTerm = (uLastLetter2 + 1 == uColIndex);
SCORE scoreGap = GapPenalty(uGapLength, bNTerm || bCTerm);
scoreTotal += scoreGap;
#if TRACE
LogGap(uGapStartCol, uColIndex - 1, uGapLength, bNTerm, bCTerm);
Log("GAP %7.1f %10.1f\n",
scoreGap,
scoreTotal);
#endif
}
continue;
}
else
{
if (bGap1)
{
uGapStartCol = uColIndex;
bGapping1 = true;
uGapLength = 1;
continue;
}
}
if (bGapping2)
{
if (bGap2)
++uGapLength;
else
{
bGapping2 = false;
bool bNTerm = (uFirstLetter1 == uGapStartCol);
bool bCTerm = (uLastLetter1 + 1 == uColIndex);
SCORE scoreGap = GapPenalty(uGapLength, bNTerm || bCTerm);
scoreTotal += scoreGap;
#if TRACE
LogGap(uGapStartCol, uColIndex - 1, uGapLength, bNTerm, bCTerm);
Log("GAP %7.1f %10.1f\n",
scoreGap,
scoreTotal);
#endif
}
}
else
{
if (bGap2)
{
uGapStartCol = uColIndex;
bGapping2 = true;
uGapLength = 1;
}
}
}
if (bGapping1 || bGapping2)
{
SCORE scoreGap = GapPenalty(uGapLength, true);
scoreTotal += scoreGap;
#if TRACE
LogGap(uGapStartCol, uColCount - 1, uGapLength, false, true);
Log("GAP %7.1f %10.1f\n",
scoreGap,
scoreTotal);
#endif
}
*ptrGaps = scoreTotal - *ptrLetters;
return scoreTotal;
}
SCORE ScoreGaps(const MSA &msa, const unsigned DiffCols[], unsigned DiffColCount)
{
MuscleContext *ctx = getMuscleContext();
unsigned &g_ColCount = ctx->scoregaps.g_ColCount;
unsigned &g_MaxSeqCount = ctx->scoregaps.g_MaxSeqCount;
unsigned &g_MaxColCount = ctx->scoregaps.g_MaxColCount;
GAPINFO** &g_Gaps = ctx->scoregaps.g_Gaps;
bool* &g_ColDiff = ctx->scoregaps.g_ColDiff;
#if TRACE
{
Log("ScoreGaps\n");
Log("DiffCols ");
for (unsigned i = 0; i < DiffColCount; ++i)
Log(" %u", DiffCols[i]);
Log("\n");
Log("msa=\n");
msa.LogMe();
Log("\n");
}
#endif
const unsigned SeqCount = msa.GetSeqCount();
const unsigned ColCount = msa.GetColCount();
g_ColCount = ColCount;
if (SeqCount > g_MaxSeqCount)
{
delete[] g_Gaps;
g_MaxSeqCount = SeqCount + 256;
g_Gaps = new GAPINFO *[g_MaxSeqCount];
}
memset(g_Gaps, 0, SeqCount*sizeof(GAPINFO *));
if (ColCount > g_MaxColCount)
{
delete[] g_ColDiff;
g_MaxColCount = ColCount + 256;
g_ColDiff = new bool[g_MaxColCount];
}
memset(g_ColDiff, 0, g_ColCount*sizeof(bool));
for (unsigned i = 0; i < DiffColCount; ++i)
{
unsigned Col = DiffCols[i];
assert(Col < ColCount);
g_ColDiff[Col] = true;
}
for (unsigned SeqIndex = 0; SeqIndex < SeqCount; ++SeqIndex)
FindIntersectingGaps(msa, SeqIndex);
#if TRACE
{
Log("\n");
Log("Intersecting gaps:\n");
Log(" ");
for (unsigned Col = 0; Col < ColCount; ++Col)
Log("%c", g_ColDiff[Col] ? '*' : ' ');
Log("\n");
Log(" ");
for (unsigned Col = 0; Col < ColCount; ++Col)
Log("%d", Col%10);
Log("\n");
for (unsigned Seq = 0; Seq < SeqCount; ++Seq)
{
Log("%3d: ", Seq);
for (unsigned Col = 0; Col < ColCount; ++Col)
Log("%c", msa.GetChar(Seq, Col));
Log(" :: ");
for (GAPINFO *GI = g_Gaps[Seq]; GI; GI = GI->Next)
Log(" (%d,%d)", GI->Start, GI->End);
Log(" >%s\n", msa.GetSeqName(Seq));
}
Log("\n");
}
#endif
SCORE Score = 0;
for (unsigned Seq1 = 0; Seq1 < SeqCount; ++Seq1)
{
const WEIGHT w1 = msa.GetSeqWeight(Seq1);
for (unsigned Seq2 = Seq1 + 1; Seq2 < SeqCount; ++Seq2)
{
const WEIGHT w2 = msa.GetSeqWeight(Seq2);
// const SCORE Pair = ScorePair(Seq1, Seq2);
const SCORE Pair = ScoreSeqPairGaps(msa, Seq1, msa, Seq2);
Score += w1*w2*Pair;
#if TRACE
Log("Seq1=%u Seq2=%u ScorePair=%.4g w1=%.4g w2=%.4g Sum=%.4g\n",
Seq1, Seq2, Pair, w1, w2, Score);
#endif
}
}
return Score;
}
