/** * 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(); }
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()); }
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 double getDistanceToLcaByFirstParameter(MultiNode leaveA, MultiNode leaveB, int tree) { MultiNode lca = getLCAFromPair(leaveA, leaveB, edgeTypes[tree]); if (lca == null) { return -1.0; } else { double dist = 0.0; do { dist += leaveA.getEdgeToParent(edgeTypes[tree]).getWeight(); leaveA = leaveA.getParent(edgeTypes[tree]); } while (leaveA != lca); return dist; } }
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;
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; }
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); } }
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);
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); } }
/** * 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); }
double weightTOChild = edgeToReroot.getWeight() - weightFromParent;
edgeWeight = node.getEdgeToParent().getWeight(); TreeNode root = tree.getRoot();
double weightTOChild = edgeToReroot.getWeight() - weightFromParent;