How to use

getEdgeToParent

method

in

phylo.tree.model.TreeNode

/**
 * 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();
}

/**
 * Compute a list of ALL edges of a given {@link TreeNode}.
 * ALL means all adjacent edges to the node. That are all edges to children and the edge to
 * the parent (if there is one).
 * <p>
 * Runtime: O(d)
 */
public ArrayList<Edge<TreeNode>> getAllEdges() {
  ArrayList<Edge<TreeNode>> edges = new ArrayList<Edge<TreeNode>>();
  for (Edge<TreeNode> edge : this.edges()) {
    edges.add(edge);
  }
  if (!(this.getEdgeToParent() == null)) {
    edges.add(this.getEdgeToParent());
  }
  return edges;
}

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

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

TreeUtils.reorderingBootstrapLabelsForRooting(bestRoot.getEdgeToParent());
TreeUtils.rerootToOutgroup(tree, bestRoot);

      TreeUtils.reorderingBootstrapLabelsForRooting(node.getEdgeToParent());
      TreeUtils.rerootToOutgroup(tree, node);
TreeUtils.reorderingBootstrapLabelsForRooting(node.getEdgeToParent());
TreeUtils.rerootToOutgroup(tree, node);

TreeUtils.reorderingBootstrapLabelsForRooting(node.getEdgeToParent());
TreeUtils.rerootToOutgroup(tree, node);

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;

/**
 * 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);
  }
}

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

if (n.getEdgeToParent() != null) n.getEdgeToParent().setWeight(1.0);

  nodes.add(rootedModel.getVertex(s));
Edge<TreeNode> edgeToReroot = rootedModel.findLeastCommonAncestor(nodes).getEdgeToParent();
TreeUtils.reorderingBootstrapLabelsForRooting(edgeToReroot);
TreeUtils.rerootToOutgroup(rootedModel, edgeToReroot.getTarget());

private static void moveUP(Edge<TreeNode> edgeForLabelMove, String label) {
  String newLabel = edgeForLabelMove.getSource().getLabel();
  edgeForLabelMove.getSource().setLabel(label);
  if (newLabel != null)
    moveUP(edgeForLabelMove.getSource().getEdgeToParent(), newLabel);
}

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);
  if (rchild.getEdgeToParent() != null) {
    tree.removeEdge(rchild.getParent(), rchild);

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();

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();

edgeWeight = node.getEdgeToParent().getWeight();
TreeNode root = tree.getRoot();