Java Tree.getChildCount方法代码示例

import beast.evolution.tree.Tree; //导入方法依赖的package包/类
/**
 * extract coalescent times and tip information into ArrayList times from tree.
 *
 * @param tree      the tree
 * @param node      the node to start from
 * @param intervals the intervals object to store the events
 */
private void collectTimes(Tree tree, NodeRef node, Set<NodeRef> excludeNodesBelow, Intervals intervals) {

    intervals.addCoalescentEvent(tree.getNodeHeight(node));

    for (int i = 0; i < tree.getChildCount(node); i++) {
        NodeRef child = tree.getChild(node, i);

        // check if this subtree is included in the coalescent density
        boolean include = true;

        if (excludeNodesBelow != null && excludeNodesBelow.contains(child)) {
            include = false;
        }

        if (!include || tree.isExternal(child)) {
            intervals.addSampleEvent(tree.getNodeHeight(child));
        } else {
            collectTimes(tree, child, excludeNodesBelow, intervals);
        }
    }

}
 

import beast.evolution.tree.Tree; //导入方法依赖的package包/类
/**
 * Extract coalescent times and tip information into ArrayList times from tree.
 * Upon return times contain the time of each node in the subtree below top, and at the corrosponding index
 * of childs is the descendent count for that time.
 *
 * @param top          the node to start from
 * @param excludeBelow an optional array of nodes to exclude (corresponding subtrees) from density.
 * @param tree         given tree
 * @param times        array to fill with times
 * @param childs       array to fill with descendents count
 */
private static void collectAllTimes(Tree tree, NodeRef top, NodeRef[] excludeBelow,
                                    ArrayList<Double> times, ArrayList<Integer> childs) {

    times.add(tree.getNodeHeight(top));
    childs.add(tree.getChildCount(top));

    for (int i = 0; i < tree.getChildCount(top); i++) {
        NodeRef child = tree.getChild(top, i);
        if (excludeBelow == null) {
            collectAllTimes(tree, child, excludeBelow, times, childs);
        } else {
            // check if this subtree is included in the coalescent density
            boolean include = true;
            for (NodeRef anExcludeBelow : excludeBelow) {
                if (anExcludeBelow.getNumber() == child.getNumber()) {
                    include = false;
                    break;
                }
            }
            if (include)
                collectAllTimes(tree, child, excludeBelow, times, childs);
        }
    }
}
 

import beast.evolution.tree.Tree; //导入方法依赖的package包/类
private int intersectingEdges(Tree tree, NodeRef node, double height, List<NodeRef> directChildren) {

        final NodeRef parent = tree.getParent(node);

        if (tree.getNodeHeight(parent) < height) return 0;

        if (tree.getNodeHeight(node) < height) {
            if (directChildren != null) directChildren.add(node);
            return 1;
        }

        int count = 0;
        for (int i = 0; i < tree.getChildCount(node); i++) {
            count += intersectingEdges(tree, tree.getChild(node, i), height, directChildren);
        }
        return count;
    }
 

import beast.evolution.tree.Tree; //导入方法依赖的package包/类
/**
 * extract coalescent times and tip information into array times from tree.
 */
private static void collectTimes(Tree tree, double[] times, int[] childCounts) {

    for (int i = 0; i < tree.getNodeCount(); i++) {
        NodeRef node = tree.getNode(i);
        times[i] = tree.getNodeHeight(node);
        childCounts[i] = tree.getChildCount(node);
    }
}
 

import beast.evolution.tree.Tree; //导入方法依赖的package包/类
/**
 * Recursive algorithm to copy a proposed tree structure into the current treeModel.
 */
private void addNodeStructure(Tree donorTree, NodeRef donorNode) {

    NodeRef acceptorNode = null;
    if (donorTree.isExternal(donorNode)) {
        //external nodes can have different numbers between both trees
        acceptorNode = this.nodes[this.getTaxonIndex(donorTree.getTaxonId(donorNode.getNumber()))];
    } else {
        //not really important for internal nodes
        acceptorNode = this.nodes[donorNode.getNumber()];
    }

    setNodeHeight(acceptorNode, donorTree.getNodeHeight(donorNode));

    //removing all child nodes up front currently works
    //((Node)acceptorNode).leftChild = null;
    //((Node)acceptorNode).rightChild = null;
    /*int nrChildren = getChildCount(acceptorNode);
      for (int i = 0; i < nrChildren; i++) {
          this.removeChild(acceptorNode, this.getChild(acceptorNode, i));
      }*/

    for (int i = 0; i < donorTree.getChildCount(donorNode); i++) {
        //add a check when the added child is an external node
        if (donorTree.isExternal(donorTree.getChild(donorNode, i))) {
            addChild(acceptorNode, this.nodes[this.getTaxonIndex(donorTree.getTaxonId(donorTree.getChild(donorNode, i).getNumber()))]);
        } else {
            addChild(acceptorNode, this.nodes[donorTree.getChild(donorNode, i).getNumber()]);
        }
    }

    pushTreeChangedEvent(acceptorNode);

    if (!donorTree.isExternal(donorNode)) {
        for (int i = 0; i < donorTree.getChildCount(donorNode); i++) {
            addNodeStructure(donorTree, donorTree.getChild(donorNode, i));
        }
    }

}
 

import beast.evolution.tree.Tree; //导入方法依赖的package包/类
/**
 * constructor used to clone a node and all children
 */
public Node(Tree tree, NodeRef node) {
    parent = null;
    leftChild = rightChild = null;

    heightParameter = new Parameter.Default(tree.getNodeHeight(node));
    addVariable(heightParameter);

    number = node.getNumber();
    taxon = tree.getNodeTaxon(node);
    heightParameter.setId("" + number);
    for (int i = 0; i < tree.getChildCount(node); i++) {
        addChild(new Node(tree, tree.getChild(node, i)));
    }
}
 

import beast.evolution.tree.Tree; //导入方法依赖的package包/类
/**
 * Alternative likelihood calculation that uses recursion over the tree and allows
 * a list of taxa to exclude
 *
 * @param tree    the tree
 * @param node
 * @param exclude a list of taxa to exclude
 * @param lnL     a reference to the lnL sum
 * @return the number of included daughter nodes
 */
private int calculateNodeLogLikelihood(Tree tree, NodeRef node, Set<Taxon> exclude, double[] lnL) {
    if (tree.isExternal(node)) {
        if (!exclude.contains(tree.getNodeTaxon(node))) {
            if (includeExternalNodesInLikelihoodCalculation()) {
                lnL[0] += logNodeProbability(tree, node);
            }

            // this tip is included in the subtree...
            return 1;
        }

        // this tip is excluded from the subtree...
        return 0;
    } else {
        int count = 0;
        for (int i = 0; i < tree.getChildCount(node); i++) {
            NodeRef child = tree.getChild(node, i);
            count += calculateNodeLogLikelihood(tree, child, exclude, lnL);
        }

        if (count == 2) {
            // this node is included in the subtree...
            lnL[0] += logNodeProbability(tree, node);
        }

        // if at least one of the children has included tips then return 1 otherwise 0
        return count > 0 ? 1 : 0;
    }
}