@Override public List<Integer> getLeaves() { int externalNodeCount = tree.getExternalNodeCount(); List<Integer> leaves = new ArrayList<Integer>(externalNodeCount); for (int i = 0; i < externalNodeCount; ++i) leaves.add(tree.getExternalNode(i).getNumber()); return leaves; }
/** * @param tree * @param node * @return and array of the total amount of time spent in each of the discrete states along the * branch above the given node. */ private double[] getProcessValues(final Tree tree, final NodeRef node) { double[] processValues = null; double branchTime = tree.getBranchLength(node); if (mode == Mode.MARKOV_JUMP_PROCESS) { processValues = (double[]) trait.getTrait(tree, node); } else if (mode == Mode.PARSIMONY) { // an approximation to dwell times using parsimony, assuming // the state changes midpoint on the tree. Does a weighted // average of the equally parsimonious state reconstructions // at the top and bottom of each branch. if (treeChanged) { fitchParsimony.initialize(tree); // Debugging test to count work // treeInitializeCounter += 1; // if (treeInitializeCounter % 10 == 0) { // System.err.println("Cnt: "+treeInitializeCounter); // } treeChanged = false; } int[] states = fitchParsimony.getStates(tree, node); int[] parentStates = fitchParsimony.getStates(tree, tree.getParent(node)); processValues = new double[fitchParsimony.getPatterns().getStateCount()]; for (int state : states) { processValues[state] += branchTime / 2; } for (int state : parentStates) { processValues[state] += branchTime / 2; } for (int i = 0; i < processValues.length; i++) { // normalize by the number of equally parsimonious states at each end of the branch // processValues should add up to the total branch length processValues[i] /= (states.length + parentStates.length) / 2; } } else if (mode == Mode.NODE_STATES) { processValues = new double[dataType.getStateCount()]; // if (indicatorParameter != null) { // // this array should be size #states NOT #rates // processValues = new double[indicatorParameter.getDimension()]; // } else { // // this array should be size #states NOT #rates // processValues = new double[rateParameter.getDimension()]; // } // if the states are being sampled - then there is only one possible state at each // end of the branch. int state = ((int[]) trait.getTrait(tree, node))[traitIndex]; processValues[state] += branchTime / 2; int parentState = ((int[]) trait.getTrait(tree, tree.getParent(node)))[traitIndex]; processValues[parentState] += branchTime / 2; } return processValues; }
@Override public List<Integer> getChildren(int i) { NodeRef n = tree.getNode(i); int childCount = tree.getChildCount(n); List<Integer> children = new ArrayList<Integer>(childCount); for (int j = 0; j < childCount; ++j) children.add(tree.getChild(n, j).getNumber()); return children; }
@Override public List<Integer> getAncestors(int i, boolean b) { List<Integer> ancestors = new ArrayList<Integer>(); if (b) ancestors.add(i); for (NodeRef n = tree.getParent(tree.getNode(i)); n != null; n = tree.getParent(n)) ancestors.add(n.getNumber()); return ancestors; }
@Override public int getSibling(int i) { NodeRef n = tree.getNode(i); if (tree.isRoot(n)) return RootedTree.NULL; NodeRef p = tree.getParent(n); int c1 = tree.getChild(p, 0).getNumber(); int c2 = tree.getChild(p, 1).getNumber(); return n.getNumber() == c2 ? c1 : c2; }
public double[] getSummaryStatistic(Tree tree) { if (taxonList == null) { return new double[] {1.0}; } double TL = Tree.Utils.getTreeLength(tree, tree.getRoot()); double betaDiversity = (TL - getUniqueBranches(tree, tree.getRoot())) / TL; return new double[] {betaDiversity}; }
public void getTransitionProbabilities( Tree tree, NodeRef node, int rateCategory, double[] matrix) { NodeRef parent = tree.getParent(node); final double branchRate = branchModel.getBranchRate(tree, node); // Get the operational time of the branch final double startTime = tree.getNodeHeight(parent); final double endTime = tree.getNodeHeight(node); final double branchTime = branchRate * (startTime - endTime); if (branchTime < 0.0) { throw new RuntimeException("Negative branch length: " + branchTime); } double distance = siteModel.getRateForCategory(rateCategory) * branchTime; int matrixCount = 0; boolean oneMatrix = (getEpochWeights(startTime, endTime, weight) == 1); for (int m = 0; m < numberModels; m++) { if (weight[m] > 0) { SubstitutionModel model = modelList.get(m); if (matrixCount == 0) { if (oneMatrix) { model.getTransitionProbabilities(distance, matrix); break; } else model.getTransitionProbabilities(distance * weight[m], resultMatrix); matrixCount++; } else { model.getTransitionProbabilities(distance * weight[m], stepMatrix); // Sum over unobserved state int index = 0; for (int i = 0; i < stateCount; i++) { for (int j = 0; j < stateCount; j++) { productMatrix[index] = 0; for (int k = 0; k < stateCount; k++) { productMatrix[index] += resultMatrix[i * stateCount + k] * stepMatrix[k * stateCount + j]; } index++; } } // Swap pointers double[] tmpMatrix = resultMatrix; resultMatrix = productMatrix; productMatrix = tmpMatrix; } } } if (!oneMatrix) System.arraycopy(resultMatrix, 0, matrix, 0, stateCount * stateCount); }
@Override public List<Integer> getDescendants(int i, boolean b) { List<Integer> descendants = new ArrayList<Integer>(); getDescendants(tree.getNode(i), descendants); if (b) descendants.remove(0); return descendants; }
private void setStatusMessage() { Tree tree = treesPanel.getTree(); if (tree != null) { String message = ""; message += "Tree loaded, " + tree.getTaxonCount() + " taxa"; TemporalRooting tr = treesPanel.getTemporalRooting(); if (tr.isContemporaneous()) { message += ", contemporaneous tips"; } else { NumberFormatter nf = new NumberFormatter(3); message += ", dated tips with range " + nf.format(tr.getDateRange()); } statusLabel.setText(message); } }
@Override public List<Integer> getDescendantLeaves(int i, boolean b) { List<Integer> descendants = new ArrayList<Integer>(); if (!b) descendants.add(i); for (NodeRef n : Tree.Utils.getExternalNodes(tree, tree.getNode(i))) descendants.add(n.getNumber()); return descendants; }
private double getUniqueBranches(Tree tree, NodeRef node) { if (tree.isExternal(node)) { return tree.getBranchLength(node); } else { double length = 0; if (isUnique(taxonList, tree, node)) { length = tree.getBranchLength(node); // System.out.println("length = " + length); } for (int i = 0; i < tree.getChildCount(node); i++) { length += getUniqueBranches(tree, tree.getChild(node, i)); } // System.out.println("length of node " + node + " = " + length); return length; } }
public Map<String, Integer> writeNexusHeader(Tree tree) { int taxonCount = tree.getTaxonCount(); List<String> names = new ArrayList<String>(); for (int i = 0; i < tree.getTaxonCount(); i++) { names.add(tree.getTaxonId(i)); } if (sorted) Collections.sort(names); out.println("#NEXUS"); out.println(); out.println("Begin taxa;"); out.println("\tDimensions ntax=" + taxonCount + ";"); out.println("\tTaxlabels"); for (String name : names) { if (name.matches(SPECIAL_CHARACTERS_REGEX)) { name = "'" + name + "'"; } out.println("\t\t" + name); } out.println("\t\t;"); out.println("End;"); out.println(""); out.println("Begin trees;"); // This is needed if the trees use numerical taxon labels out.println("\tTranslate"); Map<String, Integer> idMap = new HashMap<String, Integer>(); int k = 1; for (String name : names) { idMap.put(name, k); if (name.matches(SPECIAL_CHARACTERS_REGEX)) { name = "'" + name + "'"; } if (k < names.size()) { out.println("\t\t" + k + " " + name + ","); } else { out.println("\t\t" + k + " " + name); } k += 1; } return idMap; }
/** Calculates the actual rates corresponding to the category indices. */ protected void setupRates() { // System.out.println("BRRRTTZZZ " + distributionIndexParameter.getValue(0)); for (int i = 0; i < tree.getNodeCount(); i++) { // rates[i] = distributionModel.quantile(rateCategoryQuantiles.getNodeValue( // rateCategoryQuantiles.getTreeModel(), rateCategoryQuantiles.getTreeModel().getNode(i) )); if (!tree.isRoot(tree.getNode(i))) { if (useQuantilesForRates) { /* Using quantiles to represent rates */ rates[tree.getNode(i).getNumber()] = distributionModels[(int) Math.round(distributionIndexParameter.getValue(0))].quantile( rateCategoryQuantiles.getNodeValue(tree, tree.getNode(i))); } else { /* Not using quantiles to represent rates. This is practically useless for anything else other than simulation */ rates[tree.getNode(i).getNumber()] = rateCategoryQuantiles.getNodeValue(tree, tree.getNode(i)); } } } /*System.out.print(distributionModels[(int) Math.round(distributionIndexParameter.getValue(0))].getClass().getName() + "\t" + (int) Math.round(distributionIndexParameter.getValue(0)) + "\t" + rates[1] + "\t" + rateCategoryQuantiles.getNodeValue(tree, tree.getNode(1)));// + "\t" + distributionModels[(int) Math.round(distributionIndexParameter.getValue(0))].); if(distributionModels[(int) Math.round(distributionIndexParameter.getValue(0))].getClass().getName().equals("dr.inference.distribution.LogNormalDistributionModel")) { LogNormalDistributionModel lndm = (LogNormalDistributionModel) distributionModels[(int) Math.round(distributionIndexParameter.getValue(0))]; System.out.println("\t" + lndm.getS()); } else if (distributionModels[(int) Math.round(distributionIndexParameter.getValue(0))].getClass().getName().equals("dr.inference.distribution.InverseGaussianDistributionModel")) { InverseGaussianDistributionModel lndm = (InverseGaussianDistributionModel) distributionModels[(int) Math.round(distributionIndexParameter.getValue(0))]; System.out.println("\t" + lndm.getS()); }*/ if (normalize) computeFactor(); }
double calculateNorm(Tree tree) { double time = 0.0; double rateTime = 0.0; for (int i = 0; i < tree.getNodeCount(); i++) { NodeRef node = tree.getNode(i); if (!tree.isRoot(node)) { double branchTime = tree.getBranchLength(node); rateTime += getRawBranchRate(tree, node) * branchTime; time += branchTime; } } return rateTime / time; }
public Double getTrait(Tree tree, NodeRef node) { if (!weightsKnown) { expectedIBD(); weightsKnown = true; } if (tree.isExternal(node)) { return getIBDWeight(tree, node); } return null; }
private double getIBDWeight(Tree tree, NodeRef node) { if (!weightsKnown) { expectedIBD(); weightsKnown = true; } if (tree.isExternal(node)) { int nodeNum = node.getNumber(); return ibdweights[nodeNum] + 1; } return 0; }
private static int mauCanonicalSub( Tree tree, NodeRef node, int loc, NodeRef[] order, boolean[] wasSwaped) { if (tree.isExternal(node)) { order[loc] = node; assert (loc & 0x1) == 0; return loc + 1; } final boolean swap = MathUtils.nextBoolean(); // wasSwaped[(loc-1)/2] = swap; int l = mauCanonicalSub(tree, tree.getChild(node, swap ? 1 : 0), loc, order, wasSwaped); order[l] = node; assert (l & 0x1) == 1; wasSwaped[(l - 1) / 2] = swap; l = mauCanonicalSub(tree, tree.getChild(node, swap ? 0 : 1), l + 1, order, wasSwaped); return l; }
public void writeNexusTree(Tree tree, String s, boolean attributes, Map<String, Integer> idMap) { // PAUP marks rooted trees thou String treeAttributes = "[&R] "; // Place tree level attributes in tree comment StringBuilder treeComment = null; { Iterator<String> iter = tree.getAttributeNames(); if (iter != null) { while (iter.hasNext()) { final String name = iter.next(); final String value = tree.getAttribute(name).toString(); if (name.equals("weight")) { treeAttributes = treeAttributes + "[&W " + value + " ] "; } else { if (treeComment == null) { treeComment = new StringBuilder(" [&"); } else if (treeComment.length() > 2) { treeComment.append(", "); } treeComment.append(name).append("=").append(value); } } if (treeComment != null) { treeComment.append("]"); } } } out.print( "tree " + s + ((treeComment != null) ? treeComment.toString() : "") + " = " + treeAttributes); writeNode(tree, tree.getRoot(), attributes, idMap); out.println(";"); }
/** * Calculates the probability of a given tree. * * @param tree - the tree to be analyzed * @return estimated posterior probability in log */ public double getTreeProbability(Tree tree, HashMap<String, Integer> taxonMap) { double prob = 0.0; List<Clade> clades = new ArrayList<Clade>(); List<Clade> parentClades = new ArrayList<Clade>(); // get clades contained in the tree getNonComplementaryClades(tree, tree.getRoot(), parentClades, clades, taxonMap); int size = clades.size(); // for every clade multiply its conditional clade probability to the // tree probability for (int i = 0; i < size; i++) { Clade c = clades.get(i); // get the bits of the clade Clade parent = parentClades.get(i); // set the occurrences to epsilon double tmp = EPSILON; double parentOccurrences = 0.0; BitSet parentBits = parent.getBits(); if (cladeProbabilities.containsKey(parentBits)) { // if we observed this clade in the trace, add the // occurrences // to epsilon parentOccurrences += cladeProbabilities.get(parentBits).getSampleCount(); } if (cladeCoProbabilities.containsKey(parentBits)) { // if we observed the parent clade HashMap<BitSet, Clade> conditionalProbs = cladeCoProbabilities.get(parentBits); BitSet bits = c.getBits(); if (conditionalProbs.containsKey(bits)) { // if we observed this conditional clade in the trace, // add // the occurrences to epsilon tmp += conditionalProbs.get(bits).getSampleCount(); } } // add epsilon for each clade final double splits = Math.pow(2, parent.getSize() - 1) - 1; parentOccurrences += EPSILON * splits; // multiply the conditional clade probability to the tree // probability prob += Math.log(tmp / parentOccurrences); } return prob; }
public SubstitutionModelDelegate(Tree tree, BranchModel branchModel, int bufferPoolSize) { if (MEASURE_RUN_TIME) { updateTime = 0; convolveTime = 0; } this.tree = tree; this.substitutionModelList = branchModel.getSubstitutionModels(); this.branchModel = branchModel; eigenCount = substitutionModelList.size(); nodeCount = tree.getNodeCount(); // two eigen buffers for each decomposition for store and restore. eigenBufferHelper = new BufferIndexHelper(eigenCount, 0); // two matrices for each node less the root matrixBufferHelper = new BufferIndexHelper(nodeCount, 0); this.extraBufferCount = branchModel.requiresMatrixConvolution() ? (bufferPoolSize > 0 ? bufferPoolSize : BUFFER_POOL_SIZE_DEFAULT) : 0; if (branchModel.requiresMatrixConvolution() && this.extraBufferCount < eigenCount) { throw new RuntimeException( "SubstitutionModelDelegate requires at least " + eigenCount + " extra buffers to convolve matrices"); } for (int i = 0; i < extraBufferCount; i++) { pushAvailableBuffer(i + matrixBufferHelper.getBufferCount()); } // one extra created as a reserve // which is used to free up buffers when the avail stack is empty. reserveBufferIndex = matrixBufferHelper.getBufferCount() + extraBufferCount; if (DEBUG) { System.out.println("Creating reserve buffer with index: " + reserveBufferIndex); } } // END: Constructor
public double[] getSummaryStatistic(Tree tree) { double externalLength = 0.0; double internalLength = 0.0; int externalNodeCount = tree.getExternalNodeCount(); for (int i = 0; i < externalNodeCount; i++) { NodeRef node = tree.getExternalNode(i); externalLength += tree.getBranchLength(node); } int internalNodeCount = tree.getInternalNodeCount(); for (int i = 0; i < internalNodeCount; i++) { NodeRef node = tree.getInternalNode(i); if (!tree.isRoot(node)) { internalLength += tree.getBranchLength(node); } } return new double[] {internalLength + externalLength}; }
@Override public int getNoOfVertices() { return tree.getNodeCount(); }
@Override public int getLCA(int i, int j) { return Tree.Utils.getCommonAncestor(tree, tree.getNode(i), tree.getNode(j)).getNumber(); }
private void getDescendants(NodeRef n, List<Integer> descendants) { descendants.add(n.getNumber()); if (tree.isExternal(n)) return; for (int i = 0; i < tree.getChildCount(n); ++i) getDescendants(tree.getChild(n, i), descendants); }
@Override public int getHeight() { return getHeight(tree.getRoot().getNumber()); }
@Override public boolean isRoot(int i) { return tree.isRoot(tree.getNode(i)); }
public JPrIMERBTreeWrapperForBEASTTree(Tree tree) { super(tree.getId(), 1); this.tree = tree; root = getRoot(); }
@Override public String getName() { return tree.getId(); }
@Override public int getLeftChild(int i) { return tree.getChild(tree.getNode(i), 0).getNumber(); }
@Override public int getRightChild(int i) { return tree.getChild(tree.getNode(i), 1).getNumber(); }