int treeOptimizeThorough(tree *tr, int mintrav, int maxtrav)
{
int i;
bestlist *bestT;
nodeRectifier(tr);
bestT = (bestlist *) malloc(sizeof(bestlist));
bestT->ninit = 0;
initBestTree(bestT, 1, tr->mxtips);
if (maxtrav > tr->ntips - 3)
maxtrav = tr->ntips - 3;
tr->startLH = tr->endLH = tr->likelihood;
for(i = 1; i <= tr->mxtips + tr->mxtips - 2; i++)
{
tr->bestOfNode = unlikely;
if(rearrangeBIG(tr, tr->nodep[i], mintrav, maxtrav))
{
if((tr->endLH > tr->startLH) && (tr->bestOfNode != unlikely))
{
restoreTreeFast(tr);
quickSmoothLocal(tr, 3);
tr->startLH = tr->endLH = tr->likelihood;
}
else
{
if(tr->bestOfNode != unlikely)
{
resetBestTree(bestT);
saveBestTree(bestT, tr);
restoreTreeFast(tr);
quickSmoothLocal(tr, 3);
if(tr->likelihood < tr->startLH)
{
int res;
res = recallBestTree(bestT, 1, tr);
assert(res > 0);
}
else
tr->startLH = tr->endLH = tr->likelihood;
}
}
}
}
freeBestTree(bestT);
free(bestT);
return 1;
}
void computeBOOTRAPID (tree *tr, analdef *adef, long *radiusSeed)
{
int i, bestTrav, impr;
double lh, previousLh, difference, epsilon;
bestlist *bestT, *bt;
int countIT;
bestT = (bestlist *) malloc(sizeof(bestlist));
bestT->ninit = 0;
initBestTree(bestT, 1, tr->mxtips);
saveBestTree(bestT, tr);
bt = (bestlist *) malloc(sizeof(bestlist));
bt->ninit = 0;
initBestTree(bt, 5, tr->mxtips);
initInfoList(10);
difference = 10.0;
epsilon = 0.01;
bestTrav = adef->bestTrav = 5 + 11 * randum(radiusSeed);
Thorough = 1;
impr = 1;
if(tr->doCutoff)
tr->itCount = 0;
tr->bigCutoff = TRUE;
for(countIT = 0; countIT < 2 && impr; countIT++)
{
recallBestTree(bestT, 1, tr);
treeEvaluate(tr, 1);
saveBestTree(bestT, tr);
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);
}
}
}
tr->bigCutoff = FALSE;
recallBestTree(bestT, 1, tr);
freeBestTree(bestT);
free(bestT);
freeBestTree(bt);
free(bt);
freeInfoList();
}
void optimizeRAPID(tree *tr, analdef *adef)
{
int i, impr, bestTrav;
double lh, previousLh, difference, epsilon;
bestlist *bestT, *bt;
bestT = (bestlist *) malloc(sizeof(bestlist));
bestT->ninit = 0;
initBestTree(bestT, 1, tr->mxtips);
bt = (bestlist *) malloc(sizeof(bestlist));
bt->ninit = 0;
initBestTree(bt, 20, tr->mxtips);
initInfoList(50);
difference = 10.0;
epsilon = 0.01;
Thorough = 0;
saveBestTree(bestT, tr);
bestTrav = adef->bestTrav = determineRearrangementSetting(tr, adef, bestT, bt);
saveBestTree(bestT, tr);
impr = 1;
if(tr->doCutoff)
tr->itCount = 0;
while(impr)
{
recallBestTree(bestT, 1, tr);
treeEvaluate(tr, 1);
saveBestTree(bestT, tr);
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);
}
}
}
recallBestTree(bestT, 1, tr);
freeBestTree(bestT);
free(bestT);
freeBestTree(bt);
free(bt);
freeInfoList();
}
void thoroughOptimization(tree *tr, analdef *adef, topolRELL_LIST *rl, int index)
{
int i, impr;
int rearrangementsMin = 1, rearrangementsMax = adef->stepwidth;
double lh, previousLh, difference, epsilon;
bestlist *bestT, *bt;
bestT = (bestlist *) malloc(sizeof(bestlist));
bestT->ninit = 0;
initBestTree(bestT, 1, tr->mxtips);
bt = (bestlist *) malloc(sizeof(bestlist));
bt->ninit = 0;
initBestTree(bt, 20, tr->mxtips);
initInfoList(50);
difference = 10.0;
epsilon = 0.01;
saveBestTree(bestT, tr);
impr = 1;
if(tr->doCutoff)
tr->itCount = 0;
Thorough = 1;
impr = 1;
while(1)
{
recallBestTree(bestT, 1, tr);
if(impr)
{
rearrangementsMin = 1;
rearrangementsMax = adef->stepwidth;
}
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);
treeOptimizeRapid(tr, rearrangementsMin, rearrangementsMax, 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);
}
}
}
cleanup:
saveTL(rl, tr, index);
freeBestTree(bestT);
free(bestT);
freeBestTree(bt);
free(bt);
freeInfoList();
}
double treeOptimizeRapid(tree *tr, int mintrav, int maxtrav, analdef *adef, bestlist *bt)
{
int i, index,
*perm = (int*)NULL;
nodeRectifier(tr);
if (maxtrav > tr->ntips - 3)
maxtrav = tr->ntips - 3;
resetInfoList();
resetBestTree(bt);
tr->startLH = tr->endLH = tr->likelihood;
if(tr->doCutoff)
{
if(tr->bigCutoff)
{
if(tr->itCount == 0)
tr->lhCutoff = 0.5 * (tr->likelihood / -1000.0);
else
tr->lhCutoff = 0.5 * ((tr->lhAVG) / ((double)(tr->lhDEC)));
}
else
{
if(tr->itCount == 0)
tr->lhCutoff = tr->likelihood / -1000.0;
else
tr->lhCutoff = (tr->lhAVG) / ((double)(tr->lhDEC));
}
tr->itCount = tr->itCount + 1;
tr->lhAVG = 0;
tr->lhDEC = 0;
}
if(adef->permuteTreeoptimize)
{
int n = tr->mxtips + tr->mxtips - 2;
perm = (int *)rax_malloc(sizeof(int) * (n + 1));
makePermutation(perm, n, adef);
}
for(i = 1; i <= tr->mxtips + tr->mxtips - 2; i++)
{
tr->bestOfNode = unlikely;
if(adef->permuteTreeoptimize)
index = perm[i];
else
index = i;
if(rearrangeBIG(tr, tr->nodep[index], mintrav, maxtrav))
{
if(Thorough)
{
if(tr->endLH > tr->startLH)
{
restoreTreeFast(tr);
tr->startLH = tr->endLH = tr->likelihood;
saveBestTree(bt, tr);
}
else
{
if(tr->bestOfNode != unlikely)
restoreTopologyOnly(tr, bt);
}
}
else
{
insertInfoList(tr->nodep[index], tr->bestOfNode);
if(tr->endLH > tr->startLH)
{
restoreTreeFast(tr);
tr->startLH = tr->endLH = tr->likelihood;
}
}
}
}
if(!Thorough)
{
Thorough = 1;
for(i = 0; i < iList.valid; i++)
{
tr->bestOfNode = unlikely;
if(rearrangeBIG(tr, iList.list[i].node, mintrav, maxtrav))
{
if(tr->endLH > tr->startLH)
{
restoreTreeFast(tr);
tr->startLH = tr->endLH = tr->likelihood;
saveBestTree(bt, tr);
}
else
{
if(tr->bestOfNode != unlikely)
{
restoreTopologyOnly(tr, bt);
}
}
}
}
Thorough = 0;
}
if(adef->permuteTreeoptimize)
rax_free(perm);
return tr->startLH;
}
static void restoreTopologyOnly(tree *tr, bestlist *bt)
{
nodeptr p = tr->removeNode;
nodeptr q = tr->insertNode;
double qz[NUM_BRANCHES], pz[NUM_BRANCHES], p1z[NUM_BRANCHES], p2z[NUM_BRANCHES];
nodeptr p1, p2, r, s;
double currentLH = tr->likelihood;
int i;
p1 = p->next->back;
p2 = p->next->next->back;
for(i = 0; i < tr->numBranches; i++)
{
p1z[i] = p1->z[i];
p2z[i] = p2->z[i];
}
hookup(p1, p2, tr->currentZQR, tr->numBranches);
p->next->next->back = p->next->back = (node *) NULL;
for(i = 0; i < tr->numBranches; i++)
{
qz[i] = q->z[i];
pz[i] = p->z[i];
}
r = q->back;
s = p->back;
if(Thorough)
{
hookup(p->next, q, tr->currentLZQ, tr->numBranches);
hookup(p->next->next, r, tr->currentLZR, tr->numBranches);
hookup(p, s, tr->currentLZS, tr->numBranches);
}
else
{
double z[NUM_BRANCHES];
for(i = 0; i < tr->numBranches; i++)
{
z[i] = sqrt(q->z[i]);
if(z[i] < zmin)
z[i] = zmin;
if(z[i] > zmax)
z[i] = zmax;
}
hookup(p->next, q, z, tr->numBranches);
hookup(p->next->next, r, z, tr->numBranches);
}
tr->likelihood = tr->bestOfNode;
saveBestTree(bt, tr);
tr->likelihood = currentLH;
hookup(q, r, qz, tr->numBranches);
p->next->next->back = p->next->back = (nodeptr) NULL;
if(Thorough)
hookup(p, s, pz, tr->numBranches);
hookup(p->next, p1, p1z, tr->numBranches);
hookup(p->next->next, p2, p2z, tr->numBranches);
}
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);
}
int determineRearrangementSetting(tree *tr, analdef *adef, bestlist *bestT, bestlist *bt)
{
int i, mintrav, maxtrav, bestTrav, impr, index, MaxFast,
*perm = (int*)NULL;
double startLH;
boolean cutoff;
MaxFast = 26;
startLH = tr->likelihood;
cutoff = tr->doCutoff;
tr->doCutoff = FALSE;
mintrav = 1;
maxtrav = 5;
bestTrav = maxtrav = 5;
impr = 1;
resetBestTree(bt);
if(adef->permuteTreeoptimize)
{
int n = tr->mxtips + tr->mxtips - 2;
perm = (int *)rax_malloc(sizeof(int) * (n + 1));
makePermutation(perm, n, adef);
}
while(impr && maxtrav < MaxFast)
{
recallBestTree(bestT, 1, tr);
nodeRectifier(tr);
if (maxtrav > tr->ntips - 3)
maxtrav = tr->ntips - 3;
tr->startLH = tr->endLH = tr->likelihood;
for(i = 1; i <= tr->mxtips + tr->mxtips - 2; i++)
{
if(adef->permuteTreeoptimize)
index = perm[i];
else
index = i;
tr->bestOfNode = unlikely;
if(rearrangeBIG(tr, tr->nodep[index], mintrav, maxtrav))
{
if(tr->endLH > tr->startLH)
{
restoreTreeFast(tr);
tr->startLH = tr->endLH = tr->likelihood;
}
}
}
treeEvaluate(tr, 0.25);
saveBestTree(bt, tr);
/*printf("DETERMINE_BEST: %d %f\n", maxtrav, tr->likelihood);*/
if(tr->likelihood > startLH)
{
startLH = tr->likelihood;
printLog(tr, adef, FALSE);
bestTrav = maxtrav;
impr = 1;
}
else
{
impr = 0;
}
maxtrav += 5;
if(tr->doCutoff)
{
tr->lhCutoff = (tr->lhAVG) / ((double)(tr->lhDEC));
tr->itCount = tr->itCount + 1;
tr->lhAVG = 0;
tr->lhDEC = 0;
}
}
recallBestTree(bt, 1, tr);
tr->doCutoff = cutoff;
if(adef->permuteTreeoptimize)
rax_free(perm);
return bestTrav;
}
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);
}
