How to use

getDistanceToParent

method

in

phylo.tree.model.TreeNode

  private double calcEdgeWeight(TreeNode node) {
    final double weight = node.getDistanceToParent();
    if (weight == 0d) {
      LOGGER.warn("There are branches with length zero in your input trees. Setting 0 branches to " + MIN_VALUE);
      return MIN_VALUE;
    } else {
      return (weight / longestBranch);

    }
  }
}

public static void rerootToOutgroup(Tree tree, TreeNode outgroup) {
  rerootToOutgroup(tree, outgroup, (outgroup.getDistanceToParent() / 2d));
}

public DistanceMatrix(Tree tree) {
  TreeNode[] leafes = tree.getLeaves();
  matrix = new double[leafes.length][leafes.length];
  for (int i = 0; i < leafes.length; i++) {
    leafToIndex.put(leafes[i].getLabel(), i);
    for (int j = 0; j < leafes.length; j++) {
      if (i != j) {
        TreeNode lca = tree.findLeastCommonAncestor(leafes[i], leafes[j]);
        //BigDecimal weight = new BigDecimal(leafes[i].getDistanceToParent());
        double weight = leafes[i].getDistanceToParent();
        TreeNode parent = leafes[i].getParent();
        while (parent != lca) {
          //weight = weight.add(new BigDecimal(parent.getDistanceToParent()));
          weight = weight + parent.getDistanceToParent();
          parent = parent.getParent();
        }
        //weight = weight.add(new BigDecimal(leafes[j].getDistanceToParent()));
        weight = weight + leafes[j].getDistanceToParent();
        parent = leafes[j].getParent();
        while (parent != lca) {
          //weight = weight.add(new BigDecimal(parent.getDistanceToParent()));
          weight = weight + parent.getDistanceToParent();
          parent = parent.getParent();
        }
        matrix[i][j] = weight;//.doubleValue();//weight.multiply(new BigDecimal(ACCURACY)).doubleValue();
        matrix[j][i] = matrix[i][j];
      }
    }
  }
}

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;
}

if (writeWeights && node.getDistanceToParent() >= 0) {
  s.append(":" + node.getDistanceToParent());

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;
}

if (node.getParent() != null && node.isInnerNode()) {
  double branchLength = node.getDistanceToParent();
  if (branchLength > longestBranch)
    longestBranch = branchLength;

    TreeNode leaf2 = leafes[j];
    TreeNode ancestor = tree.findLeastCommonAncestor(leaf1, leaf2);
    double distanceToAncestor1 = leaf1.getDistanceToParent();
    TreeNode parent = leaf1.getParent();
    while (parent != ancestor) {
      distanceToAncestor1 += parent.getDistanceToParent();
      parent = parent.getParent();
    double distanceToAncestor2 = leaf2.getDistanceToParent();
    parent = leaf2.getParent();
    while (parent != ancestor) {
      distanceToAncestor2 += parent.getDistanceToParent();
      parent = parent.getParent();
double distanceToAncestor = pathLeaf1.getDistanceToParent();
TreeNode parent = pathLeaf2.getParent();
Edge<TreeNode> edgeToReroot;
if (distToAnc1 >= (pathlength / 2)) {
  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();

    TreeNode parent = leaf1;
    while (parent != ancestor) {
      distanceToAncestor1 += parent.getDistanceToParent();
      parent = parent.getParent();
    parent = leaf2;
    while (parent != ancestor) {
      distanceToAncestor2 += parent.getDistanceToParent();
      parent = parent.getParent();
double distanceToAncestor = pathLeaf1.getDistanceToParent();
TreeNode parent = pathLeaf2.getParent();
Edge<TreeNode> edgeToReroot;
if (distToAnc1 >= (pathlength / 2)) {
  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();

@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);
  }
}

TreeNode child = node.getChildAt(0);
TreeNode parent = node.getParent();
double weight_parent = node.getDistanceToParent();
double weight_child = child.getDistanceToParent();
tree.removeVertex(node);
if (parent != null) {

  edge.setWeight(n.getDistanceToParent());
  return true;
} else {
  edge.setWeight(n.getDistanceToParent());
      edge.setWeight(child.getDistanceToParent());

TreeNode n = node;
while (n.getParent() != null) {
  pathLength += (n.getDistanceToParent());
  n = n.getParent();
TreeNode n = node;
while (n.getParent() != null) {
  edgeWeight += (n.getDistanceToParent());
  n = n.getParent();