void calc_edgelks_beagle(t_edge *b, t_tree *tree) { assert(UNINITIALIZED != tree->b_inst); //Compute the edge likelihood int parents[1] = {b->p_lk_left_idx}; int children[1] = {b->rght->tax?b->p_lk_tip_idx:b->p_lk_rght_idx}; int pmats[1] = {b->Pij_rr_idx}; int other[1] = {0};//Category Weights and State Frequencies both have a single buffer, hence they are both indexed at 0 double lnL[1] = {UNINITIALIZED}; // DUMP_I(parents[0], children[0], pmats[0], b->num, b->rght->tax); int ret=beagleCalculateEdgeLogLikelihoods(tree->b_inst, parents, children, pmats, NULL, NULL, other, other, NULL, 1, lnL, NULL, NULL); int i; if(ret<0){ fprintf(stderr, "beagleCalculateEdgeLogLikelihoods() on instance %i failed:%i\n\n",tree->b_inst,ret); Exit(""); } tree->c_lnL = sizeof(phydbl)==sizeof(float)?(float)lnL[0]:lnL[0]; //Retrieve the site likelihoods that were computed during the previous edge likelihood computation ret = beagleGetSiteLogLikelihoods(tree->b_inst,tree->cur_site_lk);//TODO: Handle when cur_site_lk is float if(ret<0){ fprintf(stderr, "beagleGetSiteLogLikelihoods() on instance %i failed:%i\n\n",tree->b_inst,ret); Exit(""); } //Transform for(i=0;i<tree->n_pattern;++i) tree->cur_site_lk[i]=EXP(tree->cur_site_lk[i]); }
/* * Class: beagle_BeagleJNIWrapper * Method: getSiteLogLikelihoods * Signature: (I[D)I */ JNIEXPORT jint JNICALL Java_beagle_BeagleJNIWrapper_getSiteLogLikelihoods (JNIEnv *env, jobject obj, jint instance, jdoubleArray outSiteLogLikelihoods) { jdouble *siteLogLikelihoods = env->GetDoubleArrayElements(outSiteLogLikelihoods, NULL); jint errCode = (jint)beagleGetSiteLogLikelihoods(instance, (double *)siteLogLikelihoods); // not using JNI_ABORT flag here because we want the values to be copied back... env->ReleaseDoubleArrayElements(outSiteLogLikelihoods, siteLogLikelihoods, 0); return errCode; }
int main( int argc, const char* argv[] ) { // print resource list BeagleResourceList* rList; rList = beagleGetResourceList(); fprintf(stdout, "Available resources:\n"); for (int i = 0; i < rList->length; i++) { fprintf(stdout, "\tResource %i:\n\t\tName : %s\n", i, rList->list[i].name); fprintf(stdout, "\t\tDesc : %s\n", rList->list[i].description); fprintf(stdout, "\t\tFlags:"); printFlags(rList->list[i].supportFlags); fprintf(stdout, "\n"); } fprintf(stdout, "\n"); bool manualScaling = false; bool autoScaling = false; bool gRates = false; // generalized rate categories, separate root buffers // is nucleotides... int stateCount = 4; // get the number of site patterns int nPatterns = strlen(human); int rateCategoryCount = 4; int nRateCats = (gRates ? 1 : rateCategoryCount); int nRootCount = (!gRates ? 1 : rateCategoryCount); int nPartBuffs = 4 + nRootCount; int scaleCount = (manualScaling ? 2 + nRootCount : 0); // initialize the instance BeagleInstanceDetails instDetails; // create an instance of the BEAGLE library int instance = beagleCreateInstance( 3, /**< Number of tip data elements (input) */ nPartBuffs, /**< Number of partials buffers to create (input) */ 0, /**< Number of compact state representation buffers to create (input) */ stateCount, /**< Number of states in the continuous-time Markov chain (input) */ nPatterns, /**< Number of site patterns to be handled by the instance (input) */ 1, /**< Number of rate matrix eigen-decomposition buffers to allocate (input) */ 4, /**< Number of rate matrix buffers (input) */ nRateCats, /**< Number of rate categories (input) */ scaleCount, /**< Number of scaling buffers */ NULL, /**< List of potential resource on which this instance is allowed (input, NULL implies no restriction */ 0, /**< Length of resourceList list (input) */ BEAGLE_FLAG_PRECISION_DOUBLE | BEAGLE_FLAG_PROCESSOR_GPU | (autoScaling ? BEAGLE_FLAG_SCALING_AUTO : 0), /**< Bit-flags indicating preferred implementation charactertistics, see BeagleFlags (input) */ 0, /**< Bit-flags indicating required implementation characteristics, see BeagleFlags (input) */ &instDetails); if (instance < 0) { fprintf(stderr, "Failed to obtain BEAGLE instance\n\n"); exit(1); } int rNumber = instDetails.resourceNumber; fprintf(stdout, "Using resource %i:\n", rNumber); fprintf(stdout, "\tRsrc Name : %s\n",instDetails.resourceName); fprintf(stdout, "\tImpl Name : %s\n", instDetails.implName); fprintf(stdout, "\tImpl Desc : %s\n", instDetails.implDescription); fprintf(stdout, "\tFlags:"); printFlags(instDetails.flags); fprintf(stdout, "\n\n"); if (!(instDetails.flags & BEAGLE_FLAG_SCALING_AUTO)) autoScaling = false; // beagleSetTipStates(instance, 0, getStates(human)); // beagleSetTipStates(instance, 1, getStates(chimp)); // beagleSetTipStates(instance, 2, getStates(gorilla)); // set the sequences for each tip using partial likelihood arrays double *humanPartials = getPartials(human); double *chimpPartials = getPartials(chimp); double *gorillaPartials = getPartials(gorilla); beagleSetTipPartials(instance, 0, humanPartials); beagleSetTipPartials(instance, 1, chimpPartials); beagleSetTipPartials(instance, 2, gorillaPartials); //#ifdef _WIN32 // std::vector<double> rates(rateCategoryCount); //#else // double rates[rateCategoryCount]; //#endif // for (int i = 0; i < rateCategoryCount; i++) { // rates[i] = 1.0; // } double rates[4] = { 0.03338775, 0.25191592, 0.82026848, 2.89442785 }; // create base frequency array double freqs[16] = { 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25 }; // create an array containing site category weights double* weights = (double*) malloc(sizeof(double) * rateCategoryCount); for (int i = 0; i < rateCategoryCount; i++) { weights[i] = 1.0/rateCategoryCount; } double* patternWeights = (double*) malloc(sizeof(double) * nPatterns); for (int i = 0; i < nPatterns; i++) { patternWeights[i] = 1.0; } // an eigen decomposition for the JC69 model double evec[4 * 4] = { 1.0, 2.0, 0.0, 0.5, 1.0, -2.0, 0.5, 0.0, 1.0, 2.0, 0.0, -0.5, 1.0, -2.0, -0.5, 0.0 }; double ivec[4 * 4] = { 0.25, 0.25, 0.25, 0.25, 0.125, -0.125, 0.125, -0.125, 0.0, 1.0, 0.0, -1.0, 1.0, 0.0, -1.0, 0.0 }; double eval[4] = { 0.0, -1.3333333333333333, -1.3333333333333333, -1.3333333333333333 }; // set the Eigen decomposition beagleSetEigenDecomposition(instance, 0, evec, ivec, eval); beagleSetStateFrequencies(instance, 0, freqs); beagleSetCategoryWeights(instance, 0, weights); beagleSetPatternWeights(instance, patternWeights); // a list of indices and edge lengths int nodeIndices[4] = { 0, 1, 2, 3 }; double edgeLengths[4] = { 0.1, 0.1, 0.2, 0.1 }; int* rootIndices = (int*) malloc(sizeof(int) * nRootCount); int* categoryWeightsIndices = (int*) malloc(sizeof(int) * nRootCount); int* stateFrequencyIndices = (int*) malloc(sizeof(int) * nRootCount); int* cumulativeScalingIndices = (int*) malloc(sizeof(int) * nRootCount); for (int i = 0; i < nRootCount; i++) { rootIndices[i] = 4 + i; categoryWeightsIndices[i] = 0; stateFrequencyIndices[i] = 0; cumulativeScalingIndices[i] = (manualScaling ? 2 + i : BEAGLE_OP_NONE); beagleSetCategoryRates(instance, &rates[i]); // tell BEAGLE to populate the transition matrices for the above edge lengths beagleUpdateTransitionMatrices(instance, // instance 0, // eigenIndex nodeIndices, // probabilityIndices NULL, // firstDerivativeIndices NULL, // secondDerivativeIndices edgeLengths, // edgeLengths 4); // count // create a list of partial likelihood update operations // the order is [dest, destScaling, source1, matrix1, source2, matrix2] BeagleOperation operations[2] = { 3, (manualScaling ? 0 : BEAGLE_OP_NONE), BEAGLE_OP_NONE, 0, 0, 1, 1, rootIndices[i], (manualScaling ? 1 : BEAGLE_OP_NONE), BEAGLE_OP_NONE, 2, 2, 3, 3 }; if (manualScaling) beagleResetScaleFactors(instance, cumulativeScalingIndices[i]); // update the partials beagleUpdatePartials(instance, // instance operations, // eigenIndex 2, // operationCount cumulativeScalingIndices[i]);// cumulative scaling index } if (autoScaling) { int scaleIndices[2] = {3, 4}; beagleAccumulateScaleFactors(instance, scaleIndices, 2, BEAGLE_OP_NONE); } double *patternLogLik = (double*)malloc(sizeof(double) * nPatterns); double logL = 0.0; int returnCode = 0; // calculate the site likelihoods at the root node returnCode = beagleCalculateRootLogLikelihoods(instance, // instance (const int *)rootIndices,// bufferIndices (const int *)categoryWeightsIndices, // weights (const int *)stateFrequencyIndices, // stateFrequencies cumulativeScalingIndices,// cumulative scaling index nRootCount, // count &logL); // outLogLikelihoods if (returnCode < 0) { fprintf(stderr, "Failed to calculate root likelihood\n\n"); } else { beagleGetSiteLogLikelihoods(instance, patternLogLik); double sumLogL = 0.0; for (int i = 0; i < nPatterns; i++) { sumLogL += patternLogLik[i] * patternWeights[i]; // std::cerr << "site lnL[" << i << "] = " << patternLogLik[i] << '\n'; } fprintf(stdout, "logL = %.5f (PAUP logL = -1498.89812)\n", logL); fprintf(stdout, "sumLogL = %.5f\n", sumLogL); } // no rate heterogeneity: // fprintf(stdout, "logL = %.5f (PAUP logL = -1574.63623)\n\n", logL); free(weights); free(patternWeights); free(rootIndices); free(categoryWeightsIndices); free(stateFrequencyIndices); free(cumulativeScalingIndices); free(patternLogLik); free(humanPartials); free(chimpPartials); free(gorillaPartials); beagleFinalizeInstance(instance); #ifdef _WIN32 std::cout << "\nPress ENTER to exit...\n"; fflush( stdout); fflush( stderr); getchar(); #endif }