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 void buildNormTrees() { normalizedTrees = new ArrayList<Tree>(trees.size()); for (int i = 0; i < factors.length; i++) { double factor = factors[i]; Tree clone = trees.get(i).cloneTree(); if (factor != 1d) { Set<Edge> edges = new HashSet<Edge>(clone.edgeCount()); for (TreeNode node : clone.getRoot().depthFirstIterator()) { edges.addAll(node.getAllEdges()); } for (Edge edge : edges) { edge.setWeight(edge.getWeight() * factor); } } normalizedTrees.add(clone); } }
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; }
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()); }
/** * 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); } }
public MultiTree copy() { // System.out.println(" in copy " + this.edgeCount()); MultiTree copy = new MultiTree(); // do real array copy copy.edgeTypes = new EdgeType[edgeTypes.length]; System.arraycopy(edgeTypes, 0, copy.edgeTypes, 0, edgeTypes.length); copy.treeWeights = new double[treeWeights.length]; System.arraycopy(treeWeights, 0, copy.treeWeights, 0, treeWeights.length); // add all vertices to the copy Iterator<MultiNode> nodeIter = this.vertices().iterator(); while (nodeIter.hasNext()) { MultiNode node = nodeIter.next(); MultiNode copy_n = new MultiNode(); copy_n.setIndex(node.getIndex()); copy_n.setLabel(node.getLabel()); copy.addVertex(copy_n); } // add edges for (EdgeType type : edgeTypes) { Iterator<MultiNode> nodeIter2 = this.vertices().iterator(); while (nodeIter2.hasNext()) { MultiNode curr = nodeIter2.next(); // ArrayList<Edge> edges = new ArrayList<Edge>(); for (Edge<MultiNode> edge : curr.edges(type)) { copy.addEdge(curr.getIndex(), edge.getOpposit(curr).getIndex(), type).setWeight(edge.getWeight()); } } } return copy; }
if (n.getEdgeToParent() != null) n.getEdgeToParent().setWeight(1.0);
private static void connectParent(Tree tree, TreeNode newRoot, TreeNode parent, double weight) { TreeNode next = parent.getParent(); double nextWeight = 1; if (next != null) { nextWeight = tree.getEdge(next, parent).getWeight(); tree.removeEdge(next, parent); } tree.addEdge(newRoot, parent).setWeight(weight); if (next != null) { connectParent(tree, parent, next, nextWeight); } }
@SuppressWarnings("unchecked") private void hangIn(TreeNode newParent, TreeNode oldParent, Tree tree) { for (TreeNode n : oldParent.children()) { TreeNode newNode = n.cloneNode(); newNode.setIndex(-1); tree.addVertex(newNode); Edge edge = tree.addEdge(newParent, newNode); edge.setWeight(n.getDistanceToParent()); hangIn(newNode, n, tree); } }
private static void stepUp(Tree tree, TreeNode child, TreeNode parent, String oldChildLabel) { TreeNode newParent = parent.getParent(); String newOldLabel = parent.getLabel(); double weight = child.getDistanceToParent(); tree.removeEdge(parent, child); tree.addEdge(child, parent).setWeight(weight); parent.setLabel(oldChildLabel); if (newParent != null) { stepUp(tree, parent, newParent, newOldLabel); } }
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); } }
tree.addEdge(currentRoot, target).setWeight(w); tree.removeEdge(source.getParent(), source); tree.addEdge(currentRoot, source).setWeight(sourceWeight); tree.addEdge(last, node).setWeight(path.get(node)); last = node; tree.removeEdge(rchild.getParent(), rchild); tree.addEdge(rootchild, rchild).setWeight(w);
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); } } }
/** * Reroot tree with the new root placed at the incomming edge of the given outgroup * * @param tree the tree * @param outgroup the outgroup taxon */ public static void rerootToOutgroup(Tree tree, TreeNode outgroup, double edgeLengthToOutgroup) { TreeNode parent = outgroup.getParent(); if (parent == null) return; TreeNode newRoot = new TreeNode(); // add outgroup to new root tree.addVertex(newRoot); double oldWeight = tree.getEdge(parent, outgroup).getWeight(); tree.removeEdge(parent, outgroup); final Edge<TreeNode> edge = tree.addEdge(newRoot, outgroup); edge.setWeight(edgeLengthToOutgroup); // connect parent connectParent(tree, newRoot, parent, oldWeight - edgeLengthToOutgroup); tree.setRoot(newRoot); pruneDegreeOneNodes(tree); }