Java Node.getParent方法代码示例

import beast.evolution.tree.Node; //导入方法依赖的package包/类
protected boolean localDist(Node L1, Node L2) {
	// If z is 0, global borrowing is in effect.
	if (borrowZ == 0.0) {
		return true;
	}
	Node parent1, parent2;
	Double dist1 = 0.0, dist2 = 0.0;
	while (dist1 <= borrowZ && dist2 <= borrowZ) {
		parent1 = L1.getParent();
		parent2 = L1.getParent();

		// If it's the same ancestor, return true.
		if (parent1.equals(parent2)) {
			return true;
		}

		// Reduce height: leaves -> root.
		dist1 = Math.abs(L1.getHeight() - parent1.getHeight());
		dist2 = Math.abs(L2.getHeight() - parent2.getHeight());

		L1 = parent1;
		L2 = parent2;
	}
	return false;
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
private void fillNodes() {
    // must be done before any changes are made to the gene or species trees
    Node childNode = cNode;
    movedNodes = new ArrayList<>();
    graftNodes = new ArrayList<>();
    czBranchCount = 0;
    while (childNode != zNode) {
        czBranchCount++;
        final Node parentNode = childNode.getParent();
        final double childNodeHeight = childNode.getHeight();
        final double parentNodeHeight = parentNode.getHeight();
        final List<SortedMap<Node, Node>> perBranchMovedNodes = getMovedPairs(childNodeHeight, parentNodeHeight);
        final SetMultimap<Integer, Node> perBranchGraftNodes = getGraftBranches(childNode);
        movedNodes.add(0, perBranchMovedNodes); // needs to be added in reverse order
        graftNodes.add(0, perBranchGraftNodes); // because nodes must be grafted oldest to youngest
        childNode = parentNode;
    }
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
private static void pruneAndRegraft(final Node nodeToMove, final Node newChild, final Node disownedChild) {
    final Node sourceParent = nodeToMove.getParent();
    final Node destinationParent = newChild.getParent();

    // debug string
    // System.out.println(String.format("%d-%d-%d > %d-%d", parent.getNr(), nodeToMove.getNr(), disownedChild.getNr(), destinationParent.getNr(), newChild.getNr()));

    nodeToMove.removeChild(disownedChild);
    sourceParent.removeChild(nodeToMove);
    destinationParent.removeChild(newChild);

    nodeToMove.addChild(newChild);
    sourceParent.addChild(disownedChild);
    destinationParent.addChild(nodeToMove);

    nodeToMove.makeDirty(Tree.IS_FILTHY);
    sourceParent.makeDirty(Tree.IS_FILTHY);
    destinationParent.makeDirty(Tree.IS_FILTHY);
    newChild.makeDirty(Tree.IS_FILTHY);
    disownedChild.makeDirty(Tree.IS_FILTHY);
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
public double[] getCoalescentTimes(int nodeI) {
       if (needsUpdate) update();

       final Node speciesNode = spTree.getNode(nodeI);
       final Node parentNode = speciesNode.getParent();

       final double speciesEndTime = speciesNode.getHeight();
       final double speciesStartTime = (parentNode == null) ? Double.POSITIVE_INFINITY : parentNode.getHeight();
       final int branchEventCount = coalescentCounts[nodeI];

	final double[] branchCoalescentTimes = new double[branchEventCount + 2];
	branchCoalescentTimes[0] = speciesEndTime;
       branchCoalescentTimes[branchEventCount + 1] = speciesStartTime;

	System.arraycopy(coalescentTimes, nodeI * blocksize, branchCoalescentTimes, 1, branchEventCount);
	Arrays.sort(branchCoalescentTimes);

	return branchCoalescentTimes;
}
 

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

    if (parent.getHeight() < height) return 0;

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

    if (node.isLeaf()) {
        // TODO: verify that this makes sense
        return 0;
    } else {
        final int count = intersectingEdges(node.getLeft(), height, directChildren) +
                intersectingEdges(node.getRight(), height, directChildren);
        return count;
    }
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
@Override
public void log(final int sample, final PrintStream out) {
    out.print(getCurrentLogP() + "\t");
    if (calcCalibrations) {
        final TreeInterface tree = treeInput.get();
        for (int k = 0; k < orderedCalibrations.length; ++k) {
            final CalibrationPoint cal = orderedCalibrations[k];
            Node c;
            final int[] taxk = xclades[k];
            if (taxk.length > 1) {
                //  find MRCA of taxa
                c = getCommonAncestor(tree, taxk);
            } else {
                c = tree.getNode(taxk[0]);
            }

            if (cal.forParent()) {
                c = c.getParent();
            }

            final double h = c.getHeight();
            out.print(h + "\t");
        }
    }
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
/**
     * get transition probability matrix for particular rate category *
     */
    void getTransitionProbabilities(Tree tree, Node node, int rateCategory, double[] probs) {

        Node parent = node.getParent();
        double branchRate = (m_branchRateModel == null ? 1.0 : m_branchRateModel.getRateForBranch(node));
        branchRate *= m_siteModel.getRateForCategory(rateCategory, node);

        // Get the operational time of the branch
        //final double branchTime = branchRate * (parent.getHeight() - node.getHeight());

        //if (branchTime < 0.0) {
        //    throw new RuntimeException("Negative branch length: " + branchTime);
        //}

        //double branchLength = m_siteModel.getRateForCategory(rateCategory) * branchTime;

//        // TODO Hack until SiteRateModel issue is resolved
//        if (m_siteModel.getSubstitutionModel() instanceof SubstitutionEpochModel) {
//            ((SubstitutionEpochModel)m_siteModel.getSubstitutionModel()).getTransitionProbabilities(tree.getNodeHeight(node),
//                    tree.getNodeHeight(parent),branchLength, probs);
//            return;
//        }
        //m_siteModel.getSubstitutionModel().getTransitionProbabilities(branchLength, probs);
        m_siteModel.getSubstitutionModel().getTransitionProbabilities(node, parent.getHeight(), node.getHeight(), branchRate, probs);

    }
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
/**
 * collect parents of nodes in children set. During the collection all visited nodes get non-negative numbers
 * in order to extract the sampled tree later.
 * @param children set of nodes
 * @return  parents of nodes in children set
 */
public HashSet<Node> collectParents(HashSet<Node> children) {
    HashSet<Node> parents = new HashSet<Node>();
    for (Node node:children) {
        if (node.getParent() != null) {
            if (node.getParent().getNr() == -1){
                node.getParent().setNr(sampleCount);
                sampleCount++;
            }
            parents.add(node.getParent());
        } else {
            parents.add(node);
        }
    }
    return parents;
}
 

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包/类
public static Node getCommonAncestor(Node n1, Node n2) {
    // assert n1.getTree() == n2.getTree();
    while (n1 != n2) {
        if (n1.getHeight() < n2.getHeight()) {
            n1 = n1.getParent();
        } else {
            n2 = n2.getParent();
        }
    }
    return n1;
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
/**
 * convert a tree with single child node to ZeroBranchSATree.
 *
 * @param node all the nodes that are under this node and have single child will be
 *             replaced with zero branches
 * @throws Exception
 */

private void convertToFakeSATree(Node node, int[] lastLabel) throws Exception {
    if (!node.isLeaf()) {
        convertToFakeSATree(node.getLeft(), lastLabel);
        if (node.getRight() != null) {
            convertToFakeSATree(node.getRight(), lastLabel);
        }
    }
    if (node.getChildCount() == 1) {
        Node parent = newNode();
        parent.setNr(-1);
        parent.setHeight(node.getHeight());
        Node child = node.getLeft();
        parent.setLeft(child);
        child.setParent(parent);
        node.removeChild(child);
        parent.setRight(node);
        if (!node.isRoot()) {
            Node grandparent = node.getParent();

            if (grandparent.getLeft().equals(node)) {
                grandparent.setLeft(parent);
            }  else {
                grandparent.setRight(parent);
            }
            parent.setParent(grandparent);
        }
        node.setParent(parent);
        if (node.getNr() == -1) {
            node.setNr(lastLabel[0]+1);
            lastLabel[0]++;
        }
    }
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
public static void convertToFakeSATree(Node node, int[] nextNr) {
    if (!node.isLeaf()) {
        convertToFakeSATree(node.getLeft(), nextNr);
        if (node.getRight() != null) {
            convertToFakeSATree(node.getRight(), nextNr);
        }
    }
    if (node.getChildCount() == 1) {
        Node parent = new Node();
        parent.setHeight(node.getHeight());
        Node child = node.getLeft();
        parent.setLeft(child);
        child.setParent(parent);
        node.removeChild(child);
        parent.setRight(node);
        parent.setNr(nextNr[0]);
        nextNr[0]++;
        if (!node.isRoot()) {
            Node grandparent = node.getParent();

            if (grandparent.getLeft().getNr() == node.getNr()) {
                grandparent.setLeft(parent);
            }  else {
                grandparent.setRight(parent);
            }
            parent.setParent(grandparent);
        }  else {
            node.getTree().setRoot(parent);
        }
        node.setParent(parent);
    }
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
public void removeFossils(Node node, Tree tree, ArrayList<Node> removedNodes) {
    if (node.isLeaf()) {
        if (!extantTaxa.contains(node.getID())) {
            node.getParent().removeChild(node);
            node.setParent(null);
            removedNodes.add(node);
        }
    }  else {
        Node left = node.getLeft();
        Node right = node.getRight();
        removeFossils(left, tree, removedNodes);
        removeFossils(right, tree, removedNodes);


        if (node.isLeaf()) {
            node.getParent().removeChild(node);
            node.setParent(null);
            removedNodes.add(node);
        }
        if (node.getChildCount() == 1) {
            Node child = node.getChild(0);
            if (node.getParent() != null) {
                Node grandParent = node.getParent();
                grandParent.removeChild(node);
                grandParent.addChild(child);
                child.setParent(grandParent);
                node.setParent(null);
            }
            else {
                child.setParent(null);
                tree.setRootOnly(child);
            }
            removedNodes.add(node);
        }

    }
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
private boolean recurseCoalescenceEvents(int lastGeneTreeNodeNumber, double lastHeight, Node geneTreeNode, int geneTreeNodeNumber, Node speciesTreeNode, int speciesTreeNodeNumber) {
    while (true) {
        final double geneTreeNodeHeight = geneTreeNode.getHeight();

        // check if the next coalescence event occurs in an ancestral branch
        while (!speciesTreeNode.isRoot() && geneTreeNodeHeight >= speciesTreeNode.getParent().getHeight()) {
            /* if (geneTreeNode.isDirty() != Tree.IS_CLEAN )
                speciesBranchIsDirty[speciesTreeNodeNumber] = true;
            */
            final Node speciesTreeParentNode = speciesTreeNode.getParent();
            final double speciesTreeParentHeight = speciesTreeParentNode.getHeight();
            final int speciesTreeParentNodeNumber = speciesTreeParentNode.getNr();

            speciesOccupancy[lastGeneTreeNodeNumber * speciesNodeCount + speciesTreeNodeNumber] = speciesTreeParentHeight - lastHeight;
            coalescentLineageCounts[speciesTreeParentNodeNumber]++;

            speciesTreeNode = speciesTreeParentNode;
            speciesTreeNodeNumber = speciesTreeParentNodeNumber;
            lastHeight = speciesTreeParentHeight;
        }

        // this code executes if the next coalescence event occurs within the current branch
        speciesOccupancy[lastGeneTreeNodeNumber * speciesNodeCount + speciesTreeNodeNumber] = geneTreeNodeHeight - lastHeight;
        final int existingSpeciesAssignment = geneNodeSpeciesAssignment[geneTreeNodeNumber];
        if (existingSpeciesAssignment == -1) {
            geneNodeSpeciesAssignment[geneTreeNodeNumber] = speciesTreeNodeNumber;

            coalescentTimes[speciesTreeNodeNumber * blocksize + coalescentCounts[speciesTreeNodeNumber]++] = geneTreeNodeHeight;

            final Node nextGeneTreeNode = geneTreeNode.getParent();
            if (nextGeneTreeNode == null) {
                // this is the root of the gene tree and no incompatibilities were detected
                return true;
            } else {
                // if this is not the root of the gene tree, check the subsequent (back in time) coalescence event
                lastGeneTreeNodeNumber = geneTreeNodeNumber;
                lastHeight = geneTreeNodeHeight;
                geneTreeNode = nextGeneTreeNode;
                geneTreeNodeNumber = nextGeneTreeNode.getNr();
                //return recurseCoalescenceEvents(geneTreeNodeNumber, geneTreeNodeHeight, nextGeneTreeNode, nextGeneTreeNodeNumber, speciesTreeNode, speciesTreeNodeNumber);
            }
        } else if (existingSpeciesAssignment == speciesTreeNodeNumber) {
            return true; // gene tree OK up to here, but stop evaluating because deeper nodes have already been traversed
        } else {
            return false; // this gene tree IS NOT compatible with the species tree
        }
    }
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
@Test
public void testLogHR() throws Exception {
    TaxonSet speciesSuperSet = generateSuperset();
    initializeSpeciesTree(speciesSuperSet);
    initializeGeneTrees();

    popsizeParameter = new RealParameter();
    popsizeParameter.initByName("value", String.valueOf(popSize));

    // Create dummy state to allow statenode editing
    State state = new State();
    state.initByName("stateNode", popsizeParameter);
    for (Tree gt: geneTrees) {
        state.initByName("stateNode", gt);
    }
    state.initialise();

    populationModel = new ConstantPopulations();
    populationModel.initByName("populationSizes", popsizeParameter, "speciesTree", speciesTreeWrapper);

    int nBranches = speciesTreeWrapper.getNodeCount();
    populationModel.initPopSizes(nBranches);
    populationModel.initPopSizes(popSize);

    Node cNode = null;
    Node bNode = null;
    for (Node n: speciesTreeWrapper.getRoot().getAllLeafNodes()) {
        if (n.getID().equals(bTipLabel)) {
            if (bIsParent) bNode = n.getParent();
            else bNode = n;
        } else if (n.getID().equals(cTipLabel)) {
            if (cIsParent) cNode = n.getParent();
            else cNode = n;
        }
    }

    Node yNode = bNode.getParent();
    Node zNode = yNode.getParent();
    Node aNode = (bNode == yNode.getRight()) ? yNode.getLeft() : yNode.getRight();

    if (cNode == null) {
        cNode = (yNode == zNode.getRight()) ? zNode.getLeft() : zNode.getRight();
    }

    CoordinatedExchange coex = new CoordinatedExchange();
    coex.initByName("speciesTree", speciesTreeWrapper, "geneTree", geneTrees, "testing", true, "weight", 1.0);
    coex.aNode = aNode;
    coex.bNode = bNode;
    coex.cNode = cNode;
    coex.yNode = yNode;
    coex.zNode = zNode;
    final double calculatedLogHR = coex.proposal();

    assertEquals(expectedLogHR, calculatedLogHR, allowedError);
}