static void singleBootstrap(tree *tr, int i, analdef *adef, rawdata *rdta, cruncheddata *cdta) { tr->treeID = i; tr->checkPointCounter = 0; computeNextReplicate(tr, &adef->boot, (int*)NULL, (int*)NULL, FALSE, FALSE); initModel(tr, rdta, cdta, adef); getStartingTree(tr, adef); computeBIGRAPID(tr, adef, TRUE); if(adef->bootstrapBranchLengths) { switch(tr->rateHetModel) { case GAMMA: case GAMMA_I: modOpt(tr, adef, TRUE, adef->likelihoodEpsilon); break; case CAT: tr->likelihood = unlikely; catToGamma(tr, adef); initModel(tr, rdta, cdta, adef); if(i == 0) modOpt(tr, adef, TRUE, adef->likelihoodEpsilon); else modOpt(tr, adef, TRUE, adef->likelihoodEpsilon); gammaToCat(tr); break; default: assert(0); } } printBootstrapResult(tr, adef, TRUE); }
void doInference(tree *tr, analdef *adef, rawdata *rdta, cruncheddata *cdta) { int i, n; #ifdef _WAYNE_MPI int j, bestProcess; #endif double loopTime; topolRELL_LIST *rl = (topolRELL_LIST *)NULL; int best = -1, newBest = -1; double bestLH = unlikely; FILE *f; char bestTreeFileName[1024]; double overallTime; n = adef->multipleRuns; #ifdef _WAYNE_MPI if(n % processes != 0) n = processes * ((n / processes) + 1); #endif if(!tr->catOnly) { rl = (topolRELL_LIST *)rax_malloc(sizeof(topolRELL_LIST)); initTL(rl, tr, n); } #ifdef _WAYNE_MPI long parsimonySeed0 = adef->parsimonySeed; n = n / processes; #endif if(adef->rellBootstrap) { #ifdef _WAYNE_MPI tr->resample = permutationSH(tr, NUM_RELL_BOOTSTRAPS, parsimonySeed0 + 10000 * processID); #else tr->resample = permutationSH(tr, NUM_RELL_BOOTSTRAPS, adef->parsimonySeed); #endif tr->rellTrees = (treeList *)rax_malloc(sizeof(treeList)); initTreeList(tr->rellTrees, tr, NUM_RELL_BOOTSTRAPS); } else { tr->resample = (int *)NULL; tr->rellTrees = (treeList *)NULL; } for(i = 0; i < n; i++) { #ifdef _WAYNE_MPI if(i == 0) { if(parsimonySeed0 != 0) adef->parsimonySeed = parsimonySeed0 + 10000 * processID; } j = i + n * processID; tr->treeID = j; #else tr->treeID = i; #endif tr->checkPointCounter = 0; loopTime = gettime(); initModel(tr, rdta, cdta, adef); if(i == 0) printBaseFrequencies(tr); getStartingTree(tr, adef); computeBIGRAPID(tr, adef, TRUE); #ifdef _WAYNE_MPI if(tr->likelihood > bestLH) { best = j; bestLH = tr->likelihood; } if(!tr->catOnly) saveTL(rl, tr, j); #else if(tr->likelihood > bestLH) { best = i; bestLH = tr->likelihood; } if(!tr->catOnly) saveTL(rl, tr, i); #endif loopTime = gettime() - loopTime; writeInfoFile(adef, tr, loopTime); } assert(best >= 0); #ifdef _WAYNE_MPI MPI_Barrier(MPI_COMM_WORLD); n = n * processes; #endif if(tr->catOnly) { printBothOpenMPI("\n\nNOT conducting any final model optimizations on all %d trees under CAT-based model ....\n", n); printBothOpenMPI("\nREMEMBER that CAT-based likelihood scores are meaningless!\n\n", n); #ifdef _WAYNE_MPI if(processID != 0) { MPI_Finalize(); exit(0); } #endif } else { printBothOpenMPI("\n\nConducting final model optimizations on all %d trees under GAMMA-based models ....\n\n", n); #ifdef _WAYNE_MPI n = n / processes; #endif if(tr->rateHetModel == GAMMA || tr->rateHetModel == GAMMA_I) { restoreTL(rl, tr, best); evaluateGenericInitrav(tr, tr->start); if(!adef->useBinaryModelFile) modOpt(tr, adef, FALSE, adef->likelihoodEpsilon); else { readBinaryModel(tr, adef); evaluateGenericInitrav(tr, tr->start); treeEvaluate(tr, 2); } bestLH = tr->likelihood; tr->likelihoods[best] = tr->likelihood; saveTL(rl, tr, best); tr->treeID = best; printResult(tr, adef, TRUE); newBest = best; for(i = 0; i < n; i++) { #ifdef _WAYNE_MPI j = i + n * processID; if(j != best) { restoreTL(rl, tr, j); evaluateGenericInitrav(tr, tr->start); treeEvaluate(tr, 1); tr->likelihoods[j] = tr->likelihood; if(tr->likelihood > bestLH) { newBest = j; bestLH = tr->likelihood; saveTL(rl, tr, j); } tr->treeID = j; printResult(tr, adef, TRUE); } if(n == 1 && processes == 1) printBothOpen("Inference[%d] final GAMMA-based Likelihood: %f tree written to file %s\n", i, tr->likelihoods[i], resultFileName); else printBothOpen("Inference[%d] final GAMMA-based Likelihood: %f tree written to file %s.RUN.%d\n", j, tr->likelihoods[j], resultFileName, j); #else if(i != best) { restoreTL(rl, tr, i); evaluateGenericInitrav(tr, tr->start); treeEvaluate(tr, 1); tr->likelihoods[i] = tr->likelihood; if(tr->likelihood > bestLH) { newBest = i; bestLH = tr->likelihood; saveTL(rl, tr, i); } tr->treeID = i; printResult(tr, adef, TRUE); } if(n == 1) printBothOpen("Inference[%d] final GAMMA-based Likelihood: %f tree written to file %s\n", i, tr->likelihoods[i], resultFileName); else printBothOpen("Inference[%d] final GAMMA-based Likelihood: %f tree written to file %s.RUN.%d\n", i, tr->likelihoods[i], resultFileName, i); #endif } } else { catToGamma(tr, adef); #ifdef _WAYNE_MPI for(i = 0; i < n; i++) { j = i + n*processID; rl->t[j]->likelihood = unlikely; } #else for(i = 0; i < n; i++) rl->t[i]->likelihood = unlikely; #endif initModel(tr, rdta, cdta, adef); restoreTL(rl, tr, best); resetBranches(tr); evaluateGenericInitrav(tr, tr->start); modOpt(tr, adef, TRUE, adef->likelihoodEpsilon); tr->likelihoods[best] = tr->likelihood; bestLH = tr->likelihood; saveTL(rl, tr, best); tr->treeID = best; printResult(tr, adef, TRUE); newBest = best; for(i = 0; i < n; i++) { #ifdef _WAYNE_MPI j = i + n*processID; if(j != best) { restoreTL(rl, tr, j); resetBranches(tr); evaluateGenericInitrav(tr, tr->start); treeEvaluate(tr, 2); tr->likelihoods[j] = tr->likelihood; if(tr->likelihood > bestLH) { newBest = j; bestLH = tr->likelihood; saveTL(rl, tr, j); } tr->treeID = j; printResult(tr, adef, TRUE); } if(n == 1 && processes == 1) printBothOpen("Inference[%d] final GAMMA-based Likelihood: %f tree written to file %s\n", i, tr->likelihoods[i], resultFileName); else printBothOpen("Inference[%d] final GAMMA-based Likelihood: %f tree written to file %s.RUN.%d\n", j, tr->likelihoods[j], resultFileName, j); #else if(i != best) { restoreTL(rl, tr, i); resetBranches(tr); evaluateGenericInitrav(tr, tr->start); treeEvaluate(tr, 2); tr->likelihoods[i] = tr->likelihood; if(tr->likelihood > bestLH) { newBest = i; bestLH = tr->likelihood; saveTL(rl, tr, i); } tr->treeID = i; printResult(tr, adef, TRUE); } if(n == 1) printBothOpen("Inference[%d] final GAMMA-based Likelihood: %f tree written to file %s\n", i, tr->likelihoods[i], resultFileName); else printBothOpen("Inference[%d] final GAMMA-based Likelihood: %f tree written to file %s.RUN.%d\n", i, tr->likelihoods[i], resultFileName, i); #endif } } assert(newBest >= 0); #ifdef _WAYNE_MPI if(processes > 1) { double *buffer = (double *)rax_malloc(sizeof(double) * processes); for(i = 0; i < processes; i++) buffer[i] = unlikely; buffer[processID] = bestLH; for(i = 0; i < processes; i++) MPI_Bcast(&buffer[i], 1, MPI_DOUBLE, i, MPI_COMM_WORLD); bestLH = buffer[0]; bestProcess = 0; for(i = 1; i < processes; i++) if(buffer[i] > bestLH) { bestLH = buffer[i]; bestProcess = i; } rax_free(buffer); } if(processID == bestProcess) { #endif restoreTL(rl, tr, newBest); evaluateGenericInitrav(tr, tr->start); printBothOpen("\n\nStarting final GAMMA-based thorough Optimization on tree %d likelihood %f .... \n\n", newBest, tr->likelihoods[newBest]); Thorough = 1; tr->doCutoff = FALSE; treeOptimizeThorough(tr, 1, 10); evaluateGenericInitrav(tr, tr->start); printBothOpen("Final GAMMA-based Score of best tree %f\n\n", tr->likelihood); strcpy(bestTreeFileName, workdir); strcat(bestTreeFileName, "RAxML_bestTree."); strcat(bestTreeFileName, run_id); Tree2String(tr->tree_string, tr, tr->start->back, TRUE, TRUE, FALSE, FALSE, TRUE, adef, SUMMARIZE_LH, FALSE, FALSE, FALSE, FALSE); f = myfopen(bestTreeFileName, "wb"); fprintf(f, "%s", tr->tree_string); fclose(f); if(adef->perGeneBranchLengths) printTreePerGene(tr, adef, bestTreeFileName, "w"); #ifdef _WAYNE_MPI } #endif } if(adef->rellBootstrap) { //WARNING the functions below need to be invoked after all other trees have been printed //don't move this part of the code further up! int i; #ifdef _WAYNE_MPI FILE *f = myfopen(rellBootstrapFileNamePID, "wb"); #else FILE *f = myfopen(rellBootstrapFileName, "wb"); #endif for(i = 0; i < NUM_RELL_BOOTSTRAPS; i++) { restoreTreeList(tr->rellTrees, tr, i); Tree2String(tr->tree_string, tr, tr->start->back, FALSE, TRUE, FALSE, FALSE, TRUE, adef, SUMMARIZE_LH, FALSE, FALSE, FALSE, FALSE); fprintf(f, "%s", tr->tree_string); } freeTreeList(tr->rellTrees); rax_free(tr->rellTrees); rax_free(tr->resample); fclose(f); #ifdef _WAYNE_MPI MPI_Barrier(MPI_COMM_WORLD); concatenateBSFiles(processes, rellBootstrapFileName); removeBSFiles(processes, rellBootstrapFileName); MPI_Barrier(MPI_COMM_WORLD); if(processID == 0) printBothOpen("\nRELL bootstraps written to file %s\n", rellBootstrapFileName); #else printBothOpen("\nRELL bootstraps written to file %s\n", rellBootstrapFileName); #endif } #ifdef _WAYNE_MPI if(processID == bestProcess) { #endif overallTime = gettime() - masterTime; printBothOpen("Program execution info written to %s\n", infoFileName); if(!tr->catOnly) { printBothOpen("Best-scoring ML tree written to: %s\n\n", bestTreeFileName); if(adef->perGeneBranchLengths && tr->NumberOfModels > 1) printBothOpen("Per-Partition branch lengths of best-scoring ML tree written to %s.PARTITION.0 to %s.PARTITION.%d\n\n", bestTreeFileName, bestTreeFileName, tr->NumberOfModels - 1); } printBothOpen("Overall execution time: %f secs or %f hours or %f days\n\n", overallTime, overallTime/3600.0, overallTime/86400.0); #ifdef _WAYNE_MPI } #endif if(!tr->catOnly) { freeTL(rl); rax_free(rl); } #ifdef _WAYNE_MPI MPI_Finalize(); #endif exit(0); }
void doAllInOne(tree *tr, analdef *adef) { int i, n, bestIndex, bootstrapsPerformed; #ifdef _WAYNE_MPI int bootStopTests = 1, j, bootStrapsPerProcess = 0; #endif double loopTime; int *originalRateCategories; int *originalInvariant; #ifdef _WAYNE_MPI int slowSearches, fastEvery; #else int slowSearches, fastEvery = 5; #endif int treeVectorLength = -1; topolRELL_LIST *rl; double bestLH, mlTime, overallTime; long radiusSeed = adef->rapidBoot; FILE *f; char bestTreeFileName[1024]; hashtable *h = (hashtable*)NULL; unsigned int **bitVectors = (unsigned int**)NULL; boolean bootStopIt = FALSE; double pearsonAverage = 0.0; pInfo *catParams = allocParams(tr); pInfo *gammaParams = allocParams(tr); unsigned int vLength; n = adef->multipleRuns; #ifdef _WAYNE_MPI if(n % processes != 0) n = processes * ((n / processes) + 1); #endif if(adef->bootStopping) { h = initHashTable(tr->mxtips * 100); treeVectorLength = adef->multipleRuns; bitVectors = initBitVector(tr, &vLength); } rl = (topolRELL_LIST *)rax_malloc(sizeof(topolRELL_LIST)); initTL(rl, tr, n); originalRateCategories = (int*)rax_malloc(tr->cdta->endsite * sizeof(int)); originalInvariant = (int*)rax_malloc(tr->cdta->endsite * sizeof(int)); initModel(tr, tr->rdta, tr->cdta, adef); if(adef->grouping) printBothOpen("\n\nThe topologies of all Bootstrap and ML trees will adhere to the constraint tree specified in %s\n", tree_file); if(adef->constraint) printBothOpen("\n\nThe topologies of all Bootstrap and ML trees will adhere to the bifurcating backbone constraint tree specified in %s\n", tree_file); #ifdef _WAYNE_MPI long parsimonySeed0 = adef->parsimonySeed; long replicateSeed0 = adef->rapidBoot; n = n / processes; #endif for(i = 0; i < n && !bootStopIt; i++) { #ifdef _WAYNE_MPI j = i + n * processID; tr->treeID = j; #else tr->treeID = i; #endif tr->checkPointCounter = 0; loopTime = gettime(); #ifdef _WAYNE_MPI if(i == 0) { if(parsimonySeed0 != 0) adef->parsimonySeed = parsimonySeed0 + 10000 * processID; adef->rapidBoot = replicateSeed0 + 10000 * processID; radiusSeed = adef->rapidBoot; } #endif if(i % 10 == 0) { if(i > 0) reductionCleanup(tr, originalRateCategories, originalInvariant); if(adef->grouping || adef->constraint) { FILE *f = myfopen(tree_file, "rb"); assert(adef->restart); if (! treeReadLenMULT(f, tr, adef)) exit(-1); fclose(f); } else makeParsimonyTree(tr, adef); tr->likelihood = unlikely; if(i == 0) { double t; onlyInitrav(tr, tr->start); treeEvaluate(tr, 1); t = gettime(); modOpt(tr, adef, FALSE, 5.0); #ifdef _WAYNE_MPI printBothOpen("\nTime for BS model parameter optimization on Process %d: %f seconds\n", processID, gettime() - t); #else printBothOpen("\nTime for BS model parameter optimization %f\n", gettime() - t); #endif memcpy(originalRateCategories, tr->cdta->rateCategory, sizeof(int) * tr->cdta->endsite); memcpy(originalInvariant, tr->invariant, sizeof(int) * tr->cdta->endsite); if(adef->bootstrapBranchLengths) { if(tr->rateHetModel == CAT) { copyParams(tr->NumberOfModels, catParams, tr->partitionData, tr); assert(tr->cdta->endsite == tr->originalCrunchedLength); catToGamma(tr, adef); modOpt(tr, adef, TRUE, adef->likelihoodEpsilon); copyParams(tr->NumberOfModels, gammaParams, tr->partitionData, tr); gammaToCat(tr); copyParams(tr->NumberOfModels, tr->partitionData, catParams, tr); } else { assert(tr->cdta->endsite == tr->originalCrunchedLength); } } } } computeNextReplicate(tr, &adef->rapidBoot, originalRateCategories, originalInvariant, TRUE, TRUE); resetBranches(tr); evaluateGenericInitrav(tr, tr->start); treeEvaluate(tr, 1); computeBOOTRAPID(tr, adef, &radiusSeed); #ifdef _WAYNE_MPI saveTL(rl, tr, j); #else saveTL(rl, tr, i); #endif if(adef->bootstrapBranchLengths) { double lh = tr->likelihood; if(tr->rateHetModel == CAT) { copyParams(tr->NumberOfModels, tr->partitionData, gammaParams, tr); catToGamma(tr, adef); resetBranches(tr); onlyInitrav(tr, tr->start); treeEvaluate(tr, 2.0); gammaToCat(tr); copyParams(tr->NumberOfModels, tr->partitionData, catParams, tr); tr->likelihood = lh; } else { treeEvaluate(tr, 2.0); tr->likelihood = lh; } } printBootstrapResult(tr, adef, TRUE); loopTime = gettime() - loopTime; writeInfoFile(adef, tr, loopTime); if(adef->bootStopping) #ifdef _WAYNE_MPI { int nn = (i + 1) * processes; if((nn > START_BSTOP_TEST) && (i * processes < FC_SPACING * bootStopTests) && ((i + 1) * processes >= FC_SPACING * bootStopTests) ) { MPI_Barrier(MPI_COMM_WORLD); concatenateBSFiles(processes, bootstrapFileName); MPI_Barrier(MPI_COMM_WORLD); bootStopIt = computeBootStopMPI(tr, bootstrapFileName, adef, &pearsonAverage); bootStopTests++; } } #else bootStopIt = bootStop(tr, h, i, &pearsonAverage, bitVectors, treeVectorLength, vLength, adef); #endif } #ifdef _WAYNE_MPI MPI_Barrier(MPI_COMM_WORLD); bootstrapsPerformed = i * processes; bootStrapsPerProcess = i; concatenateBSFiles(processes, bootstrapFileName); removeBSFiles(processes, bootstrapFileName); MPI_Barrier(MPI_COMM_WORLD); #else bootstrapsPerformed = i; #endif rax_freeParams(tr->NumberOfModels, catParams); rax_free(catParams); rax_freeParams(tr->NumberOfModels, gammaParams); rax_free(gammaParams); if(adef->bootStopping) { freeBitVectors(bitVectors, 2 * tr->mxtips); rax_free(bitVectors); freeHashTable(h); rax_free(h); } { double t; printBothOpenMPI("\n\n"); if(adef->bootStopping) { if(bootStopIt) { switch(tr->bootStopCriterion) { case FREQUENCY_STOP: printBothOpenMPI("Stopped Rapid BS search after %d replicates with FC Bootstopping criterion\n", bootstrapsPerformed); printBothOpenMPI("Pearson Average of %d random splits: %f\n",BOOTSTOP_PERMUTATIONS , pearsonAverage); break; case MR_STOP: printBothOpenMPI("Stopped Rapid BS search after %d replicates with MR-based Bootstopping criterion\n", bootstrapsPerformed); printBothOpenMPI("WRF Average of %d random splits: %f\n", BOOTSTOP_PERMUTATIONS, pearsonAverage); break; case MRE_STOP: printBothOpenMPI("Stopped Rapid BS search after %d replicates with MRE-based Bootstopping criterion\n", bootstrapsPerformed); printBothOpenMPI("WRF Average of %d random splits: %f\n", BOOTSTOP_PERMUTATIONS, pearsonAverage); break; case MRE_IGN_STOP: printBothOpenMPI("Stopped Rapid BS search after %d replicates with MRE_IGN-based Bootstopping criterion\n", bootstrapsPerformed); printBothOpenMPI("WRF Average of %d random splits: %f\n", BOOTSTOP_PERMUTATIONS, pearsonAverage); break; default: assert(0); } } else { switch(tr->bootStopCriterion) { case FREQUENCY_STOP: printBothOpenMPI("Rapid BS search did not converge after %d replicates with FC Bootstopping criterion\n", bootstrapsPerformed); printBothOpenMPI("Pearson Average of %d random splits: %f\n",BOOTSTOP_PERMUTATIONS , pearsonAverage); break; case MR_STOP: printBothOpenMPI("Rapid BS search did not converge after %d replicates with MR-based Bootstopping criterion\n", bootstrapsPerformed); printBothOpenMPI("WRF Average of %d random splits: %f\n", BOOTSTOP_PERMUTATIONS, pearsonAverage); break; case MRE_STOP: printBothOpenMPI("Rapid BS search did not converge after %d replicates with MRE-based Bootstopping criterion\n", bootstrapsPerformed); printBothOpenMPI("WRF Average of %d random splits: %f\n", BOOTSTOP_PERMUTATIONS, pearsonAverage); break; case MRE_IGN_STOP: printBothOpenMPI("Rapid BS search did not converge after %d replicates with MR_IGN-based Bootstopping criterion\n", bootstrapsPerformed); printBothOpenMPI("WRF Average of %d random splits: %f\n", BOOTSTOP_PERMUTATIONS, pearsonAverage); break; default: assert(0); } } } t = gettime() - masterTime; printBothOpenMPI("Overall Time for %d Rapid Bootstraps %f seconds\n", bootstrapsPerformed, t); printBothOpenMPI("Average Time per Rapid Bootstrap %f seconds\n", (double)(t/((double)bootstrapsPerformed))); if(!adef->allInOne) { printBothOpenMPI("All %d bootstrapped trees written to: %s\n", bootstrapsPerformed, bootstrapFileName); #ifdef _WAYNE_MPI MPI_Finalize(); #endif exit(0); } } /* ML-search */ mlTime = gettime(); double t = mlTime; printBothOpenMPI("\nStarting ML Search ...\n\n"); /***CLEAN UP reduction stuff */ reductionCleanup(tr, originalRateCategories, originalInvariant); /****/ #ifdef _WAYNE_MPI restoreTL(rl, tr, n * processID); #else restoreTL(rl, tr, 0); #endif resetBranches(tr); evaluateGenericInitrav(tr, tr->start); modOpt(tr, adef, TRUE, adef->likelihoodEpsilon); #ifdef _WAYNE_MPI if(bootstrapsPerformed <= 100) fastEvery = 5; else fastEvery = bootstrapsPerformed / 20; for(i = 0; i < bootstrapsPerformed; i++) rl->t[i]->likelihood = unlikely; for(i = 0; i < bootStrapsPerProcess; i++) { j = i + n * processID; if(i % fastEvery == 0) { restoreTL(rl, tr, j); resetBranches(tr); evaluateGenericInitrav(tr, tr->start); treeEvaluate(tr, 1); optimizeRAPID(tr, adef); saveTL(rl, tr, j); } } #else for(i = 0; i < bootstrapsPerformed; i++) { rl->t[i]->likelihood = unlikely; if(i % fastEvery == 0) { restoreTL(rl, tr, i); resetBranches(tr); evaluateGenericInitrav(tr, tr->start); treeEvaluate(tr, 1); optimizeRAPID(tr, adef); saveTL(rl, tr, i); } } #endif printBothOpenMPI("Fast ML optimization finished\n\n"); t = gettime() - t; #ifdef _WAYNE_MPI printBothOpen("Fast ML search on Process %d: Time %f seconds\n\n", processID, t); j = n * processID; qsort(&(rl->t[j]), n, sizeof(topolRELL*), compareTopolRell); restoreTL(rl, tr, j); #else printBothOpen("Fast ML search Time: %f seconds\n\n", t); qsort(&(rl->t[0]), bootstrapsPerformed, sizeof(topolRELL*), compareTopolRell); restoreTL(rl, tr, 0); #endif t = gettime(); resetBranches(tr); evaluateGenericInitrav(tr, tr->start); modOpt(tr, adef, TRUE, adef->likelihoodEpsilon); slowSearches = bootstrapsPerformed / 5; if(bootstrapsPerformed % 5 != 0) slowSearches++; slowSearches = MIN(slowSearches, 10); #ifdef _WAYNE_MPI if(processes > 1) { if(slowSearches % processes == 0) slowSearches = slowSearches / processes; else slowSearches = (slowSearches / processes) + 1; } for(i = 0; i < slowSearches; i++) { j = i + n * processID; restoreTL(rl, tr, j); rl->t[j]->likelihood = unlikely; evaluateGenericInitrav(tr, tr->start); treeEvaluate(tr, 1.0); thoroughOptimization(tr, adef, rl, j); } #else for(i = 0; i < slowSearches; i++) { restoreTL(rl, tr, i); rl->t[i]->likelihood = unlikely; evaluateGenericInitrav(tr, tr->start); treeEvaluate(tr, 1.0); thoroughOptimization(tr, adef, rl, i); } #endif /*************************************************************************************************************/ if(tr->rateHetModel == CAT) { catToGamma(tr, adef); modOpt(tr, adef, TRUE, adef->likelihoodEpsilon); } bestIndex = -1; bestLH = unlikely; #ifdef _WAYNE_MPI for(i = 0; i < slowSearches; i++) { j = i + n * processID; restoreTL(rl, tr, j); resetBranches(tr); evaluateGenericInitrav(tr, tr->start); treeEvaluate(tr, 2); printBothOpen("Slow ML Search %d Likelihood: %f\n", j, tr->likelihood); if(tr->likelihood > bestLH) { bestLH = tr->likelihood; bestIndex = j; } } /*printf("processID = %d, bestIndex = %d; bestLH = %f\n", processID, bestIndex, bestLH);*/ #else for(i = 0; i < slowSearches; i++) { restoreTL(rl, tr, i); resetBranches(tr); evaluateGenericInitrav(tr, tr->start); treeEvaluate(tr, 2); printBothOpen("Slow ML Search %d Likelihood: %f\n", i, tr->likelihood); if(tr->likelihood > bestLH) { bestLH = tr->likelihood; bestIndex = i; } } #endif printBothOpenMPI("Slow ML optimization finished\n\n"); t = gettime() - t; #ifdef _WAYNE_MPI printBothOpen("Slow ML search on Process %d: Time %f seconds\n", processID, t); #else printBothOpen("Slow ML search Time: %f seconds\n", t); #endif t = gettime(); restoreTL(rl, tr, bestIndex); resetBranches(tr); evaluateGenericInitrav(tr, tr->start); treeEvaluate(tr, 2); Thorough = 1; tr->doCutoff = FALSE; treeOptimizeThorough(tr, 1, 10); evaluateGenericInitrav(tr, tr->start); modOpt(tr, adef, TRUE, adef->likelihoodEpsilon); t = gettime() - t; #ifdef _WAYNE_MPI printBothOpen("Thorough ML search on Process %d: Time %f seconds\n", processID, t); #else printBothOpen("Thorough ML search Time: %f seconds\n", t); #endif #ifdef _WAYNE_MPI bestLH = tr->likelihood; printf("\nprocessID = %d, bestLH = %f\n", processID, bestLH); if(processes > 1) { double *buffer; int bestProcess; buffer = (double *)rax_malloc(sizeof(double) * processes); for(i = 0; i < processes; i++) buffer[i] = unlikely; buffer[processID] = bestLH; for(i = 0; i < processes; i++) MPI_Bcast(&buffer[i], 1, MPI_DOUBLE, i, MPI_COMM_WORLD); bestLH = buffer[0]; bestProcess = 0; for(i = 1; i < processes; i++) if(buffer[i] > bestLH) { bestLH = buffer[i]; bestProcess = i; } rax_free(buffer); if(processID != bestProcess) { MPI_Finalize(); exit(0); } } #endif printBothOpen("\nFinal ML Optimization Likelihood: %f\n", tr->likelihood); printBothOpen("\nModel Information:\n\n"); printModelParams(tr, adef); strcpy(bestTreeFileName, workdir); strcat(bestTreeFileName, "RAxML_bestTree."); strcat(bestTreeFileName, run_id); Tree2String(tr->tree_string, tr, tr->start->back, TRUE, TRUE, FALSE, FALSE, TRUE, adef, SUMMARIZE_LH, FALSE, FALSE, FALSE, FALSE); f = myfopen(bestTreeFileName, "wb"); fprintf(f, "%s", tr->tree_string); fclose(f); if(adef->perGeneBranchLengths) printTreePerGene(tr, adef, bestTreeFileName, "w"); overallTime = gettime() - masterTime; mlTime = gettime() - mlTime; printBothOpen("\nML search took %f secs or %f hours\n", mlTime, mlTime / 3600.0); printBothOpen("\nCombined Bootstrap and ML search took %f secs or %f hours\n", overallTime, overallTime / 3600.0); printBothOpen("\nDrawing Bootstrap Support Values on best-scoring ML tree ...\n\n"); freeTL(rl); rax_free(rl); calcBipartitions(tr, adef, bestTreeFileName, bootstrapFileName); overallTime = gettime() - masterTime; printBothOpen("Program execution info written to %s\n", infoFileName); printBothOpen("All %d bootstrapped trees written to: %s\n\n", bootstrapsPerformed, bootstrapFileName); printBothOpen("Best-scoring ML tree written to: %s\n\n", bestTreeFileName); if(adef->perGeneBranchLengths && tr->NumberOfModels > 1) printBothOpen("Per-Partition branch lengths of best-scoring ML tree written to %s.PARTITION.0 to %s.PARTITION.%d\n\n", bestTreeFileName, bestTreeFileName, tr->NumberOfModels - 1); printBothOpen("Best-scoring ML tree with support values written to: %s\n\n", bipartitionsFileName); printBothOpen("Best-scoring ML tree with support values as branch labels written to: %s\n\n", bipartitionsFileNameBranchLabels); printBothOpen("Overall execution time for full ML analysis: %f secs or %f hours or %f days\n\n", overallTime, overallTime/3600.0, overallTime/86400.0); #ifdef _WAYNE_MPI MPI_Finalize(); #endif exit(0); }
void shSupports(tree *tr, analdef *adef, rawdata *rdta, cruncheddata *cdta) { double diff, *lhVectors[3]; char bestTreeFileName[1024], shSupportFileName[1024]; FILE *f; int interchanges = 0, counter = 0; assert(adef->restart); tr->resample = permutationSH(tr, 1000, 12345); lhVectors[0] = (double *)rax_malloc(sizeof(double) * tr->cdta->endsite); lhVectors[1] = (double *)rax_malloc(sizeof(double) * tr->cdta->endsite); lhVectors[2] = (double *)rax_malloc(sizeof(double) * tr->cdta->endsite); tr->bInf = (branchInfo*)rax_malloc(sizeof(branchInfo) * (tr->mxtips - 3)); initModel(tr, rdta, cdta, adef); getStartingTree(tr, adef); if(adef->useBinaryModelFile) { readBinaryModel(tr); evaluateGenericInitrav(tr, tr->start); treeEvaluate(tr, 2); } else modOpt(tr, adef, FALSE, 10.0); printBothOpen("Time after model optimization: %f\n", gettime() - masterTime); printBothOpen("Initial Likelihood %f\n\n", tr->likelihood); do { double lh1, lh2; lh1 = tr->likelihood; interchanges = encapsulateNNIs(tr, lhVectors, FALSE); evaluateGeneric(tr, tr->start); lh2 = tr->likelihood; diff = ABS(lh1 - lh2); printBothOpen("NNI interchanges %d Likelihood %f\n", interchanges, tr->likelihood); } while(diff > 0.01); printBothOpen("\nFinal Likelihood of NNI-optimized tree: %f\n\n", tr->likelihood); setupBranchInfo(tr->start->back, tr, &counter); assert(counter == tr->mxtips - 3); interchanges = encapsulateNNIs(tr, lhVectors, TRUE); strcpy(bestTreeFileName, workdir); strcat(bestTreeFileName, "RAxML_fastTree."); strcat(bestTreeFileName, run_id); Tree2String(tr->tree_string, tr, tr->start->back, FALSE, TRUE, FALSE, FALSE, FALSE, adef, SUMMARIZE_LH, FALSE, FALSE); f = myfopen(bestTreeFileName, "wb"); fprintf(f, "%s", tr->tree_string); fclose(f); strcpy(shSupportFileName, workdir); strcat(shSupportFileName, "RAxML_fastTreeSH_Support."); strcat(shSupportFileName, run_id); Tree2String(tr->tree_string, tr, tr->start->back, TRUE, TRUE, FALSE, FALSE, FALSE, adef, SUMMARIZE_LH, FALSE, TRUE); f = myfopen(shSupportFileName, "wb"); fprintf(f, "%s", tr->tree_string); fclose(f); printBothOpen("RAxML NNI-optimized tree written to file: %s\n", bestTreeFileName); printBothOpen("Same tree with SH-like supports written to file: %s\n", shSupportFileName); printBothOpen("Total execution time: %f\n", gettime() - masterTime); exit(0); }
void fastSearch(tree *tr, analdef *adef, rawdata *rdta, cruncheddata *cdta) { double likelihood, startLikelihood, *lhVectors[3]; char bestTreeFileName[1024]; FILE *f; int model; lhVectors[0] = (double *)NULL; lhVectors[1] = (double *)NULL; lhVectors[2] = (double *)NULL; /* initialize model parameters with standard starting values */ initModel(tr, rdta, cdta, adef); printBothOpen("Time after init : %f\n", gettime() - masterTime); /* compute starting tree, either by reading in a tree specified via -t or by building one */ getStartingTree(tr, adef); printBothOpen("Time after init and starting tree: %f\n", gettime() - masterTime); /* rough model parameter optimization, the log likelihood epsilon should actually be determined based on the initial tree score and not be hard-coded */ if(adef->useBinaryModelFile) { readBinaryModel(tr); evaluateGenericInitrav(tr, tr->start); treeEvaluate(tr, 2); } else modOpt(tr, adef, FALSE, 10.0); printBothOpen("Time after init, starting tree, mod opt: %f\n", gettime() - masterTime); /* print out the number of rate categories used for the CAT model, one should use less then the default, e.g., -c 16 works quite well */ for(model = 0; model < tr->NumberOfModels; model++) printBothOpen("Partion %d number of Cats: %d\n", model, tr->partitionData[model].numberOfCategories); /* means that we are going to do thorough insertions with real newton-raphson based br-len opt at the three branches adjactent to every insertion point */ Thorough = 1; /* loop over SPR cycles until the likelihood difference before and after the SPR cycle is <= 0.5 log likelihood units. Rather than being hard-coded this should also be determined based on the actual likelihood of the tree */ do { startLikelihood = tr->likelihood; /* conduct a cycle of linear SPRs */ likelihood = linearSPRs(tr, 20, adef->veryFast); evaluateGeneric(tr, tr->start); /* the NNIs also optimize br-lens of resulting topology a bit */ encapsulateNNIs(tr, lhVectors, FALSE); printBothOpen("LH after SPRs %f, after NNI %f\n", likelihood, tr->likelihood); } while(ABS(tr->likelihood - startLikelihood) > 0.5); /* print out the resulting tree to the RAxML_bestTree. file. note that boosttrapping or doing multiple inferences won't work. This thing computes a single tree and that's it */ strcpy(bestTreeFileName, workdir); strcat(bestTreeFileName, "RAxML_fastTree."); strcat(bestTreeFileName, run_id); Tree2String(tr->tree_string, tr, tr->start->back, FALSE, TRUE, FALSE, FALSE, FALSE, adef, SUMMARIZE_LH, FALSE, FALSE); f = myfopen(bestTreeFileName, "wb"); fprintf(f, "%s", tr->tree_string); fclose(f); printBothOpen("RAxML fast tree written to file: %s\n", bestTreeFileName); writeBinaryModel(tr); printBothOpen("Total execution time: %f\n", gettime() - masterTime); printBothOpen("Good bye ... \n"); }
void computeBIGRAPID (tree *tr, analdef *adef, boolean estimateModel) { unsigned int vLength = 0; int i, impr, bestTrav, rearrangementsMax = 0, rearrangementsMin = 0, thoroughIterations = 0, fastIterations = 0; double lh, previousLh, difference, epsilon; bestlist *bestT, *bt; #ifdef _TERRACES /* store the 20 best trees found in a dedicated list */ bestlist *terrace; /* output file names */ char terraceFileName[1024], buf[64]; #endif hashtable *h = (hashtable*)NULL; unsigned int **bitVectors = (unsigned int**)NULL; if(tr->searchConvergenceCriterion) { bitVectors = initBitVector(tr, &vLength); h = initHashTable(tr->mxtips * 4); } bestT = (bestlist *) rax_malloc(sizeof(bestlist)); bestT->ninit = 0; initBestTree(bestT, 1, tr->mxtips); bt = (bestlist *) rax_malloc(sizeof(bestlist)); bt->ninit = 0; initBestTree(bt, 20, tr->mxtips); #ifdef _TERRACES /* initialize the tree list and the output file name for the current tree search/replicate */ terrace = (bestlist *) rax_malloc(sizeof(bestlist)); terrace->ninit = 0; initBestTree(terrace, 20, tr->mxtips); sprintf(buf, "%d", bCount); strcpy(terraceFileName, workdir); strcat(terraceFileName, "RAxML_terrace."); strcat(terraceFileName, run_id); strcat(terraceFileName, ".BS."); strcat(terraceFileName, buf); printf("%s\n", terraceFileName); #endif initInfoList(50); difference = 10.0; epsilon = 0.01; Thorough = 0; if(estimateModel) { if(adef->useBinaryModelFile) { readBinaryModel(tr); evaluateGenericInitrav(tr, tr->start); treeEvaluate(tr, 2); } else { evaluateGenericInitrav(tr, tr->start); modOpt(tr, adef, FALSE, 10.0); } } else treeEvaluate(tr, 2); printLog(tr, adef, FALSE); saveBestTree(bestT, tr); if(!adef->initialSet) bestTrav = adef->bestTrav = determineRearrangementSetting(tr, adef, bestT, bt); else bestTrav = adef->bestTrav = adef->initial; if(estimateModel) { if(adef->useBinaryModelFile) treeEvaluate(tr, 2); else { evaluateGenericInitrav(tr, tr->start); modOpt(tr, adef, FALSE, 5.0); } } else treeEvaluate(tr, 1); saveBestTree(bestT, tr); impr = 1; if(tr->doCutoff) tr->itCount = 0; while(impr) { recallBestTree(bestT, 1, tr); if(tr->searchConvergenceCriterion) { int bCounter = 0; if(fastIterations > 1) cleanupHashTable(h, (fastIterations % 2)); bitVectorInitravSpecial(bitVectors, tr->nodep[1]->back, tr->mxtips, vLength, h, fastIterations % 2, BIPARTITIONS_RF, (branchInfo *)NULL, &bCounter, 1, FALSE, FALSE); assert(bCounter == tr->mxtips - 3); if(fastIterations > 0) { double rrf = convergenceCriterion(h, tr->mxtips); if(rrf <= 0.01) /* 1% cutoff */ { printBothOpen("ML fast search converged at fast SPR cycle %d with stopping criterion\n", fastIterations); printBothOpen("Relative Robinson-Foulds (RF) distance between respective best trees after one succseful SPR cycle: %f%s\n", rrf, "%"); cleanupHashTable(h, 0); cleanupHashTable(h, 1); goto cleanup_fast; } else printBothOpen("ML search convergence criterion fast cycle %d->%d Relative Robinson-Foulds %f\n", fastIterations - 1, fastIterations, rrf); } } fastIterations++; treeEvaluate(tr, 1.0); saveBestTree(bestT, tr); printLog(tr, adef, FALSE); printResult(tr, adef, FALSE); lh = previousLh = tr->likelihood; treeOptimizeRapid(tr, 1, bestTrav, adef, bt); impr = 0; for(i = 1; i <= bt->nvalid; i++) { recallBestTree(bt, i, tr); treeEvaluate(tr, 0.25); difference = ((tr->likelihood > previousLh)? tr->likelihood - previousLh: previousLh - tr->likelihood); if(tr->likelihood > lh && difference > epsilon) { impr = 1; lh = tr->likelihood; saveBestTree(bestT, tr); } } } if(tr->searchConvergenceCriterion) { cleanupHashTable(h, 0); cleanupHashTable(h, 1); } cleanup_fast: Thorough = 1; impr = 1; recallBestTree(bestT, 1, tr); if(estimateModel) { if(adef->useBinaryModelFile) treeEvaluate(tr, 2); else { evaluateGenericInitrav(tr, tr->start); modOpt(tr, adef, FALSE, 1.0); } } else treeEvaluate(tr, 1.0); while(1) { recallBestTree(bestT, 1, tr); if(impr) { printResult(tr, adef, FALSE); rearrangementsMin = 1; rearrangementsMax = adef->stepwidth; if(tr->searchConvergenceCriterion) { int bCounter = 0; if(thoroughIterations > 1) cleanupHashTable(h, (thoroughIterations % 2)); bitVectorInitravSpecial(bitVectors, tr->nodep[1]->back, tr->mxtips, vLength, h, thoroughIterations % 2, BIPARTITIONS_RF, (branchInfo *)NULL, &bCounter, 1, FALSE, FALSE); assert(bCounter == tr->mxtips - 3); if(thoroughIterations > 0) { double rrf = convergenceCriterion(h, tr->mxtips); if(rrf <= 0.01) /* 1% cutoff */ { printBothOpen("ML search converged at thorough SPR cycle %d with stopping criterion\n", thoroughIterations); printBothOpen("Relative Robinson-Foulds (RF) distance between respective best trees after one succseful SPR cycle: %f%s\n", rrf, "%"); goto cleanup; } else printBothOpen("ML search convergence criterion thorough cycle %d->%d Relative Robinson-Foulds %f\n", thoroughIterations - 1, thoroughIterations, rrf); } } thoroughIterations++; } else { rearrangementsMax += adef->stepwidth; rearrangementsMin += adef->stepwidth; if(rearrangementsMax > adef->max_rearrange) goto cleanup; } treeEvaluate(tr, 1.0); previousLh = lh = tr->likelihood; saveBestTree(bestT, tr); printLog(tr, adef, FALSE); treeOptimizeRapid(tr, rearrangementsMin, rearrangementsMax, adef, bt); impr = 0; for(i = 1; i <= bt->nvalid; i++) { recallBestTree(bt, i, tr); treeEvaluate(tr, 0.25); #ifdef _TERRACES /* save all 20 best trees in the terrace tree list */ saveBestTree(terrace, tr); #endif difference = ((tr->likelihood > previousLh)? tr->likelihood - previousLh: previousLh - tr->likelihood); if(tr->likelihood > lh && difference > epsilon) { impr = 1; lh = tr->likelihood; saveBestTree(bestT, tr); } } } cleanup: #ifdef _TERRACES { double bestLH = tr->likelihood; FILE *f = myfopen(terraceFileName, "w"); /* print out likelihood of best tree found */ printf("best tree: %f\n", tr->likelihood); /* print out likelihoods of 20 best trees found during the tree search */ for(i = 1; i <= terrace->nvalid; i++) { recallBestTree(terrace, i, tr); /* if the likelihood scores are smaller than some epsilon 0.000001 print the tree to file */ if(ABS(bestLH - tr->likelihood) < 0.000001) { printf("%d %f\n", i, tr->likelihood); Tree2String(tr->tree_string, tr, tr->start->back, FALSE, TRUE, FALSE, FALSE, FALSE, adef, NO_BRANCHES, FALSE, FALSE, FALSE, FALSE); fprintf(f, "%s\n", tr->tree_string); } } fclose(f); /* increment tree search counter */ bCount++; } #endif if(tr->searchConvergenceCriterion) { freeBitVectors(bitVectors, 2 * tr->mxtips); rax_free(bitVectors); freeHashTable(h); rax_free(h); } freeBestTree(bestT); rax_free(bestT); freeBestTree(bt); rax_free(bt); #ifdef _TERRACES /* free terrace tree list */ freeBestTree(terrace); rax_free(terrace); #endif freeInfoList(); printLog(tr, adef, FALSE); printResult(tr, adef, FALSE); }
void mcmc(tree *tr, analdef *adef) { int i=0; tr->startLH = tr->likelihood; printBothOpen("start minimalistic search with LH %f\n", tr->likelihood); printBothOpen("tr LH %f, startLH %f\n", tr->likelihood, tr->startLH); int insert_id; int j; int maxradius = 30; int accepted_spr = 0, accepted_nni = 0, accepted_bl = 0, accepted_model = 0, accepted_gamma = 0, inserts = 0; int rejected_spr = 0, rejected_nni = 0, rejected_bl = 0, rejected_model = 0, rejected_gamma = 0; int num_moves = 10000; boolean proposalAccepted; boolean proposalSuccess; prop which_proposal; double testr; double acceptance; srand (440); double totalTime = 0.0, proposalTime = 0.0, blTime = 0.0, printTime = 0.0; double t_start = gettime(); double t; //allocate states double bl_prior_exp_lambda = 0.1; double bl_sliding_window_w = 0.005; double gm_sliding_window_w = 0.75; double rt_sliding_window_w = 0.5; state *curstate = state_init(tr, adef, maxradius, bl_sliding_window_w, rt_sliding_window_w, gm_sliding_window_w, bl_prior_exp_lambda); printStateFileHeader(curstate); set_start_bl(curstate); printf("start bl_prior: %f\n",curstate->bl_prior); set_start_prior(curstate); curstate->hastings = 1;//needs to be set by the proposal when necessary /* Set the starting LH with a full traversal */ evaluateGeneric(tr, tr->start, TRUE); tr->startLH = tr->likelihood; printBothOpen("Starting with tr LH %f, startLH %f\n", j, tr->likelihood, tr->startLH); /* Set reasonable model parameters */ evaluateGeneric(curstate->tr, curstate->tr->start, FALSE); // just for validation printBothOpen("tr LH before modOpt %f\n",curstate->tr->likelihood); printSubsRates(curstate->tr, curstate->model, curstate->numSubsRates); /* optimize the model with Brents method for reasonable starting points */ modOpt(curstate->tr, curstate->adef, 5.0); /* not by proposal, just using std raxml machinery... */ evaluateGeneric(curstate->tr, curstate->tr->start, FALSE); // just for validation printBothOpen("tr LH after modOpt %f\n",curstate->tr->likelihood); printSubsRates(curstate->tr, curstate->model, curstate->numSubsRates); recordSubsRates(curstate->tr, curstate->model, curstate->numSubsRates, curstate->curSubsRates); int first = 1; /* beginning of the MCMC chain */ for(j=0; j<num_moves; j++) { //printBothOpen("iter %d, tr LH %f, startLH %f\n",j, tr->likelihood, tr->startLH); //printRecomTree(tr, TRUE, "startiter"); proposalAccepted = FALSE; t = gettime(); /* evaluateGeneric(tr, tr->start); // just for validation printBothOpen("before proposal, iter %d tr LH %f, startLH %f\n", j, tr->likelihood, tr->startLH); */ which_proposal = proposal(curstate); if (first == 1) { first = 0; curstate->curprior = curstate->newprior; } //printBothOpen("proposal done, iter %d tr LH %f, startLH %f\n", j, tr->likelihood, tr->startLH); assert(which_proposal == SPR || which_proposal == stNNI || which_proposal == UPDATE_ALL_BL || which_proposal == UPDATE_MODEL || which_proposal == UPDATE_GAMMA); proposalTime += gettime() - t; /* decide upon acceptance */ testr = (double)rand()/(double)RAND_MAX; //should look something like acceptance = fmin(1,(curstate->hastings) * (exp(curstate->newprior-curstate->curprior)) * (exp(curstate->tr->likelihood-curstate->tr->startLH))); /* //printRecomTree(tr, FALSE, "after proposal"); printBothOpen("after proposal, iter %d tr LH %f, startLH %f\n", j, tr->likelihood, tr->startLH); */ if(testr < acceptance) { proposalAccepted = TRUE; switch(which_proposal) { case SPR: //printRecomTree(tr, TRUE, "after accepted"); // printBothOpen("SPR new topology , iter %d tr LH %f, startLH %f\n", j, tr->likelihood, tr->startLH); accepted_spr++; break; case stNNI: printBothOpen("NNI new topology , iter %d tr LH %f, startLH %f\n", j, tr->likelihood, tr->startLH); accepted_nni++; break; case UPDATE_ALL_BL: // printBothOpen("BL new , iter %d tr LH %f, startLH %f\n", j, tr->likelihood, tr->startLH); accepted_bl++; break; case UPDATE_MODEL: // printBothOpen("Model new, iter %d tr LH %f, startLH %f\n", j, tr->likelihood, tr->startLH); accepted_model++; break; case UPDATE_GAMMA: // printBothOpen("Gamma new, iter %d tr LH %f, startLH %f\n", j, tr->likelihood, tr->startLH); accepted_gamma++; break; default: assert(0); } curstate->tr->startLH = curstate->tr->likelihood; //new LH curstate->curprior = curstate->newprior; } else { //printBothOpen("rejected , iter %d tr LH %f, startLH %f, %i \n", j, tr->likelihood, tr->startLH, which_proposal); resetState(which_proposal,curstate); switch(which_proposal) { case SPR: rejected_spr++; break; case stNNI: rejected_nni++; break; case UPDATE_ALL_BL: rejected_bl++; break; case UPDATE_MODEL: rejected_model++; break; case UPDATE_GAMMA: rejected_gamma++; break; default: assert(0); } evaluateGeneric(tr, tr->start, FALSE); // just for validation if(fabs(curstate->tr->startLH - tr->likelihood) > 1.0E-10) { printBothOpen("WARNING: LH diff %.10f\n", curstate->tr->startLH - tr->likelihood); } //printRecomTree(tr, TRUE, "after reset"); //printBothOpen("after reset, iter %d tr LH %f, startLH %f\n", j, tr->likelihood, tr->startLH); assert(fabs(curstate->tr->startLH - tr->likelihood) < 1.0E-10); } inserts++; /* need to print status */ if (j % 50 == 0) { t = gettime(); printBothOpen("sampled at iter %d, tr LH %f, startLH %f, prior %f, incr %f\n",j, tr->likelihood, tr->startLH, curstate->curprior, tr->likelihood - tr->startLH); boolean printBranchLengths = TRUE; /*printSimpleTree(tr, printBranchLengths, adef);*/ //TODO: print some parameters to a file printStateFile(j,curstate); printTime += gettime() - t; } } t = gettime(); treeEvaluate(tr, 1); blTime += gettime() - t; printBothOpen("accepted SPR %d, accepted stNNI %d, accepted BL %d, accepted model %d, accepted gamma %d, num moves tried %d, SPRs with max radius %d\n", accepted_spr, accepted_nni, accepted_bl, accepted_model, accepted_gamma, num_moves, maxradius); printBothOpen("rejected SPR %d, rejected stNNI %d, rejected BL %d, rejected model %d, rejected gamma %d\n", rejected_spr, rejected_nni, rejected_bl, rejected_model, rejected_gamma); printBothOpen("ratio SPR %f, ratio stNNI %f, ratio BL %f, ratio model %f, ratio gamma %f\n", accepted_spr/(double)(rejected_spr+accepted_spr), accepted_nni/(double)(rejected_nni+accepted_nni), accepted_bl/(double)(rejected_bl+accepted_bl), accepted_model/(double)(rejected_model+accepted_model), accepted_gamma/(double)(rejected_gamma+accepted_gamma)); printBothOpen("total %f, BL %f, printing %f, proposal %f\n", gettime()- t_start, blTime, printTime, proposalTime); assert(inserts == num_moves); state_free(curstate); }
static void computeAllLHs(tree *tr, analdef *adef, char *bootStrapFileName) { int numberOfTrees = 0, i; char ch; double bestLH = unlikely; bestlist *bestT; FILE *infoFile, *result; infoFile = fopen(infoFileName, "a"); result = fopen(resultFileName, "w"); bestT = (bestlist *) malloc(sizeof(bestlist)); bestT->ninit = 0; initBestTree(bestT, 1, tr->mxtips); allocNodex(tr, adef); INFILE = fopen(bootStrapFileName, "r"); while((ch = getc(INFILE)) != EOF) { if(ch == ';') numberOfTrees++; } rewind(INFILE); printf("\n\nFound %d trees in File %s\n\n", numberOfTrees, bootStrapFileName); fprintf(infoFile, "\n\nBB Found %d trees in File %s\n\n", numberOfTrees, bootStrapFileName); for(i = 0; i < numberOfTrees; i++) { treeReadLen(INFILE, tr, adef); if(i == 0) { modOpt(tr, adef); printf("Model optimization, first Tree: %f\n", tr->likelihood); fprintf(infoFile, "Model optimization, first Tree: %f\n", tr->likelihood); bestLH = tr->likelihood; resetBranches(tr); } treeEvaluate(tr, 2); Tree2String(tr->tree_string, tr, tr->start->back, TRUE, TRUE, FALSE, FALSE, TRUE, adef, SUMMARIZE_LH); fprintf(result, "%s", tr->tree_string); saveBestTree(bestT, tr); if(tr->likelihood > bestLH) bestLH = tr->likelihood; printf("Tree %d Likelihood %f\n", i, tr->likelihood); fprintf(infoFile, "Tree %d Likelihood %f\n", i, tr->likelihood); } recallBestTree(bestT, 1, tr); evaluateGeneric(tr, tr->start); printf("Model optimization, %f <-> %f\n", bestLH, tr->likelihood); fprintf(infoFile, "Model optimization, %f <-> %f\n", bestLH, tr->likelihood); modOpt(tr, adef); treeEvaluate(tr, 2); printf("Model optimization, %f <-> %f\n", bestLH, tr->likelihood); fprintf(infoFile, "Model optimization, %f <-> %f\n", bestLH, tr->likelihood); printf("\nAll evaluated trees with branch lengths written to File: %s\n", resultFileName); fprintf(infoFile, "\nAll evaluated trees with branch lengths written to File: %s\n", resultFileName); fclose(INFILE); fclose(infoFile); fclose(result); exit(0); }