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();
}
bool RefineSubfams(MSA &msa, const Tree &tree, unsigned uIters)
{
MuscleContext *ctx = getMuscleContext();
CLUSTER &g_Cluster2 = ctx->params.g_Cluster2;
DISTANCE &g_Distance2 = ctx->params.g_Distance2;
ROOT &g_Root2 = ctx->params.g_Root2;
bool &g_bAnchors = ctx->params.g_bAnchors;
const unsigned uSeqCount = msa.GetSeqCount();
if (uSeqCount < 3)
return false;
const double dMaxHeight = 0.6;
const unsigned uMaxSubfamCount = 16;
//const unsigned uNodeCount = tree.GetNodeCount();
unsigned *Subfams;
unsigned uSubfamCount;
GetSubfams(tree, dMaxHeight, uMaxSubfamCount, &Subfams, &uSubfamCount);
assert(uSubfamCount <= uSeqCount);
if (ctx->params.g_bVerbose)
LogSubfams(tree, Subfams, uSubfamCount);
MSA *SubfamMSAs = new MSA[uSubfamCount];
unsigned *Leaves = new unsigned[uSeqCount];
unsigned *Ids = new unsigned[uSeqCount];
bool bAnyChanges = false;
for (unsigned uSubfamIndex = 0; uSubfamIndex < uSubfamCount; ++uSubfamIndex)
{
unsigned uSubfam = Subfams[uSubfamIndex];
unsigned uLeafCount;
GetLeaves(tree, uSubfam, Leaves, &uLeafCount);
assert(uLeafCount <= uSeqCount);
LeafIndexesToIds(tree, Leaves, uLeafCount, Ids);
MSA &msaSubfam = SubfamMSAs[uSubfamIndex];
MSASubsetByIds(msa, Ids, uLeafCount, msaSubfam);
DeleteGappedCols(msaSubfam);
#if TRACE
Log("Subfam %u MSA=\n", uSubfamIndex);
msaSubfam.LogMe();
#endif
if (msaSubfam.GetSeqCount() <= 2)
continue;
// TODO /////////////////////////////////////////
// Try using existing tree, may actually hurt to
// re-estimate, may also be a waste of CPU & mem.
/////////////////////////////////////////////////
Tree SubfamTree;
TreeFromMSA(msaSubfam, SubfamTree, g_Cluster2, g_Distance2, g_Root2);
bool bAnyChangesThisSubfam;
if (g_bAnchors)
bAnyChangesThisSubfam = RefineVert(msaSubfam, SubfamTree, uIters);
else
bAnyChangesThisSubfam = RefineHoriz(msaSubfam, SubfamTree, uIters, false, false);
#if TRACE
Log("Subfam %u Changed %d\n", uSubfamIndex, bAnyChangesThisSubfam);
#endif
if (bAnyChangesThisSubfam)
bAnyChanges = true;
}
if (bAnyChanges)
ProgressiveAlignSubfams(tree, Subfams, uSubfamCount, SubfamMSAs, msa);
delete[] Leaves;
delete[] Subfams;
delete[] SubfamMSAs;
return bAnyChanges;
}
void Refine()
{
SetOutputFileName(g_pstrOutFileName.get());
SetInputFileName(g_pstrInFileName.get());
SetStartTime();
SetMaxIters(g_uMaxIters.get());
SetSeqWeightMethod(g_SeqWeight1.get());
TextFile fileIn(g_pstrInFileName.get());
MSA msa;
msa.FromFile(fileIn);
const unsigned uSeqCount = msa.GetSeqCount();
if (0 == uSeqCount)
Quit("No sequences in input file");
ALPHA Alpha = ALPHA_Undefined;
switch (g_SeqType.get())
{
case SEQTYPE_Auto:
Alpha = msa.GuessAlpha();
break;
case SEQTYPE_Protein:
Alpha = ALPHA_Amino;
break;
case SEQTYPE_DNA:
Alpha = ALPHA_DNA;
break;
case SEQTYPE_RNA:
Alpha = ALPHA_RNA;
break;
default:
Quit("Invalid SeqType");
}
SetAlpha(Alpha);
msa.FixAlpha();
SetPPScore();
if (ALPHA_DNA == Alpha || ALPHA_RNA == Alpha)
SetPPScore(PPSCORE_SPN);
MSA::SetIdCount(uSeqCount);
// Initialize sequence ids.
// From this point on, ids must somehow propogate from here.
for (unsigned uSeqIndex = 0; uSeqIndex < uSeqCount; ++uSeqIndex)
msa.SetSeqId(uSeqIndex, uSeqIndex);
SetMuscleInputMSA(msa);
Tree GuideTree;
TreeFromMSA(msa, GuideTree, g_Cluster2.get(), g_Distance2.get(), g_Root2.get());
SetMuscleTree(GuideTree);
if (g_bAnchors.get())
RefineVert(msa, GuideTree, g_uMaxIters.get());
else
RefineHoriz(msa, GuideTree, g_uMaxIters.get(), false, false);
ValidateMuscleIds(msa);
ValidateMuscleIds(GuideTree);
// TextFile fileOut(g_pstrOutFileName.get(), true);
// msa.ToFile(fileOut);
MuscleOutput(msa);
}
void ProgAlignSubFams()
{
MSA msaOut;
SetOutputFileName(g_pstrOutFileName.get());
SetInputFileName(g_pstrInFileName.get());
SetMaxIters(g_uMaxIters.get());
SetSeqWeightMethod(g_SeqWeight1.get());
TextFile fileIn(g_pstrInFileName.get());
SeqVect v;
v.FromFASTAFile(fileIn);
const unsigned uSeqCount = v.Length();
if (0 == uSeqCount)
Quit("No sequences in input file");
ALPHA Alpha = ALPHA_Undefined;
switch (g_SeqType.get())
{
case SEQTYPE_Auto:
Alpha = v.GuessAlpha();
break;
case SEQTYPE_Protein:
Alpha = ALPHA_Amino;
break;
case SEQTYPE_DNA:
Alpha = ALPHA_DNA;
break;
case SEQTYPE_RNA:
Alpha = ALPHA_RNA;
break;
default:
Quit("Invalid seq type");
}
SetAlpha(Alpha);
v.FixAlpha();
PTR_SCOREMATRIX UserMatrix = 0;
if (0 != g_pstrMatrixFileName.get())
{
const char *FileName = g_pstrMatrixFileName.get();
const char *Path = getenv("MUSCLE_MXPATH");
if (Path != 0)
{
size_t n = strlen(Path) + 1 + strlen(FileName) + 1;
char *NewFileName = new char[n];
sprintf(NewFileName, "%s/%s", Path, FileName);
FileName = NewFileName;
}
TextFile File(FileName);
UserMatrix = ReadMx(File);
g_Alpha = ALPHA_Amino;
g_PPScore = PPSCORE_SP;
}
SetPPScore();
if (0 != UserMatrix)
g_ptrScoreMatrix = UserMatrix;
if (ALPHA_DNA == Alpha || ALPHA_RNA == Alpha)
{
SetPPScore(PPSCORE_SPN);
g_Distance1.get() = DISTANCE_Kmer4_6;
}
unsigned uMaxL = 0;
unsigned uTotL = 0;
for (unsigned uSeqIndex = 0; uSeqIndex < uSeqCount; ++uSeqIndex)
{
unsigned L = v.GetSeq(uSeqIndex).Length();
uTotL += L;
if (L > uMaxL)
uMaxL = L;
}
SetIter(1);
g_bDiags.get() = g_bDiags1.get();
SetSeqStats(uSeqCount, uMaxL, uTotL/uSeqCount);
SetMuscleSeqVect(v);
MSA::SetIdCount(uSeqCount);
// Initialize sequence ids.
// From this point on, ids must somehow propogate from here.
for (unsigned uSeqIndex = 0; uSeqIndex < uSeqCount; ++uSeqIndex)
v.SetSeqId(uSeqIndex, uSeqIndex);
if (uSeqCount > 1)
MHackStart(v);
if (0 == uSeqCount)
{
msaOut.Clear();
return;
}
if (1 == uSeqCount && ALPHA_Amino == Alpha)
{
const Seq &s = v.GetSeq(0);
msaOut.FromSeq(s);
return;
}
Tree GuideTree;
TreeFromSeqVect(v, GuideTree, g_Cluster1.get(), g_Distance1.get(), g_Root1.get());
SetMuscleTree(GuideTree);
MSA msa;
if (g_bLow.get())
{
ProgNode *ProgNodes = 0;
ProgNodes = ProgressiveAlignE(v, GuideTree, msa);
delete[] ProgNodes;
}
else
ProgressiveAlign(v, GuideTree, msa);
SetCurrentAlignment(msa);
TreeFromMSA(msa, GuideTree, g_Cluster2.get(), g_Distance2.get(), g_Root2.get());
SetMuscleTree(GuideTree);
unsigned *SubFams = new unsigned[uSeqCount];
unsigned uSubFamCount;
SubFam(GuideTree, g_uMaxSubFamCount.get(), SubFams, &uSubFamCount);
SetProgressDesc("Align node");
const unsigned uNodeCount = 2*uSeqCount - 1;
ProgNode *ProgNodes = new ProgNode[uNodeCount];
bool *NodeIsSubFam = new bool[uNodeCount];
bool *NodeInSubFam = new bool[uNodeCount];
for (unsigned i = 0; i < uNodeCount; ++i)
{
NodeIsSubFam[i] = false;
NodeInSubFam[i] = false;
}
for (unsigned i = 0; i < uSubFamCount; ++i)
{
unsigned uNodeIndex = SubFams[i];
assert(uNodeIndex < uNodeCount);
NodeIsSubFam[uNodeIndex] = true;
SetInFam(GuideTree, uNodeIndex, NodeInSubFam);
}
unsigned uJoin = 0;
unsigned uTreeNodeIndex = GuideTree.FirstDepthFirstNode();
do
{
if (NodeIsSubFam[uTreeNodeIndex])
{
#if TRACE
Log("Node %d: align subfam\n", uTreeNodeIndex);
#endif
ProgNode &Node = ProgNodes[uTreeNodeIndex];
AlignSubFam(v, GuideTree, uTreeNodeIndex, Node.m_MSA);
Node.m_uLength = Node.m_MSA.GetColCount();
}
else if (!NodeInSubFam[uTreeNodeIndex])
{
#if TRACE
Log("Node %d: align two subfams\n", uTreeNodeIndex);
#endif
Progress(uJoin, uSubFamCount - 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();
}
else
{
#if TRACE
Log("Node %d: in subfam\n", uTreeNodeIndex);
#endif
;
}
uTreeNodeIndex = GuideTree.NextDepthFirstNode(uTreeNodeIndex);
}
while (NULL_NEIGHBOR != uTreeNodeIndex);
ProgressStepsDone();
unsigned uRootNodeIndex = GuideTree.GetRootNodeIndex();
ProgNode &RootProgNode = ProgNodes[uRootNodeIndex];
TextFile fOut(g_pstrOutFileName.get(), true);
MHackEnd(RootProgNode.m_MSA);
RootProgNode.m_MSA.ToFile(fOut);
delete[] NodeInSubFam;
delete[] NodeIsSubFam;
delete[] ProgNodes;
delete[] SubFams;
ProgNodes = 0;
NodeInSubFam = 0;
NodeIsSubFam = 0;
SubFams = 0;
}
