@SuppressWarnings("unchecked") public Edge<TreeNode> getEdge(Vertex oppositNode) { if (edges == null) { return null; } for (Edge<TreeNode> e : edges) { if (e.getOpposit(this) == oppositNode) return e; } return null; }
/** * Check the edges source/target for this node and returns true if this * node contains the given edge as incoming or outgoing edge. */ public boolean containsEdge(Edge<MultiNode> e) { if (e.getSource() == this) { Edge e1 = incomingEdges.get(e.getType()); return (e1 != null && e1 == e); } else { ArrayList<Edge<MultiNode>> l = outgoingEdges.get(e.getType()); if (l != null) { return l.contains(e); } } return false; }
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()); }
TreeNode source = edge.getSource(); TreeNode target = edge.getTarget(); 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); tree.removeEdge(source.getParent(), source); tree.addEdge(currentRoot, source).setWeight(sourceWeight); tree.addEdge(last, node).setWeight(path.get(node)); last = node; tree.addEdge(rootchild, rchild).setWeight(w);
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); } }
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; }
/** * 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(); }
/** * Return the parent of this node. * * @return parent the parent TreeNode or null */ public TreeNode getParent() { if (incompingEdge == null) return null; return incompingEdge.getSource(); }
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); } }
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; }
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; } }
public int indegree(EdgeType type) { if (!type.directed) return 0; int sum = 0; List<E> l = adjList.get(type); for (E e : l) { if (e.getTarget() == this) sum++; } return sum; }
/** * Returns the parent connected with specified type or null * * @param type * @return parent of given type or null */ public MultiNode getParent(EdgeType type) { Edge<MultiNode> e = getEdgeToParent(type); return e != null ? e.getSource() : null; }