/*
* 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;
}
