Java Node.getNr方法代码示例

import beast.evolution.tree.Node; //导入方法依赖的package包/类
@Override
public void serialize(Node speciesTreeNode, StringBuffer buf, DecimalFormat df) {
    final RealParameter tipPopSizes = tipPopSizesInput.get();
    final RealParameter topPopSizes = topPopSizesInput.get();
    final int speciesTreeNodeNumber = speciesTreeNode.getNr();

    double branchTipPopSize;
    if (speciesTreeNode.isLeaf()) {
        branchTipPopSize = tipPopSizes.getValue(speciesTreeNodeNumber);
    } else {
        final int leftChildTopI = speciesTreeNode.getLeft().getNr();
        final int rightChildTopI = speciesTreeNode.getRight().getNr();
        branchTipPopSize = topPopSizes.getValue(leftChildTopI) + topPopSizes.getValue(rightChildTopI);
    }

    final double branchTopPopSize = (speciesTreeNode.isRoot()) ? branchTipPopSize : topPopSizes.getValue(speciesTreeNode.getNr());

    if (df == null) buf.append("dmv={" + branchTopPopSize + "," + branchTipPopSize + "}");
    else buf.append("dmv={" + df.format(branchTopPopSize) + "," + df.format(branchTipPopSize) + "}");
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
private SetMultimap<Integer, Node> getConnectingNodes(Node speciesTreeNode, MinimumDouble tipwardFreedom) {
    final Node leftChildNode = speciesTreeNode.getLeft();
    final Node rightChildNode = speciesTreeNode.getRight();
    final int leftChildNodeNumber = leftChildNode.getNr();
    final int rightChildNodeNumber = rightChildNode.getNr();
    final Set<String> leftChildDescendants = findDescendants(leftChildNode, leftChildNodeNumber);
    final Set<String> rightChildDescendants = findDescendants(rightChildNode, rightChildNodeNumber);

    final SetMultimap<Integer, Node> allConnectingNodes = HashMultimap.create();
    final List<Tree> geneTrees = geneTreeInput.get();
    for (int j = 0; j < nGeneTrees; j++) {
        final Tree geneTree = geneTrees.get(j);
        final Node geneTreeRootNode = geneTree.getRoot();
        final Set<Node> jConnectingNodes = new HashSet<Node>();
        findConnectingNodes(geneTreeRootNode, jConnectingNodes, leftChildDescendants, rightChildDescendants, tipwardFreedom);
        allConnectingNodes.putAll(j, jConnectingNodes);
        geneTree.startEditing(null); // hack to stop beast.core.State.Trie memory leak
    }

    return allConnectingNodes;
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
protected Set<String> findDescendants(Node speciesTreeNode, int speciesTreeNodeNumber) {
    final Multimap<Integer, String> numberTipMap = speciesTreeInput.get().getNumberTipMap();
    final Set<String> descendantNames = new HashSet<>();

    if (speciesTreeNode.isLeaf()) {
        descendantNames.addAll(numberTipMap.get(speciesTreeNodeNumber));
    } else {
        final Node leftChild = speciesTreeNode.getLeft();
        final Node rightChild = speciesTreeNode.getRight();
        final int leftChildNumber = leftChild.getNr();
        final int rightChildNumber = rightChild.getNr();

        descendantNames.addAll(findDescendants(leftChild, leftChildNumber));
        descendantNames.addAll(findDescendants(rightChild, rightChildNumber));
    }

    return descendantNames;
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
protected SetMultimap<Integer, Node> getGraftBranches(Node yNode) {
    final int yNumber = yNode.getNr();
    final Set<String> cousinDescendants = findDescendants(yNode, yNumber);

    final SetMultimap<Integer, Node> allGraftBranches = HashMultimap.create();
    final List<Tree> geneTrees = geneTreeInput.get();
    for (int j = 0; j < nGeneTrees; j++) {
        final Tree geneTree = geneTrees.get(j);
        final Node geneTreeRootNode = geneTree.getRoot();
        final Set<Node> jGraftBranches = new LinkedHashSet<>();
        findGraftBranches(geneTreeRootNode, jGraftBranches, cousinDescendants);
        allGraftBranches.putAll(j, jGraftBranches);
    }

    return allGraftBranches;
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
@Override
public int compare(Node nodeA, Node nodeB) {
    final double heightA = nodeA.getHeight();
    final double heightB = nodeB.getHeight();
    if (heightA == heightB) {
        final int depthA = calculateNodeDepth(nodeA);
        final int depthB = calculateNodeDepth(nodeB);
        if (depthA == depthB) {
            final int nodeNumberA = nodeA.getNr();
            final int nodeNumberB = nodeB.getNr();
            if (nodeNumberA == nodeNumberB) {
                return 0;
            }
            return nodeNumberA > nodeNumberB ? greaterThan : lessThan;
        }
        return depthA > depthB ? greaterThan : lessThan;
    }
    return heightA > heightB ? greaterThan : lessThan;
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
/**
 * This is a recursive function that does the work of
 * calculating the unscaled branch rates across the tree
 * taking into account the indicator variables.
 *
 * @param node the node
 * @param rate the rate of the parent node
 */
private void recurseBranchRates(Node node, double parentHeight, double rate, Boolean[] indicators, Double[] branchRates) {
    final int nodeNumber = node.getNr();
    final double nodeHeight = node.getHeight();

    // not the root, and indicator is "on"
    if (nodeNumber < rootNodeNumber && indicators[nodeNumber]) {
        rate = branchRates[nodeNumber];
    }

    double branchLength = parentHeight - nodeHeight;
    strictRatesTotal += branchLength;
    relaxedRatesTotal += branchLength * rate;

    ratesArray[nodeNumber] = rate;

    if (!node.isLeaf()) {
        recurseBranchRates(node.getLeft(), nodeHeight, rate, indicators, branchRates);
        recurseBranchRates(node.getRight(), nodeHeight, rate, indicators, branchRates);
    }
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
private SetMultimap<Integer, Node> getConnectingNodes(Node speciesTreeNode, MinimumDouble tipwardFreedom, MinimumDouble rootwardFreedom) {
    final Node leftChildNode = speciesTreeNode.getLeft();
    final Node rightChildNode = speciesTreeNode.getRight();
    final int leftChildNodeNumber = leftChildNode.getNr();
    final int rightChildNodeNumber = rightChildNode.getNr();
    final Set<String> leftChildDescendants = findDescendants(leftChildNode, leftChildNodeNumber);
    final Set<String> rightChildDescendants = findDescendants(rightChildNode, rightChildNodeNumber);

    final SetMultimap<Integer, Node> allConnectingNodes = HashMultimap.create();
    final List<Tree> geneTrees = geneTreeInput.get();
    for (int j = 0; j < nGeneTrees; j++) {
        final Tree geneTree = geneTrees.get(j);
        final Node geneTreeRootNode = geneTree.getRoot();
        final Set<Node> jConnectingNodes = new HashSet<Node>();
        findConnectingNodes(geneTreeRootNode, jConnectingNodes, leftChildDescendants, rightChildDescendants, tipwardFreedom, rootwardFreedom);
        allConnectingNodes.putAll(j, jConnectingNodes);
        geneTree.startEditing(null); // hack to stop beast.core.State.Trie memory leak
    }

    return allConnectingNodes;
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
/**
 * Extract the sampled tree by discarding all the nodes that have -1 number simultaneously suppress single
 * child nodes (nodes with only one child numbered by non-negative number)
 * @param node
 */
public void removeSingleChildNodes(Node node) {
    if (!node.isLeaf()) {
        Node left = node.getLeft();
        Node right = node.getRight();

        removeSingleChildNodes(left);
        removeSingleChildNodes(right);
        for (Node child:node.getChildren()) {
            if (child.getNr() == -1) {
                node.removeChild(child);
            }
        }
        if (node.getChildCount() == 1 && node.getParent() != null) {
            Node parent = node.getParent();
            Node newChild =  node.getLeft();
            parent.removeChild(node);
            parent.addChild(newChild);
            newChild.setParent(parent);
            //node.setParent(null);
        }
    }
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
/**
 * @param node the node to get the rate of
 * @return the rate of the branch
 */
private double getRawRateForCategory(Node node) {

    int nodeNumber = node.getNr();
    if (nodeNumber == branchCount) {
        // root node has nr less than #categories, so use that nr
        nodeNumber = node.getTree().getRoot().getNr();
    }

    int category = categories.getValue(nodeNumber);

    if (rates[category] == 0.0) {
        try {
            rates[category] = distribution.inverseCumulativeProbability((category + 0.5) / rates.length);
        } catch (MathException e) {
            throw new RuntimeException("Failed to compute inverse cumulative probability!");
        }
    }
    return rates[category];
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
int getTreeCladeCodes(Node node, BitSet[] codes) {
    final int inode = node.getNr();
    codes[inode].clear();
    if (node.isLeaf()) {
        int index = getTaxonIndex(node);//getTaxonIndex(node);
        codes[inode].set(index);
    } else {
        for (int i = 0; i < node.getChildCount(); i++) {
            final Node child = node.getChild(i);
            final int childIndex = getTreeCladeCodes(child, codes);

            codes[inode].or(codes[childIndex]);
        }
    }
    return inode;
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
/**
 * Given a map of name translations (string to string),
 * rewrites all leaf ids that match a key in the map
 * to the respective value in the matching key/value pair.
 * If current leaf id is null, then interpret translation keys as node numbers (origin 1)
 * and set leaf id of node n to map.get(n-1).
 *
 * @param translationMap
 */
public void translateLeafIds(Map<String, String> translationMap) {

    for (Node leaf : getExternalNodes()) {
        String id = leaf.getID();

        if (id == null) {
            id = (leaf.getNr() + 1) + "";
        }

        String newId = translationMap.get(id);
        if (newId != null) {
            leaf.setID(newId);
        }
    }
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
protected void processSampleEvent(int interval) {
  	int sampleState;
List<Node> incomingLines = intervals.getLineagesAdded(interval);
for (Node l : incomingLines) {			
	/* uses pre-computed nodeNrToState */
	sampleState = nodeNrToState[l.getNr()];	/* suceeds if node is a leaf, otherwise state=-1 */	
	DoubleMatrix sVec = DoubleMatrix.zeros(1,numStates); // row-vector
	sVec.put(sampleState, 1.0);
	stateProbabilities.addLineage(l.getNr(),sVec);
}	
  }
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
@Override
public boolean isDirtyBranch(Node speciesNode) {
    if (needsUpdate) {
        final RealParameter tipPopSizes = tipPopSizesInput.get();
        final RealParameter topPopSizes = topPopSizesInput.get();

        Arrays.fill(speciesBranchStatus, false);
        Node[] speciesNodes = speciesTree.getNodesAsArray();

        // non-root nodes (linear population sizes)
        for (int nodeI = 0; nodeI < speciesNodes.length; nodeI++) {
            // if the "top" population is dirty, no need to check the tip
            if (nodeI < rootNodeNumber && topPopSizes.isDirty(nodeI)) { // not the root node
                speciesBranchStatus[nodeI] = true;
                continue;
            }

            if (nodeI < leafNodeCount) { // is a leaf node
                speciesBranchStatus[nodeI] = tipPopSizes.isDirty(nodeI);
            } else { // is an internal node
                final Node leftChild = speciesNodes[nodeI].getLeft();
                final Node rightChild = speciesNodes[nodeI].getRight();
                final int leftChildTopI = leftChild.getNr();
                final int rightChildTopI = rightChild.getNr();
                speciesBranchStatus[nodeI] = topPopSizes.isDirty(leftChildTopI) ||
                        topPopSizes.isDirty(rightChildTopI) ||
                        leftChild.isDirty() != Tree.IS_CLEAN ||
                        rightChild.isDirty() != Tree.IS_CLEAN;
            }
        }

        //Arrays.fill(speciesBranchStatus, true);
        needsUpdate = false;
    }

    return speciesBranchStatus[speciesNode.getNr()];
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
@Override
public double getRateForBranch(Node node) {
    if (needsUpdate) {
        update();
    }

    return branchRates[node.getNr()];
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
private boolean checkConsistency(final Node node, final boolean[] used) {
    if (used[node.getNr()]) {
        // used twice? tha's bad
        return false;
    }
    used[node.getNr()] = true;
    if ( node.isLeaf() ) {
        return true;
    }
    return checkConsistency(node.getLeft(), used) && checkConsistency(node.getRight(), used);
}