protected void handleVariableChangedEvent(
Variable variable, int index, Parameter.ChangeType type) {
if (variable == traitParameter) { // A tip value got updated
if (index > dimTrait * treeModel.getExternalNodeCount()) {
throw new RuntimeException("Attempting to update an invalid index");
}
if (index != -1) {
cacheHelper.setMeanCache(index, traitParameter.getValue(index));
} else {
for (int idx = 0; idx < traitParameter.getDimension(); ++idx) {
cacheHelper.setMeanCache(idx, traitParameter.getValue(idx));
}
}
// meanCache[index] = traitParameter.getValue(index);
likelihoodKnown = false;
// if (!cacheBranches) {
// throw new RuntimeException("Must cache means in IMTL if they are random");
// }
// TODO Need better solution. If tips are random, cacheBranches should be true (to get
// reset).
// TODO However, jitter calls setParameterValue() on the tips at initialization
}
super.handleVariableChangedEvent(variable, index, type);
}
/**
* Create a region with the given region description name.
*
* @param regDescriptName The name of a region description.
*/
protected void initializeRegion(String regDescriptName) {
CacheHelper.createCache("cache1");
String key = VmIDStr + RemoteTestModule.getMyVmid();
String xmlFile = key + ".xml";
try {
CacheHelper.generateCacheXmlFile("cache1", regDescriptName, xmlFile);
} catch (HydraRuntimeException e) {
if (e.toString().indexOf("Cache XML file was already created") >= 0) {
// this can occur when reinitializing after a stop-start because
// the cache xml file is written during the first init tasks
} else {
throw new TestException(TestHelper.getStackTrace(e));
}
}
aRegion = RegionHelper.createRegion(regDescriptName);
}
public void setTipDataValuesForNode(int index, double[] traitValue) {
// Set tip data values
// cacheHelper.copyToMeanCache(traitValue, dim*index, dim);
cacheHelper.setTipMeans(traitValue, dim, index);
// System.arraycopy(traitValue, 0, meanCache, dim * index, dim);
makeDirty();
}
/**
* Returns the async event queues for the current cache, or null if no async event queues or cache
* exists.
*/
public static Set<AsyncEventQueue> getAsyncEventQueues() {
Cache cache = CacheHelper.getCache();
if (cache == null) {
return null;
} else {
Set<AsyncEventQueue> queues = cache.getAsyncEventQueues();
return (queues == null || queues.size() == 0) ? null : queues;
}
}
private void setTipDataValuesForNode(NodeRef node) {
// Set tip data values
int index = node.getNumber();
double[] traitValue = traitParameter.getParameter(index).getParameterValues();
if (traitValue.length < dim) {
throw new RuntimeException(
"The trait parameter for the tip with index, " + index + ", is too short");
}
cacheHelper.setTipMeans(traitValue, dim, index, node);
// System.arraycopy(traitValue, 0, meanCache
//// cacheHelper.getMeanCache()
// , dim * index, dim);
}
private void incrementOuterProducts(
int thisOffset, int childOffset0, int childOffset1, double precision0, double precision1) {
final double[][] outerProduct = wishartStatistics.getScaleMatrix();
for (int k = 0; k < numData; k++) {
for (int i = 0; i < dimTrait; i++) {
// final double wChild0i = meanCache[childOffset0 + k * dimTrait + i] * precision0;
// final double wChild1i = meanCache[childOffset1 + k * dimTrait + i] * precision1;
final double wChild0i =
cacheHelper.getCorrectedMeanCache()[childOffset0 + k * dimTrait + i] * precision0;
final double wChild1i =
cacheHelper.getCorrectedMeanCache()[childOffset1 + k * dimTrait + i] * precision1;
for (int j = 0; j < dimTrait; j++) {
// final double child0j = meanCache[childOffset0 + k * dimTrait + j];
// final double child1j = meanCache[childOffset1 + k * dimTrait + j];
final double child0j =
cacheHelper.getCorrectedMeanCache()[childOffset0 + k * dimTrait + j];
final double child1j =
cacheHelper.getCorrectedMeanCache()[childOffset1 + k * dimTrait + j];
outerProduct[i][j] += wChild0i * child0j;
outerProduct[i][j] += wChild1i * child1j;
// outerProduct[i][j] -= (wChild0i + wChild1i) * meanCache[thisOffset + k * dimTrait + j];
outerProduct[i][j] -=
(wChild0i + wChild1i) * cacheHelper.getMeanCache()[thisOffset + k * dimTrait + j];
}
}
}
wishartStatistics.incrementDf(1); // Peeled one node
}
protected void initializeQueryService() {
try {
String usingPool = TestConfig.tab().stringAt(CQUtilPrms.QueryServiceUsingPool, "false");
boolean queryServiceUsingPool = Boolean.valueOf(usingPool).booleanValue();
if (queryServiceUsingPool) {
Pool pool = PoolHelper.createPool(CQUtilPrms.getQueryServicePoolName());
qService = pool.getQueryService();
Log.getLogWriter()
.info("Initializing QueryService using Pool. PoolName: " + pool.getName());
} else {
qService = CacheHelper.getCache().getQueryService();
Log.getLogWriter().info("Initializing QueryService using Cache.");
}
} catch (Exception e) {
throw new TestException(TestHelper.getStackTrace(e));
}
}
public void storeState() {
super.storeState();
if (cacheBranches) {
// System.arraycopy(meanCache, 0, storedMeanCache, 0, meanCache.length);
cacheHelper.store();
System.arraycopy(
upperPrecisionCache, 0, storedUpperPrecisionCache, 0, upperPrecisionCache.length);
System.arraycopy(
lowerPrecisionCache, 0, storedLowerPrecisionCache, 0, lowerPrecisionCache.length);
System.arraycopy(
logRemainderDensityCache,
0,
storedLogRemainderDensityCache,
0,
logRemainderDensityCache.length);
}
}
/**
* Creates and starts an async event queue in the current cache. The queue is configured using the
* {@link AsyncEventQueueDescription} corresponding to the given configuration from {@link
* AsyncEventQueuePrms#names}. The id for the queue is the same as the queue configuration name.
*
* <p>This method is thread-safe. The async event queues for a given logical queue configuration
* will only be created once.
*
* @throws HydraRuntimeException if an attempt is made to reconfigure an existing async event
* queue.
*/
public static synchronized AsyncEventQueue createAndStartAsyncEventQueue(
String asyncEventQueueConfig) {
AsyncEventQueue queue = getAsyncEventQueue(asyncEventQueueConfig);
if (queue == null) {
// get the cache
Cache cache = CacheHelper.getCache();
if (cache == null) {
String s = "Cache has not been created yet";
throw new HydraRuntimeException(s);
}
// look up the async event queue configuration
AsyncEventQueueDescription aeqd = getAsyncEventQueueDescription(asyncEventQueueConfig);
// create the disk store
DiskStoreHelper.createDiskStore(aeqd.getDiskStoreDescription().getName());
// create the async event queue
queue = createAsyncEventQueue(aeqd, cache);
}
return queue;
}
public void restoreState() {
super.restoreState();
if (cacheBranches) {
double[] tmp;
cacheHelper.restore();
// tmp = storedMeanCache;
// storedMeanCache = meanCache;
// meanCache = tmp;
tmp = storedUpperPrecisionCache;
storedUpperPrecisionCache = upperPrecisionCache;
upperPrecisionCache = tmp;
tmp = storedLowerPrecisionCache;
storedLowerPrecisionCache = lowerPrecisionCache;
lowerPrecisionCache = tmp;
tmp = storedLogRemainderDensityCache;
storedLogRemainderDensityCache = logRemainderDensityCache;
logRemainderDensityCache = tmp;
}
}
private void preOrderTraverseSample(
MultivariateTraitTree treeModel,
NodeRef node,
int parentIndex,
double[][] treePrecision,
double[][] treeVariance) {
final int thisIndex = node.getNumber();
if (treeModel.isRoot(node)) {
// draw root
double[] rootMean = new double[dimTrait];
final int rootIndex = treeModel.getRoot().getNumber();
double rootPrecision = lowerPrecisionCache[rootIndex];
for (int datum = 0; datum < numData; datum++) {
// System.arraycopy(meanCache, thisIndex * dim + datum * dimTrait, rootMean, 0, dimTrait);
System.arraycopy(
cacheHelper.getMeanCache(), thisIndex * dim + datum * dimTrait, rootMean, 0, dimTrait);
double[][] variance =
computeMarginalRootMeanAndVariance(
rootMean, treePrecision, treeVariance, rootPrecision);
double[] draw =
MultivariateNormalDistribution.nextMultivariateNormalVariance(rootMean, variance);
if (DEBUG_PREORDER) {
Arrays.fill(draw, 1.0);
}
System.arraycopy(draw, 0, drawnStates, rootIndex * dim + datum * dimTrait, dimTrait);
if (DEBUG) {
System.err.println("Root mean: " + new Vector(rootMean));
System.err.println("Root var : " + new Matrix(variance));
System.err.println("Root draw: " + new Vector(draw));
}
}
} else { // draw conditional on parentState
if (!missingTraits.isCompletelyMissing(thisIndex)
&& !missingTraits.isPartiallyMissing(thisIndex)) {
// System.arraycopy(meanCache, thisIndex * dim, drawnStates, thisIndex * dim, dim);
System.arraycopy(
cacheHelper.getMeanCache(), thisIndex * dim, drawnStates, thisIndex * dim, dim);
} else {
if (missingTraits.isPartiallyMissing(thisIndex)) {
throw new RuntimeException("Partially missing values are not yet implemented");
}
// This code should work for sampling a missing tip trait as well, but needs testing
// parent trait at drawnStates[parentOffset]
double precisionToParent = 1.0 / getRescaledBranchLengthForPrecision(node);
double precisionOfNode = lowerPrecisionCache[thisIndex];
double totalPrecision = precisionOfNode + precisionToParent;
double[] mean = Ay; // temporary storage
double[][] var = tmpM; // temporary storage
for (int datum = 0; datum < numData; datum++) {
int parentOffset = parentIndex * dim + datum * dimTrait;
int thisOffset = thisIndex * dim + datum * dimTrait;
if (DEBUG) {
double[] parentValue = new double[dimTrait];
System.arraycopy(drawnStates, parentOffset, parentValue, 0, dimTrait);
System.err.println("Parent draw: " + new Vector(parentValue));
if (parentValue[0] != drawnStates[parentOffset]) {
throw new RuntimeException("Error in setting indices");
}
}
for (int i = 0; i < dimTrait; i++) {
mean[i] =
(drawnStates[parentOffset + i] * precisionToParent
// + meanCache[thisOffset + i] * precisionOfNode) / totalPrecision;
+ cacheHelper.getMeanCache()[thisOffset + i] * precisionOfNode)
/ totalPrecision;
for (int j = 0; j < dimTrait; j++) {
var[i][j] = treeVariance[i][j] / totalPrecision;
}
}
double[] draw = MultivariateNormalDistribution.nextMultivariateNormalVariance(mean, var);
System.arraycopy(draw, 0, drawnStates, thisOffset, dimTrait);
if (DEBUG) {
System.err.println("Int prec: " + totalPrecision);
System.err.println("Int mean: " + new Vector(mean));
System.err.println("Int var : " + new Matrix(var));
System.err.println("Int draw: " + new Vector(draw));
System.err.println("");
}
}
}
}
if (peel() && !treeModel.isExternal(node)) {
preOrderTraverseSample(
treeModel, treeModel.getChild(node, 0), thisIndex, treePrecision, treeVariance);
preOrderTraverseSample(
treeModel, treeModel.getChild(node, 1), thisIndex, treePrecision, treeVariance);
}
}
private void incrementRemainderDensities(
double[][] precisionMatrix,
double logDetPrecisionMatrix,
int thisIndex,
int thisOffset,
int childOffset0,
int childOffset1,
double precision0,
double precision1,
double OUFactor0,
double OUFactor1,
boolean cacheOuterProducts) {
final double remainderPrecision = precision0 * precision1 / (precision0 + precision1);
if (cacheOuterProducts) {
incrementOuterProducts(thisOffset, childOffset0, childOffset1, precision0, precision1);
}
for (int k = 0; k < numData; k++) {
double childSS0 = 0;
double childSS1 = 0;
double crossSS = 0;
for (int i = 0; i < dimTrait; i++) {
// In case of no drift, getCorrectedMeanCache() simply returns mean cache
// final double wChild0i = meanCache[childOffset0 + k * dimTrait + i] * precision0;
final double wChild0i =
cacheHelper.getCorrectedMeanCache()[childOffset0 + k * dimTrait + i] * precision0;
// final double wChild1i = meanCache[childOffset1 + k * dimTrait + i] * precision1;
final double wChild1i =
cacheHelper.getCorrectedMeanCache()[childOffset1 + k * dimTrait + i] * precision1;
for (int j = 0; j < dimTrait; j++) {
// subtract "correction"
// final double child0j = meanCache[childOffset0 + k * dimTrait + j];
final double child0j =
cacheHelper.getCorrectedMeanCache()[childOffset0 + k * dimTrait + j];
// subtract "correction"
// final double child1j = meanCache[childOffset1 + k * dimTrait + j];
final double child1j =
cacheHelper.getCorrectedMeanCache()[childOffset1 + k * dimTrait + j];
childSS0 += wChild0i * precisionMatrix[i][j] * child0j;
childSS1 += wChild1i * precisionMatrix[i][j] * child1j;
// make sure meanCache in following is not "corrected"
// crossSS += (wChild0i + wChild1i) * precisionMatrix[i][j] * meanCache[thisOffset + k *
// dimTrait + j];
crossSS +=
(wChild0i + wChild1i)
* precisionMatrix[i][j]
* cacheHelper.getMeanCache()[thisOffset + k * dimTrait + j];
}
}
logRemainderDensityCache[thisIndex] +=
-dimTrait * LOG_SQRT_2_PI
+ 0.5 * (dimTrait * Math.log(remainderPrecision) + logDetPrecisionMatrix)
- 0.5 * (childSS0 + childSS1 - crossSS)
- dimTrait * (Math.log(OUFactor0) + Math.log(OUFactor1));
}
}
void postOrderTraverse(
MultivariateTraitTree treeModel,
NodeRef node,
double[][] precisionMatrix,
double logDetPrecisionMatrix,
boolean cacheOuterProducts) {
final int thisNumber = node.getNumber();
if (treeModel.isExternal(node)) {
// Fill in precision scalar, traitValues already filled in
if (missingTraits.isCompletelyMissing(thisNumber)) {
upperPrecisionCache[thisNumber] = 0;
lowerPrecisionCache[thisNumber] = 0; // Needed in the pre-order traversal
} else { // not missing tip trait
upperPrecisionCache[thisNumber] =
(1.0 / getRescaledBranchLengthForPrecision(node))
* Math.pow(cacheHelper.getOUFactor(node), 2);
lowerPrecisionCache[thisNumber] = Double.POSITIVE_INFINITY;
}
return;
}
final NodeRef childNode0 = treeModel.getChild(node, 0);
final NodeRef childNode1 = treeModel.getChild(node, 1);
postOrderTraverse(
treeModel, childNode0, precisionMatrix, logDetPrecisionMatrix, cacheOuterProducts);
postOrderTraverse(
treeModel, childNode1, precisionMatrix, logDetPrecisionMatrix, cacheOuterProducts);
final int childNumber0 = childNode0.getNumber();
final int childNumber1 = childNode1.getNumber();
final int meanOffset0 = dim * childNumber0;
final int meanOffset1 = dim * childNumber1;
final int meanThisOffset = dim * thisNumber;
final double precision0 = upperPrecisionCache[childNumber0];
final double precision1 = upperPrecisionCache[childNumber1];
final double totalPrecision = precision0 + precision1;
lowerPrecisionCache[thisNumber] = totalPrecision;
// Multiply child0 and child1 densities
// Delegate this!
cacheHelper.computeMeanCaches(
meanThisOffset,
meanOffset0,
meanOffset1,
totalPrecision,
precision0,
precision1,
missingTraits,
node,
childNode0,
childNode1);
// if (totalPrecision == 0) {
// System.arraycopy(zeroDimVector, 0, meanCache, meanThisOffset, dim);
// } else {
// // Delegate in case either child is partially missing
// // computeCorrectedWeightedAverage
// missingTraits.computeWeightedAverage(meanCache,
// meanOffset0, precision0,
// meanOffset1, precision1,
// meanThisOffset, dim);
// }
// In this delegation, you can call
// getShiftForBranchLength(node);
if (!treeModel.isRoot(node)) {
// Integrate out trait value at this node
double thisPrecision = 1.0 / getRescaledBranchLengthForPrecision(node);
if (Double.isInfinite(thisPrecision)) {
upperPrecisionCache[thisNumber] = totalPrecision;
} else {
upperPrecisionCache[thisNumber] =
(totalPrecision * thisPrecision / (totalPrecision + thisPrecision))
* Math.pow(cacheHelper.getOUFactor(node), 2);
}
}
// Compute logRemainderDensity
logRemainderDensityCache[thisNumber] = 0;
if (precision0 != 0 && precision1 != 0) {
incrementRemainderDensities(
precisionMatrix,
logDetPrecisionMatrix,
thisNumber,
meanThisOffset,
meanOffset0,
meanOffset1,
precision0,
precision1,
cacheHelper.getOUFactor(childNode0),
cacheHelper.getOUFactor(childNode1),
cacheOuterProducts);
}
}
public double calculateLogLikelihood() {
double logLikelihood = 0;
double[][] traitPrecision = diffusionModel.getPrecisionmatrix();
double logDetTraitPrecision = Math.log(diffusionModel.getDeterminantPrecisionMatrix());
double[] conditionalRootMean = tmp2;
final boolean computeWishartStatistics = getComputeWishartSufficientStatistics();
if (computeWishartStatistics) {
// if (wishartStatistics == null) {
wishartStatistics = new WishartSufficientStatistics(dimTrait);
// } else {
// wishartStatistics.clear();
// }
}
// Use dynamic programming to compute conditional likelihoods at each internal node
postOrderTraverse(
treeModel,
treeModel.getRoot(),
traitPrecision,
logDetTraitPrecision,
computeWishartStatistics);
if (DEBUG) {
System.err.println("mean: " + new Vector(cacheHelper.getMeanCache()));
System.err.println("correctedMean: " + new Vector(cacheHelper.getCorrectedMeanCache()));
System.err.println("upre: " + new Vector(upperPrecisionCache));
System.err.println("lpre: " + new Vector(lowerPrecisionCache));
System.err.println("cach: " + new Vector(logRemainderDensityCache));
}
// Compute the contribution of each datum at the root
final int rootIndex = treeModel.getRoot().getNumber();
// Precision scalar of datum conditional on root
double conditionalRootPrecision = lowerPrecisionCache[rootIndex];
for (int datum = 0; datum < numData; datum++) {
double thisLogLikelihood = 0;
// Get conditional mean of datum conditional on root
// System.arraycopy(meanCache, rootIndex * dim + datum * dimTrait, conditionalRootMean, 0,
// dimTrait);
System.arraycopy(
cacheHelper.getMeanCache(),
rootIndex * dim + datum * dimTrait,
conditionalRootMean,
0,
dimTrait);
if (DEBUG) {
System.err.println("Datum #" + datum);
System.err.println("root mean: " + new Vector(conditionalRootMean));
System.err.println("root prec: " + conditionalRootPrecision);
System.err.println("diffusion prec: " + new Matrix(traitPrecision));
}
// B = root prior precision
// z = root prior mean
// A = likelihood precision
// y = likelihood mean
// y'Ay
double yAy =
computeWeightedAverageAndSumOfSquares(
conditionalRootMean,
Ay,
traitPrecision,
dimTrait,
conditionalRootPrecision); // Also fills in Ay
if (conditionalRootPrecision != 0) {
thisLogLikelihood +=
-LOG_SQRT_2_PI * dimTrait
+ 0.5
* (logDetTraitPrecision + dimTrait * Math.log(conditionalRootPrecision) - yAy);
}
if (DEBUG) {
double[][] T = new double[dimTrait][dimTrait];
for (int i = 0; i < dimTrait; i++) {
for (int j = 0; j < dimTrait; j++) {
T[i][j] = traitPrecision[i][j] * conditionalRootPrecision;
}
}
System.err.println("Conditional root MVN precision = \n" + new Matrix(T));
System.err.println(
"Conditional root MVN density = "
+ MultivariateNormalDistribution.logPdf(
conditionalRootMean,
new double[dimTrait],
T,
Math.log(MultivariateNormalDistribution.calculatePrecisionMatrixDeterminate(T)),
1.0));
}
if (integrateRoot) {
// Integrate root trait out against rootPrior
thisLogLikelihood +=
integrateLogLikelihoodAtRoot(
conditionalRootMean,
Ay,
tmpM,
traitPrecision,
conditionalRootPrecision); // Ay is destroyed
}
if (DEBUG) {
System.err.println("yAy = " + yAy);
System.err.println(
"logLikelihood (before remainders) = "
+ thisLogLikelihood
+ " (should match conditional root MVN density when root not integrated out)");
}
logLikelihood += thisLogLikelihood;
}
logLikelihood += sumLogRemainders();
if (DEBUG) {
System.out.println("logLikelihood is " + logLikelihood);
}
if (DEBUG) { // Root trait is univariate!!!
System.err.println("logLikelihood (final) = " + logLikelihood);
// checkViaLargeMatrixInversion();
}
if (DEBUG_PNAS) {
checkLogLikelihood(
logLikelihood,
sumLogRemainders(),
conditionalRootMean,
conditionalRootPrecision,
traitPrecision);
}
areStatesRedrawn = false; // Should redraw internal node states when needed
return logLikelihood;
}
public double[] getTipDataValues(int index) {
double[] traitValue = new double[dim];
System.arraycopy(cacheHelper.getMeanCache(), dim * index, traitValue, 0, dim);
return traitValue;
}
