void RefineTreeE(MSA &msa, const SeqVect &v, Tree &tree, ProgNode *ProgNodes)
{
MuscleContext *ctx = getMuscleContext();
const unsigned uSeqCount = msa.GetSeqCount();
if (tree.GetLeafCount() != uSeqCount)
Quit("Refine tree, tree has different number of nodes");
if (uSeqCount < 3)
return;
#if DEBUG
ValidateMuscleIds(msa);
ValidateMuscleIds(tree);
#endif
const unsigned uNodeCount = tree.GetNodeCount();
unsigned *uNewNodeIndexToOldNodeIndex= new unsigned[uNodeCount];
Tree Tree2;
TreeFromMSA(msa, Tree2, ctx->params.g_Cluster2, ctx->params.g_Distance2, ctx->params.g_Root2, ctx->params.g_pstrDistMxFileName2);
#if DEBUG
ValidateMuscleIds(Tree2);
#endif
DiffTreesE(Tree2, tree, uNewNodeIndexToOldNodeIndex);
unsigned uRoot = Tree2.GetRootNodeIndex();
if (NODE_CHANGED == uNewNodeIndexToOldNodeIndex[uRoot])
{
MSA msa2;
RealignDiffsE(msa, v, Tree2, tree, uNewNodeIndexToOldNodeIndex, msa2, ProgNodes);
if (!ctx->isCanceled()) {
tree.Copy(Tree2);
msa.Copy(msa2);
#if DEBUG
ValidateMuscleIds(msa2);
#endif
}
}
delete[] uNewNodeIndexToOldNodeIndex;
if (ctx->isCanceled()) {
throw MuscleException("Canceled");
}
SetCurrentAlignment(msa);
ProgressStepsDone();
}
static void ProgressiveAlignSubfams(const Tree &tree, const unsigned Subfams[],
unsigned uSubfamCount, const MSA SubfamMSAs[], MSA &msa)
{
const unsigned uNodeCount = tree.GetNodeCount();
bool *Ready = new bool[uNodeCount];
MSA **MSAs = new MSA *[uNodeCount];
for (unsigned uNodeIndex = 0; uNodeIndex < uNodeCount; ++uNodeIndex)
{
Ready[uNodeIndex] = false;
MSAs[uNodeIndex] = 0;
}
for (unsigned uSubfamIndex = 0; uSubfamIndex < uSubfamCount; ++uSubfamIndex)
{
unsigned uNodeIndex = Subfams[uSubfamIndex];
Ready[uNodeIndex] = true;
MSA *ptrMSA = new MSA;
// TODO: Wasteful copy, needs re-design
ptrMSA->Copy(SubfamMSAs[uSubfamIndex]);
MSAs[uNodeIndex] = ptrMSA;
}
for (unsigned uNodeIndex = tree.FirstDepthFirstNode();
NULL_NEIGHBOR != uNodeIndex;
uNodeIndex = tree.NextDepthFirstNode(uNodeIndex))
{
if (tree.IsLeaf(uNodeIndex))
continue;
unsigned uRight = tree.GetRight(uNodeIndex);
unsigned uLeft = tree.GetLeft(uNodeIndex);
if (!Ready[uRight] || !Ready[uLeft])
continue;
MSA *ptrLeft = MSAs[uLeft];
MSA *ptrRight = MSAs[uRight];
assert(ptrLeft != 0 && ptrRight != 0);
MSA *ptrParent = new MSA;
PWPath Path;
AlignTwoMSAs(*ptrLeft, *ptrRight, *ptrParent, Path);
MSAs[uNodeIndex] = ptrParent;
Ready[uNodeIndex] = true;
Ready[uLeft] = false;
Ready[uRight] = false;
delete MSAs[uLeft];
delete MSAs[uRight];
MSAs[uLeft] = 0;
MSAs[uRight] = 0;
}
#if DEBUG
{
unsigned uReadyCount = 0;
for (unsigned uNodeIndex = 0; uNodeIndex < uNodeCount; ++uNodeIndex)
{
if (Ready[uNodeIndex])
{
assert(tree.IsRoot(uNodeIndex));
++uReadyCount;
assert(0 != MSAs[uNodeIndex]);
}
else
assert(0 == MSAs[uNodeIndex]);
}
assert(1 == uReadyCount);
}
#endif
const unsigned uRoot = tree.GetRootNodeIndex();
MSA *ptrRootAlignment = MSAs[uRoot];
msa.Copy(*ptrRootAlignment);
delete ptrRootAlignment;
delete[] Ready;
#if TRACE
Log("After refine subfamilies, root alignment=\n");
msa.LogMe();
#endif
}
bool TryRealign(MSA &msaIn, const Tree &tree, const unsigned Leaves1[],
unsigned uCount1, const unsigned Leaves2[], unsigned uCount2,
SCORE *ptrscoreBefore, SCORE *ptrscoreAfter,
bool bLockLeft, bool bLockRight)
{
#if TRACE
Log("TryRealign, msaIn=\n");
#endif
MuscleContext *ctx = getMuscleContext();
const unsigned uSeqCount = msaIn.GetSeqCount();
unsigned *Ids1 = new unsigned[uSeqCount];
unsigned *Ids2 = new unsigned[uSeqCount];
LeafIndexesToIds(tree, Leaves1, uCount1, Ids1);
LeafIndexesToIds(tree, Leaves2, uCount2, Ids2);
MSA msa1;
MSA msa2;
MSASubsetByIds(msaIn, Ids1, uCount1, msa1);
MSASubsetByIds(msaIn, Ids2, uCount2, msa2);
#if DEBUG
ValidateMuscleIds(msa1);
ValidateMuscleIds(msa2);
#endif
// Computing the objective score may be expensive for
// large numbers of sequences. As a speed optimization,
// we check whether the alignment changes. If it does
// not change, there is no need to compute the objective
// score. We test for the alignment changing by comparing
// the Viterbi paths before and after re-aligning.
PWPath pathBefore;
pathBefore.FromMSAPair(msa1, msa2);
DeleteGappedCols(msa1);
DeleteGappedCols(msa2);
if (0 == msa1.GetColCount() || 0 == msa2.GetColCount()) {
delete[] Ids1;
delete[] Ids2;
return false;
}
MSA msaRealigned;
PWPath pathAfter;
AlignTwoMSAs(msa1, msa2, msaRealigned, pathAfter, bLockLeft, bLockRight);
bool bAnyChanges = !pathAfter.Equal(pathBefore);
unsigned uDiffCount1;
unsigned uDiffCount2;
unsigned* Edges1 = ctx->refinehoriz.Edges1;
unsigned* Edges2 = ctx->refinehoriz.Edges2;
DiffPaths(pathBefore, pathAfter, Edges1, &uDiffCount1, Edges2, &uDiffCount2);
#if TRACE
Log("TryRealign, msa1=\n");
Log("\nmsa2=\n");
Log("\nRealigned (changes %s)=\n", bAnyChanges ? "TRUE" : "FALSE");
#endif
if (!bAnyChanges)
{
*ptrscoreBefore = 0;
*ptrscoreAfter = 0;
delete[] Ids1;
delete[] Ids2;
return false;
}
SetMSAWeightsMuscle(msaIn);
SetMSAWeightsMuscle(msaRealigned);
#if DIFFOBJSCORE
const SCORE scoreDiff = DiffObjScore(msaIn, pathBefore, Edges1, uDiffCount1,
msaRealigned, pathAfter, Edges2, uDiffCount2);
bool bAccept = (scoreDiff > 0);
*ptrscoreBefore = 0;
*ptrscoreAfter = scoreDiff;
//const SCORE scoreBefore = ObjScoreIds(msaIn, Ids1, uCount1, Ids2, uCount2);
//const SCORE scoreAfter = ObjScoreIds(msaRealigned, Ids1, uCount1, Ids2, uCount2);
//Log("Diff = %.3g %.3g\n", scoreDiff, scoreAfter - scoreBefore);
#else
const SCORE scoreBefore = ObjScoreIds(msaIn, Ids1, uCount1, Ids2, uCount2);
const SCORE scoreAfter = ObjScoreIds(msaRealigned, Ids1, uCount1, Ids2, uCount2);
bool bAccept = (scoreAfter > scoreBefore);
#if TRACE
Log("Score %g -> %g Accept %s\n", scoreBefore, scoreAfter, bAccept ? "TRUE" : "FALSE");
#endif
*ptrscoreBefore = scoreBefore;
*ptrscoreAfter = scoreAfter;
#endif
if (bAccept)
msaIn.Copy(msaRealigned);
delete[] Ids1;
delete[] Ids2;
return bAccept;
}
void ProgressiveAlign(const SeqVect &v, const Tree &GuideTree, MSA &a)
{
assert(GuideTree.IsRooted());
#if TRACE
Log("GuideTree:\n");
GuideTree.LogMe();
#endif
const unsigned uSeqCount = v.Length();
const unsigned uNodeCount = 2*uSeqCount - 1;
ProgNode *ProgNodes = new ProgNode[uNodeCount];
unsigned uJoin = 0;
unsigned uTreeNodeIndex = GuideTree.FirstDepthFirstNode();
SetProgressDesc("Align node");
do
{
if (GuideTree.IsLeaf(uTreeNodeIndex))
{
if (uTreeNodeIndex >= uNodeCount)
Quit("TreeNodeIndex=%u NodeCount=%u\n", uTreeNodeIndex, uNodeCount);
ProgNode &Node = ProgNodes[uTreeNodeIndex];
unsigned uId = GuideTree.GetLeafId(uTreeNodeIndex);
if (uId >= uSeqCount)
Quit("Seq index out of range");
const Seq &s = *(v[uId]);
Node.m_MSA.FromSeq(s);
Node.m_MSA.SetSeqId(0, uId);
Node.m_uLength = Node.m_MSA.GetColCount();
}
else
{
Progress(uJoin, uSeqCount - 1);
++uJoin;
const unsigned uMergeNodeIndex = uTreeNodeIndex;
ProgNode &Parent = ProgNodes[uMergeNodeIndex];
const unsigned uLeft = GuideTree.GetLeft(uTreeNodeIndex);
const unsigned uRight = GuideTree.GetRight(uTreeNodeIndex);
ProgNode &Node1 = ProgNodes[uLeft];
ProgNode &Node2 = ProgNodes[uRight];
PWPath Path;
AlignTwoMSAs(Node1.m_MSA, Node2.m_MSA, Parent.m_MSA, Path);
Parent.m_uLength = Parent.m_MSA.GetColCount();
Node1.m_MSA.Clear();
Node2.m_MSA.Clear();
}
uTreeNodeIndex = GuideTree.NextDepthFirstNode(uTreeNodeIndex);
}
while (NULL_NEIGHBOR != uTreeNodeIndex);
ProgressStepsDone();
unsigned uRootNodeIndex = GuideTree.GetRootNodeIndex();
const ProgNode &RootProgNode = ProgNodes[uRootNodeIndex];
a.Copy(RootProgNode.m_MSA);
delete[] ProgNodes;
ProgNodes = 0;
}
// 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;
}
