/* * Class: beagle_BeagleJNIWrapper * Method: getPartials * Signature: (III[D)I */ JNIEXPORT jint JNICALL Java_beagle_BeagleJNIWrapper_getPartials (JNIEnv *env, jobject obj, jint instance, jint bufferIndex, jint scaleIndex, jdoubleArray outPartials) { jdouble *partials = env->GetDoubleArrayElements(outPartials, NULL); jint errCode = beagleGetPartials(instance, bufferIndex, scaleIndex, (double *)partials); // not using JNI_ABORT flag here because we want the values to be copied back... env->ReleaseDoubleArrayElements(outPartials, partials, 0); return errCode; }
/* Update partial likelihood on edge b on the side of b where node d lies. */ void update_beagle_partials(t_tree* tree, t_edge* b, t_node* d) { /* | |<- b | d / \ b1 / \ b2 / \ n_v1 n_v2 */ if(d->tax) //Partial likelihoods are only calculated on internal nodes { PhyML_Printf("\n== t_node %d is a leaf...",d->num); PhyML_Printf("\n== Err. in file %s at line %d (function '%s')\n",__FILE__,__LINE__,__FUNCTION__); Warn_And_Exit("\n"); } //Determine d's "left" and "right" neighbors. t_node *n_v1, *n_v2;//d's "left" and "right" neighbor nodes phydbl *p_lk,*p_lk_v1,*p_lk_v2; phydbl *Pij1,*Pij2; int *sum_scale, *sum_scale_v1, *sum_scale_v2; int *p_lk_loc; int dest_p_idx, child1_p_idx, child2_p_idx, Pij1_idx, Pij2_idx; n_v1 = n_v2 = NULL; p_lk = p_lk_v1 = p_lk_v2 = NULL; Pij1 = Pij2 = NULL; sum_scale_v1 = sum_scale_v2 = NULL; p_lk_loc = NULL; dest_p_idx = child1_p_idx = child2_p_idx = Pij1_idx = Pij2_idx = UNINITIALIZED; Set_All_P_Lk(&n_v1,&n_v2, &p_lk,&sum_scale,&p_lk_loc, &Pij1,&p_lk_v1,&sum_scale_v1, &Pij2,&p_lk_v2,&sum_scale_v2, d,b,tree, &dest_p_idx, &child1_p_idx, &child2_p_idx, &Pij1_idx, &Pij2_idx); // fprintf(stdout, "\nUpdating partials on Branch %d (on the side where Node %d lies)\n",b->num,d->num);fflush(stdout); // double* p_lk_v1_b = (double*)malloc(tree->mod->ras->n_catg*tree->mod->ns*tree->n_pattern*sizeof(double));if(NULL==p_lk_v1_b) Warn_And_Exit("Couldnt allocate memory"); // beagleGetPartials(tree->b_inst, child1_p_idx, BEAGLE_OP_NONE, (double*)p_lk_v1_b); // double* p_lk_v2_b = (double*)malloc(tree->mod->ras->n_catg*tree->mod->ns*tree->n_pattern*sizeof(double));if(NULL==p_lk_v2_b) Warn_And_Exit("Couldnt allocate memory"); // beagleGetPartials(tree->b_inst, child2_p_idx, BEAGLE_OP_NONE, (double*)p_lk_v2_b); // fprintf(stdout, "Left partials :");fflush(stdout); // Dump_Arr_D(p_lk_v1_b, tree->mod->ras->n_catg*tree->mod->ns*tree->n_pattern); // fprintf(stdout, "Right partials:");fflush(stdout); // Dump_Arr_D(p_lk_v2_b, tree->mod->ras->n_catg*tree->mod->ns*tree->n_pattern); // Free(p_lk_v1_b); // Free(p_lk_v2_b); //Create the corresponding BEAGLE operation // fprintf(stderr,"%d, %d, %d, ", dest_p_idx, child1_p_idx, child2_p_idx); BeagleOperation operations[1] = {{dest_p_idx, BEAGLE_OP_NONE, BEAGLE_OP_NONE, child1_p_idx, Pij1_idx, child2_p_idx, Pij2_idx}}; //Compute the partials int ret = beagleUpdatePartials(tree->b_inst, operations, 1, BEAGLE_OP_NONE); if(ret<0){ fprintf(stderr, "beagleUpdatePartials() on instance %i failed:%i\n\n",tree->b_inst,ret); Exit(""); } //Load the computed/updated partial partials #ifndef CLEAN_BEAGLE_API ret = beagleGetPartials(tree->b_inst, dest_p_idx, BEAGLE_OP_NONE, (double*)p_lk); if(ret<0){ fprintf(stderr, "beagleGetPartials() on instance %i failed:%i\n\n",tree->b_inst,ret); Exit(""); } #endif // fprintf(stdout, "Updated partials:");fflush(stdout); // Dump_Arr_D(p_lk, tree->mod->ras->n_catg*tree->mod->ns*tree->n_pattern); }
/*----------------------------------------------------------------------------- | Calculates the log likelihood by calling the beagle functions | updateTransitionMatrices, updatePartials and calculateEdgeLogLikelihoods. */ double calcLnL(world_fmt *world, boolean instance) { beagle_fmt *beagle = world->beagle; double logL = 0.0; unsigned long i; unsigned long j; //unsigned long z; long locus = world->locus; long ii; double *patternloglike = (double *) calloc(world->maxnumpattern[locus],sizeof(double)); double *outlike = (double *) calloc(10*world->maxnumpattern[locus],sizeof(double)); int rootIndex = beagle->operations[BEAGLE_PARTIALS * (beagle->numoperations-1)];//world->root->next->back->id; for(i=0; i<world->nummutationmodels[locus]; i++) { ii = world->sublocistarts[locus] + i; int code = beagleUpdateTransitionMatrices(beagle->instance_handle[i], // instance, 0, // eigenIndex, (const int *) beagle->branch_indices, // indicators transitionrates for each branch, NULL, // firstDerivativeIndices, NULL, // secondDervativeIndices, beagle->branch_lengths, // edgeLengths, beagle->numbranches); // number branches to update, count if (code != 0) usererror("updateTransitionMatrices encountered a problem"); int cumulativeScalingFactorIndex = 0; //BEAGLE_OP_NONE; //this would be the index of the root scaling location beagleResetScaleFactors(beagle->instance_handle[i], cumulativeScalingFactorIndex); beagleAccumulateScaleFactors(beagle->instance_handle[i], beagle->scalingfactorsindices, beagle->scalingfactorscount, cumulativeScalingFactorIndex); code = beagleUpdatePartials((const int *) &beagle->instance_handle[i], // instance 1, // instanceCount beagle->operations, // operations beagle->numoperations, // operationCount cumulativeScalingFactorIndex);//BEAGLE_OP_NONE); // connected to accumulate.... #ifdef BEAGLEDEBUG for(j=0;j<2*(world->sumtips * 2 - 1); j++) { beagleGetPartials(beagle->instance_handle[i],j,BEAGLE_OP_NONE, outlike); if(j==world->sumtips * 2 - 1) printf("-----------------------\n"); printf("%li: {%f, %f, %f, %f}\n",j, outlike[0],outlike[1],outlike[2],outlike[3]); } #endif if (code != 0) usererror("updatePartials encountered a problem"); if(beagle->weights==NULL) beagle->weights = (double *) mycalloc(1,sizeof(double)); // else // beagle->weights = (double *) myrealloc(beagle->weights,beagle->numoperations * sizeof(double)); beagle->weights[0]= 1.0; // calculate the site likelihoods at the root node code = beagleCalculateRootLogLikelihoods(beagle->instance_handle[i], // instance (const int *) &rootIndex, // bufferIndices (const double *) world->mutationmodels[ii].siteprobs, // weights (const double *) world->mutationmodels[ii].basefreqs,// stateFrequencies &cumulativeScalingFactorIndex, //scalingfactors index, 1, // count is this correct patternloglike); // outLogLikelihoods //trash from function above &beagle->scalingfactorscount,//size of the scaling factor index if (code != 0) usererror("calculateRootLogLikelihoods encountered a problem"); for (j = 0; j < world->mutationmodels[ii].numsites; j++) { logL += beagle->allyweights[j] * patternloglike[j]; // printf("%.1f ",patternloglike[j]); } } printf("Log LnL=%f (instance=%li)\n",logL,(long) instance); #ifdef BEAGLEDEBUG debug_beagle(beagle); #endif myfree(patternloglike); myfree(outlike); return logL; }