Java MutableTree.getChildCount方法代码示例

import dr.evolution.tree.MutableTree; //导入方法依赖的package包/类
private static void adjustInternalHeights(MutableTree tree, NodeRef node) {

        if (!tree.isExternal(node)) {
            // pre-order recursion
            for (int i = 0; i < tree.getChildCount(node); i++) {
                adjustInternalHeights(tree, tree.getChild(node, i));
            }
        }

        NodeRef parent = tree.getParent(node);

        if (parent != null) {

            if (tree.getNodeHeight(parent) < tree.getNodeHeight(node)) {
                tree.setNodeHeight(parent, tree.getNodeHeight(node));
            }
        }
    }
 

import dr.evolution.tree.MutableTree; //导入方法依赖的package包/类
private BitSet addNewClades(final MutableTree tree, final NodeRef node) {

		final BitSet bitSet = new BitSet(tree.getTaxonCount());
		if (tree.isExternal(node)) {
			bitSet.set(hostTaxonList.getTaxonIndex(tree.getNodeTaxon(node).getId()));
		} else {
			for (int i = 0; i < tree.getChildCount(node); ++i) {
				bitSet.or(addNewClades(tree, tree.getChild(node, i)));
			}
		}
		
		if (!clades.containsKey(bitSet))
			clades.put(bitSet, clades.size());

		final int id = clades.get(bitSet);
		ids[(Integer) tree.getNodeAttribute(node, NODE_REF)] = id;
		tree.setNodeAttribute(node, NODE_REF, id);

		return bitSet;
	}
 

import dr.evolution.tree.MutableTree; //导入方法依赖的package包/类
private void simulate(MutableTree tree, NodeRef node, double value) {
		
	tree.setNodeAttribute(node, traitName, new Double(value));
	int childCount = tree.getChildCount(node);
	double height = tree.getNodeHeight(node);
	for (int i = 0; i < childCount; i++) {
		NodeRef child = tree.getChild(node, i);
		
		simulate(tree, child, diffusionModel.simulateForward(value, height - tree.getNodeHeight(child)));
	}	
}
 

import dr.evolution.tree.MutableTree; //导入方法依赖的package包/类
public void annotateTree(MutableTree tree, NodeRef node, BitSet bits, HeightsSummary heightsOption) {

            BitSet bits2 = new BitSet();

            if (tree.isExternal(node)) {

                int index = taxonList.getTaxonIndex(tree.getNodeTaxon(node).getId());
                bits2.set(index);

                annotateNode(tree, node, bits2, true, heightsOption);
            } else {

                for (int i = 0; i < tree.getChildCount(node); i++) {

                    NodeRef node1 = tree.getChild(node, i);

                    annotateTree(tree, node1, bits2, heightsOption);
                }

                annotateNode(tree, node, bits2, false, heightsOption);
            }

            if (bits != null) {
                bits.or(bits2);
            }
        }
 

import dr.evolution.tree.MutableTree; //导入方法依赖的package包/类
private static void annotateRates(
        MutableTree targetTree, NodeRef node, Tree timeTree, Tree mutationTree) {

    Set<String> leafSet = Tree.Utils.getDescendantLeaves(targetTree, node);
    if (Tree.Utils.isMonophyletic(timeTree, leafSet)) {
        NodeRef timeNode = Tree.Utils.getCommonAncestorNode(timeTree, leafSet);
        NodeRef mutationNode = Tree.Utils.getCommonAncestorNode(mutationTree, leafSet);

        double height = timeTree.getNodeHeight(timeNode);

        if (!targetTree.isRoot(node)) {
            double time = timeTree.getNodeHeight(timeTree.getParent(timeNode)) - height;
            double mutations = mutationTree.getNodeHeight(mutationTree.getParent(mutationNode)) - mutationTree.getNodeHeight(mutationNode);

            //double rate = mutations/time;
            Number totalMutations = (Number)targetTree.getNodeAttribute(node, "totalMutations");
            Number totalTime = (Number)targetTree.getNodeAttribute(node, "totalTime");
            if (totalMutations == null) {
                targetTree.setNodeAttribute(node, "totalMutations", mutations);
                targetTree.setNodeAttribute(node, "totalTime", time);
                targetTree.setNodeAttribute(node, "count", 1);
            } else {
                Integer count = (Integer)targetTree.getNodeAttribute(node, "count");
                targetTree.setNodeAttribute(node, "totalMutations", totalMutations.doubleValue() + mutations);
                targetTree.setNodeAttribute(node, "totalTime", totalTime.doubleValue() + time);
                targetTree.setNodeAttribute(node, "count", count + 1);
            }
        }
        if (!targetTree.isExternal(node)) {
            java.util.List<Double> list = (java.util.List<Double>)targetTree.getNodeAttribute(node, "heightList");
            if (list == null) {
                list = new ArrayList<Double>() ;
                targetTree.setNodeAttribute(node, "heightList", list);
            }
            list.add(height);
        }
    }


    for (int i = 0; i < targetTree.getChildCount(node); i++) {
        annotateRates(targetTree, targetTree.getChild(node, i), timeTree, mutationTree);
    }
}