/** * Returns the distance to the parent node. * If the node has no parent (root node ) -1 is returned. * * @return distance to parent or -1 (if there is no parent) */ public double getDistanceToParent() { if (getEdgeToParent() == null) return -1;// null; return getEdgeToParent().getWeight(); }
/** * Compute a list of ALL edges of a given {@link TreeNode}. * ALL means all adjacent edges to the node. That are all edges to children and the edge to * the parent (if there is one). * <p> * Runtime: O(d) */ public ArrayList<Edge<TreeNode>> getAllEdges() { ArrayList<Edge<TreeNode>> edges = new ArrayList<Edge<TreeNode>>(); for (Edge<TreeNode> edge : this.edges()) { edges.add(edge); } if (!(this.getEdgeToParent() == null)) { edges.add(this.getEdgeToParent()); } return edges; }
private static void mergeTreeIntoTopology(LeafMappedTree topology, Map<Set<String>, TreeNode> treeToMergeAsLeafMap, Tree treeToMerge) { Map<Set<String>, TreeNode> toplogyAsLeafMap = topology.treeAsLeafMap; for (Map.Entry<Set<String>, TreeNode> entry : toplogyAsLeafMap.entrySet()) { TreeNode topologyNode = entry.getValue(); TreeNode treeToMergeNode = treeToMergeAsLeafMap.get(entry.getKey()); Edge topologyEdgeToParent = topologyNode.getEdgeToParent(); topologyEdgeToParent.setWeight(topologyEdgeToParent.getWeight() + treeToMergeNode.getEdgeToParent().getWeight()); checkForChilds(topologyNode, treeToMergeNode); } //check for root children checkForChilds(topology.tree.getRoot(), treeToMerge.getRoot()); }
public static void addLeafesFromChildren(final Map<Set<String>, TreeNode> childrenSets, final TreeNode current, final Set<String> parentTaxaSet, final boolean setEdgeweightsToZero) { if (setEdgeweightsToZero) current.getEdgeToParent().setWeight(0d); if (current.isLeaf()) { parentTaxaSet.add(current.getLabel()); } else { Set<String> currentTaxaSet = new HashSet<String>(); for (TreeNode child : current.children()) { addLeafesFromChildren(childrenSets, child, currentTaxaSet, setEdgeweightsToZero); } parentTaxaSet.addAll(currentTaxaSet); childrenSets.put(currentTaxaSet, current); } }
private static boolean mergeTrees(Map<Set<String>, TreeNode> mergedTreeAsMap, Tree mergedTree, Set<Map<Set<String>, TreeNode>> trees2AddAsMap, Map<Map<Set<String>, TreeNode>, Tree> trees2Add) { //merge edges to leaves for (Map<Set<String>, TreeNode> tree2AddAsMap : trees2AddAsMap) { Tree tree2Add = trees2Add.get(tree2AddAsMap); for (TreeNode leaf : mergedTree.getLeaves()) { Edge e = leaf.getEdgeToParent(); e.setWeight(tree2Add.getVertex(leaf.getLabel()).getDistanceToParent() + e.getWeight()); } } //merge inner edges Iterator<Set<String>> tMerge = mergedTreeAsMap.keySet().iterator(); while (tMerge.hasNext()) { Set<String> nodeMerge = tMerge.next(); for (Map<Set<String>, TreeNode> tree2AddAsMap : trees2AddAsMap) { Iterator<Set<String>> t2Add = tree2AddAsMap.keySet().iterator(); while (t2Add.hasNext()) { Set<String> node2Add = t2Add.next(); if (node2Add.equals(nodeMerge)) { double weight = tree2AddAsMap.get(node2Add).getDistanceToParent(); tree2AddAsMap.remove(node2Add); Edge edge = mergedTreeAsMap.get(nodeMerge).getEdgeToParent(); edge.setWeight(edge.getWeight() + weight); break; } } } } return true; }
public static Map<Set<String>, TreeNode> getChildrenMap(final Tree tree, final boolean setEdgeweightsToZero) { Map<Set<String>, TreeNode> childrenSets = new HashMap<Set<String>, TreeNode>(tree.vertexCount()); for (TreeNode node : tree.vertices()) { if (node.isInnerNode()) { if (node != tree.getRoot()) { if (setEdgeweightsToZero) node.getEdgeToParent().setWeight(0d); childrenSets.put(getLeafLabels(node), node); } } else { if (setEdgeweightsToZero) node.getEdgeToParent().setWeight(0d); } } return childrenSets; }
TreeUtils.reorderingBootstrapLabelsForRooting(bestRoot.getEdgeToParent()); TreeUtils.rerootToOutgroup(tree, bestRoot);
TreeUtils.reorderingBootstrapLabelsForRooting(node.getEdgeToParent()); TreeUtils.rerootToOutgroup(tree, node); TreeUtils.reorderingBootstrapLabelsForRooting(node.getEdgeToParent()); TreeUtils.rerootToOutgroup(tree, node);
TreeUtils.reorderingBootstrapLabelsForRooting(node.getEdgeToParent()); TreeUtils.rerootToOutgroup(tree, node);
private static void checkForChilds(TreeNode topologyNode, TreeNode treeToMergeNode) { for (TreeNode topologyChild : topologyNode.children()) { if (topologyChild.isLeaf()) { double treeToMergeEdgeWeight = 0; for (TreeNode treeToMergeChild : treeToMergeNode.children()) { if (treeToMergeChild.isLeaf() && treeToMergeChild.getLabel().equalsIgnoreCase(topologyChild.getLabel())) { //found the correct child treeToMergeEdgeWeight = treeToMergeChild.getEdgeToParent().getWeight(); break; } } Edge topologyChildEdgeToParent = topologyChild.getEdgeToParent(); topologyChildEdgeToParent.setWeight(topologyChildEdgeToParent.getWeight() + treeToMergeEdgeWeight); } } }
globalScore += (column.getEdgeToParent().getWeight() * (double) localScore); } else { globalScore += (double) localScore;
/** * Removes al inner vertices on the tree and sets branch length to 1 * the given tree is modified * * @param tree the source tree */ public static void cleanTree(Tree tree) { for (TreeNode node : tree.getRoot().depthFirstIterator()) { if (!node.equals(tree.getRoot())) node.getEdgeToParent().setWeight(1d); if (node.isInnerNode()) node.setLabel(null); } }
private void hangIn(TreeNode n, HashMap<String, MultiNode> labeledNodes, HashMap<TreeNode, MultiNode> all, EdgeType type) { MultiNode m = null; if (n.getLabel() != null) { m = labeledNodes.get(n.getLabel()); } if (m == null) { m = new MultiNode(); all.put(n, m); if (n.getLabel() != null) { m.setLabel(n.getLabel()); labeledNodes.put(n.getLabel(), m); } addVertex(m); } if (n.getEdgeToParent() != null) { MultiNode p = all.get(n.getParent()); addEdge(p, m, type).setWeight(n.getEdgeToParent().getWeight()); } for (TreeNode c : n.children()) { hangIn(c, labeledNodes, all, type); } }
if (n.getEdgeToParent() != null) n.getEdgeToParent().setWeight(1.0);
nodes.add(rootedModel.getVertex(s)); Edge<TreeNode> edgeToReroot = rootedModel.findLeastCommonAncestor(nodes).getEdgeToParent(); TreeUtils.reorderingBootstrapLabelsForRooting(edgeToReroot); TreeUtils.rerootToOutgroup(rootedModel, edgeToReroot.getTarget());
private static void moveUP(Edge<TreeNode> edgeForLabelMove, String label) { String newLabel = edgeForLabelMove.getSource().getLabel(); edgeForLabelMove.getSource().setLabel(label); if (newLabel != null) moveUP(edgeForLabelMove.getSource().getEdgeToParent(), newLabel); }
double sourceWeight = source.getParent() != null ? source.getEdgeToParent().getWeight() : 1.0; TreeNode rootchild = source; while (next != null && next != currentRoot) { path.put(next, next.getEdgeToParent().getWeight()); rootchild = next; next = next.getParent(); for (TreeNode c : currentRoot.children()) { if (c != rootchild) { otherRootChildren.put(c, c.getEdgeToParent().getWeight()); double w = target.getEdgeToParent().getWeight(); tree.removeEdge(target.getParent(), target); tree.addEdge(currentRoot, target).setWeight(w); if (rchild.getEdgeToParent() != null) { tree.removeEdge(rchild.getParent(), rchild);
distanceToAncestor = pathLeaf1.getDistanceToParent(); parent = pathLeaf1.getParent(); edgeToReroot = pathLeaf1.getEdgeToParent(); while (distanceToAncestor < (pathlength / 2) && parent != anc) { distanceToAncestor += parent.getDistanceToParent(); edgeToReroot = parent.getEdgeToParent(); parent = parent.getParent(); distanceToAncestor = pathLeaf1.getDistanceToParent(); parent = pathLeaf2.getParent(); edgeToReroot = pathLeaf2.getEdgeToParent(); while (distanceToAncestor < (pathlength / 2) && parent != anc) { distanceToAncestor += parent.getDistanceToParent(); edgeToReroot = parent.getEdgeToParent(); parent = parent.getParent();
distanceToAncestor = pathLeaf1.getDistanceToParent(); parent = pathLeaf1.getParent(); edgeToReroot = pathLeaf1.getEdgeToParent(); while (distanceToAncestor < (pathlength / 2) && parent != anc) { distanceToAncestor += parent.getDistanceToParent(); edgeToReroot = parent.getEdgeToParent(); parent = parent.getParent(); distanceToAncestor = pathLeaf1.getDistanceToParent(); parent = pathLeaf2.getParent(); edgeToReroot = pathLeaf2.getEdgeToParent(); while (distanceToAncestor < (pathlength / 2) && parent != anc) { distanceToAncestor += parent.getDistanceToParent(); edgeToReroot = parent.getEdgeToParent(); parent = parent.getParent();
edgeWeight = node.getEdgeToParent().getWeight(); TreeNode root = tree.getRoot();