string TreeTemplateTools::treeToParenthesis(const TreeTemplate<Node>& tree, bool writeId)
{
ostringstream s;
s << "(";
const Node* node = tree.getRootNode();
if (node->hasNoSon())
{
s << node->getName();
for (size_t i = 0; i < node->getNumberOfSons(); ++i)
{
s << "," << nodeToParenthesis(*node->getSon(i), writeId);
}
}
else
{
s << nodeToParenthesis(*node->getSon(0), writeId);
for (size_t i = 1; i < node->getNumberOfSons(); ++i)
{
s << "," << nodeToParenthesis(*node->getSon(i), writeId);
}
}
s << ")";
if (node->hasDistanceToFather())
s << ":" << node->getDistanceToFather();
s << ";" << endl;
return s.str();
}
double TreeTemplateTools::getRadius(TreeTemplate<Node>& tree)
{
TreeTemplateTools::midRoot(tree, MIDROOT_SUM_OF_SQUARES, false);
Moments_ moments = getSubtreeMoments_(tree.getRootNode());
double radius = moments.sum / moments.numberOfLeaves;
return radius;
}
string TreeTemplateTools::treeToParenthesis(const TreeTemplate<Node>& tree, bool bootstrap, const string& propertyName)
{
ostringstream s;
s << "(";
const Node* node = tree.getRootNode();
if (node->hasNoSon())
{
s << node->getName();
for (size_t i = 0; i < node->getNumberOfSons(); i++)
{
s << "," << nodeToParenthesis(*node->getSon(i), bootstrap, propertyName);
}
}
else
{
s << nodeToParenthesis(*node->getSon(0), bootstrap, propertyName);
for (size_t i = 1; i < node->getNumberOfSons(); i++)
{
s << "," << nodeToParenthesis(*node->getSon(i), bootstrap, propertyName);
}
}
s << ")";
if (bootstrap)
{
if (node->hasBranchProperty(TreeTools::BOOTSTRAP))
s << (dynamic_cast<const Number<double>*>(node->getBranchProperty(TreeTools::BOOTSTRAP))->getValue());
}
else
{
if (node->hasBranchProperty(propertyName))
{
const BppString* ppt = dynamic_cast<const BppString*>(node->getBranchProperty(propertyName));
if (ppt)
s << *ppt;
else
throw Exception("TreeTemplateTools::nodeToParenthesis. Property should be a BppString.");
}
}
s << ";" << endl;
return s.str();
}
RecursiveLikelihoodTree::RecursiveLikelihoodTree(const SubstitutionProcess& process, bool usepatterns) :
AbstractLikelihoodTree(process),
vTree_(),
patternLinks_(),
usePatterns_(usepatterns),
initializedAboveLikelihoods_(false)
{
TreeTemplate<Node> tree = process.getParametrizableTree().getTree();
RecursiveLikelihoodNode* rCN = TreeTemplateTools::cloneSubtree<RecursiveLikelihoodNode>(*tree.getRootNode());
TreeTemplate<RecursiveLikelihoodNode>* pTC = new TreeTemplate<RecursiveLikelihoodNode>(rCN);
for (size_t i = 0; i < nbClasses_; i++)
{
TreeTemplate<RecursiveLikelihoodNode>* pTC2 = pTC->clone();
vTree_.push_back(pTC2);
}
delete pTC;
}
void TreeTemplateTools::midRoot(TreeTemplate<Node>& tree, short criterion, bool forceBranchRoot)
{
if (criterion != MIDROOT_VARIANCE && criterion != MIDROOT_SUM_OF_SQUARES)
throw Exception("TreeTemplateTools::midRoot(). Illegal criterion value '" + TextTools::toString(criterion) + "'");
if (tree.isRooted())
tree.unroot();
Node* ref_root = tree.getRootNode();
//
// The bestRoot object records :
// -- the current best branch : .first
// -- the current best value of the criterion : .second["value"]
// -- the best position of the root on the branch : .second["position"]
// 0 is toward the original root, 1 is away from it
//
pair<Node*, map<string, double> > best_root_branch;
best_root_branch.first = ref_root; // nota: the root does not correspond to a branch as it has no father
best_root_branch.second ["position"] = -1;
best_root_branch.second ["score"] = numeric_limits<double>::max();
// find the best root
getBestRootInSubtree_(tree, criterion, ref_root, best_root_branch);
tree.rootAt(ref_root); // back to the original root
// reroot
const double pos = best_root_branch.second["position"];
if (pos < 1e-6 or pos > 1 - 1e-6)
// The best root position is on a node (this is often the case with the sum of squares criterion)
tree.rootAt(pos < 1e-6 ? best_root_branch.first->getFather() : best_root_branch.first);
else
// The best root position is somewhere on a branch (a new Node is created)
{
Node* new_root = new Node();
new_root->setId( TreeTools::getMPNUId(tree, tree.getRootId()) );
double root_branch_length = best_root_branch.first->getDistanceToFather();
Node* best_root_father = best_root_branch.first->getFather();
best_root_father->removeSon(best_root_branch.first);
best_root_father->addSon(new_root);
new_root->addSon(best_root_branch.first);
new_root->setDistanceToFather(max(pos * root_branch_length, 1e-6));
best_root_branch.first->setDistanceToFather(max((1 - pos) * root_branch_length, 1e-6));
// The two branches leaving the root must have the same branch properties
const vector<string> branch_properties = best_root_branch.first->getBranchPropertyNames();
for (vector<string>::const_iterator p = branch_properties.begin(); p != branch_properties.end(); ++p)
{
new_root->setBranchProperty(*p, *best_root_branch.first->getBranchProperty(*p));
}
tree.rootAt(new_root);
}
if (forceBranchRoot) // if we want the root to be on a branch, not on a node
{
Node* orig_root = tree.getRootNode();
vector<Node*> root_sons = orig_root->getSons();
if (root_sons.size() > 2)
{
Node* nearest = root_sons.at(0);
for (vector<Node*>::iterator n = root_sons.begin(); n !=
root_sons.end(); ++n)
{
if ((**n).getDistanceToFather() < nearest->getDistanceToFather())
nearest = *n;
}
const double d = nearest->getDistanceToFather();
Node* new_root = new Node();
new_root->setId( TreeTools::getMPNUId(tree, tree.getRootId()) );
orig_root->removeSon(nearest);
orig_root->addSon(new_root);
new_root->addSon(nearest);
new_root->setDistanceToFather(d / 2.);
nearest->setDistanceToFather(d / 2.);
const vector<string> branch_properties = nearest->getBranchPropertyNames();
for (vector<string>::const_iterator p = branch_properties.begin(); p != branch_properties.end(); ++p)
{
new_root->setBranchProperty(*p, *nearest->getBranchProperty(*p));
}
tree.rootAt(new_root);
}
}
}
void ClusterTools::computeNormProperties(TreeTemplate<Node>& tree, const ProbabilisticSubstitutionMapping & mapping)
{
double min;
computeNormProperties_(tree.getRootNode(), mapping, min);
}
vector<const Node *> ClusterTools::getSubtreesWithSize(const TreeTemplate<Node>& tree, size_t size)
{
vector<const Node *> subtrees;
getSubtreesWithSize(tree.getRootNode(), size, subtrees);
return subtrees;
}