/** * The number of labels of all leafs in the input trees * * @param trees tree to get leafs from * @return number of leafs in this list of trees */ public static int getLeafCount(List<Tree> trees) { return getLeafLabels(trees).size(); }
/** * The set of labels of all leafs in the input trees * * @param trees tree to get leafs from * @return The Set of leaf labels */ public static Set<String> getLeafLabels(List<Tree> trees) { Set<String> leafs = new HashSet<>(); for (Tree tree : trees) { leafs.addAll(getLeafLabels(tree)); } return leafs; }
/** * The set of labels of all leafs in the input tree * * @param tree tree to get leafs from * @return The Set of leaf labels */ public static Set<String> getLeafLabels(Tree tree) { return getLeafLabels(tree.getRoot()); }
public static List<WeightedTreePartitions> getBiparts(Tree sourceTree){ List<WeightedTreePartitions> biparts = new LinkedList<>(); final TreeNode r = sourceTree.getRoot(); Set<String> sourceLeafes = getLeafLabels(r); for (TreeNode treeNode : sourceTree.getRoot().depthFirstIterator()) { if (treeNode != r && treeNode.isInnerNode()) { biparts.add(new WeightedTreePartitions(getLeafLabels(treeNode), sourceLeafes)); } } return biparts; }
public static boolean treeEquals(Tree t1, Tree t2) { if (t1.equals(t2)) return true; if (t1.vertexCount() != t2.vertexCount()) return false; Set<String> l1 = TreeUtils.getLeafLabels(t1.getRoot()); Set<String> l2 = TreeUtils.getLeafLabels(t2.getRoot()); if (!l1.equals(l2)) return false; double[] rates = FN_FP_RateComputer.calculateRates(t1, t2, false); if (rates[2] == 0d && rates[3] == 0d) { return true; } return false; }
public static double claculateMinumCharaterDeletionCosts(Tree tree, List<Tree> sourceTrees) { Set<TreeNode> deletedNodes = new HashSet<TreeNode>(); for (Tree sourceTree : sourceTrees) { for (TreeNode treeNode : sourceTree.vertices()) { if (treeNode.isInnerNode() && treeNode != sourceTree.getRoot()) { Set<String> sourceLeafLabels = getLeafLabels(treeNode); Set<TreeNode> superLeafes = getLeafesFromLabels(sourceLeafLabels, tree); TreeNode lca = tree.findLeastCommonAncestor(new ArrayList<TreeNode>(superLeafes)); Set<String> superLeafLabels = getLeafLabels(lca); if (!sourceLeafLabels.equals(superLeafLabels)) { deletedNodes.add(treeNode); } } } } double costs = 0; for (TreeNode deletedNode : deletedNodes) { costs += deletedNode.getDistanceToParent(); } return costs; }
private static int findMostCompatibleRoot(Tree tree, Tree prunedModel) { List<Set<String>> rootEdges = new ArrayList<>(prunedModel.getRoot().childCount()); //should be 2 otherwise method will not work for (TreeNode child : prunedModel.getRoot().getChildren()) { rootEdges.add(TreeUtils.getLeafLabels(child)); Set<String> allLabels = TreeUtils.getLeafLabels(tree.getRoot()); p1 = TreeUtils.getLeafLabels(node); } else { p1 = new HashSet<>(1);
public static Tree addCladewiseSplitFit(List<WeightedTreePartitions> biparts, Tree tree) { Map<Set<String>, TreeNode> labelsToClade = getChildrenMap(tree); Set<String> all = getLeafLabels(tree); Map<WeightedTreePartitions, AtomicDouble> partitionsToConflicts = new HashMap<>(labelsToClade.size()); for (Set<String> leafesInClade : labelsToClade.keySet()) { partitionsToConflicts.put(new WeightedTreePartitions(leafesInClade, all), new AtomicDouble(0)); } double numberOfChars = 0; for (WeightedTreePartitions sourcePartition : biparts) { numberOfChars += sourcePartition.weight; for (Map.Entry<WeightedTreePartitions, AtomicDouble> e : partitionsToConflicts.entrySet()) { if (e.getKey().isIncompatible(sourcePartition)) { e.getValue().addAndGet(e.getKey().weight); } } } for (Map.Entry<WeightedTreePartitions, AtomicDouble> entry : partitionsToConflicts.entrySet()) { TreeNode first = labelsToClade.remove(entry.getKey().getGroupA()); TreeNode second = labelsToClade.remove(entry.getKey().getGroupB()); String l = String.valueOf(1 - (entry.getValue().doubleValue() / numberOfChars)); if (first != null) first.setLabel(l); if (second != null) second.setLabel(l); } return tree; }
private static int findMostCompatibleFakeRoot(Tree tree, Tree prunedModel) { List<Set<String>> rootEdges = new ArrayList<>(prunedModel.getRoot().childCount()); //should be >2 otherwise use the real root method for (TreeNode child : prunedModel.getRoot().getChildren()) { rootEdges.add(TreeUtils.getLeafLabels(child)); Set<String> allLabels = TreeUtils.getLeafLabels(tree.getRoot()); Set<String> clade = TreeUtils.getLeafLabels(child); if (splitsCopy.contains(clade)) splitsCopy.remove(clade); clade.removeAll(TreeUtils.getLeafLabels(node)); if (splitsCopy.contains(clade)) splitsCopy.remove(clade);
rootEdges.add(TreeUtils.getLeafLabels(child)); Set<String> allLabels = TreeUtils.getLeafLabels(tree.getRoot()); boolean newRootFound = false; Set<String> p1; if (node.isInnerNode()) { p1 = TreeUtils.getLeafLabels(node); } else { p1 = new HashSet<String>(1);
rootEdge.add(TreeUtils.getLeafLabels(child)); Set<String> allLabels = TreeUtils.getLeafLabels(tree.getRoot()); boolean newRootFound = false; Set<String> p1; if (node.isInnerNode()) { p1 = TreeUtils.getLeafLabels(node); } else { p1 = new HashSet<String>(1);
Set<String> characterTaxa = getLeafLabels(character); Tree sourceTree = (Tree) character.getGraph(); TreeNode[] sourceTreeTaxa = sourceTree.getLeaves();
public static void addCladewiseSplitFit(List<Tree> sourceTrees, FlipCutWeights.Weights weighting, Collection<Tree> trees) { final SimpleCosts comp; if (weighting == FlipCutWeights.Weights.UNIT_COST) { comp = new UnitCostComputer(sourceTrees,null); } else { comp = new WeightCostComputer(sourceTrees,weighting); } List<WeightedTreePartitions> biparts = new LinkedList<>(); for (Tree sourceTree : sourceTrees) { final TreeNode r = sourceTree.getRoot(); Set<String> sourceLeafes = getLeafLabels(r); for (TreeNode treeNode : sourceTree.getRoot().depthFirstIterator()) { if (treeNode != r && treeNode.isInnerNode()) { biparts.add(new WeightedTreePartitions(getLeafLabels(treeNode), sourceLeafes, comp.getEdgeWeight(treeNode))); } } } for (Tree tree : trees) { addCladewiseSplitFit(biparts, tree); } } }
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; }
if (!sibling.equals(node)) { numOfSiblings++; siblingLeaves.addAll(TreeUtils.getLeafLabels(sibling));
Set<String> clade = TreeUtils.getLeafLabels(node); if (clade.size() > 2 && (numTaxa - clade.size()) > 2) {
if (singleTaxon.numOfSiblings == 1) { Set<String> s = new THashSet<>(TreeUtils.getLeafLabels(lca)); s.retainAll(commonLeafes); Set<String> s2 = new HashSet<>(singleTaxon.siblingLeaves);