nodeptr removeNodeBIG (tree *tr, nodeptr p, int numBranches)
{
double zqr[NUM_BRANCHES], result[NUM_BRANCHES];
nodeptr q, r;
int i;
q = p->next->back;
r = p->next->next->back;
for(i = 0; i < numBranches; i++)
zqr[i] = q->z[i] * r->z[i];
makenewzGeneric(tr, q, r, zqr, iterations, result, FALSE);
for(i = 0; i < numBranches; i++)
tr->zqr[i] = result[i];
hookup(q, r, result, numBranches);
p->next->next->back = p->next->back = (node *) NULL;
return q;
}
void
match_trail(void)
{ int i, a, nst;
Element *dothis;
char snap[512], *q;
/*
* if source model name is leader.pml
* look for the trail file under these names:
* leader.pml.trail
* leader.pml.tra
* leader.trail
* leader.tra
*/
if (ntrail)
sprintf(snap, "%s%d.trail", oFname->name, ntrail);
else
sprintf(snap, "%s.trail", oFname->name);
if ((fd = fopen(snap, "r")) == NULL)
{ snap[strlen(snap)-2] = '\0'; /* .tra */
if ((fd = fopen(snap, "r")) == NULL)
{ if ((q = strchr(oFname->name, '.')) != NULL)
{ *q = '\0';
if (ntrail)
sprintf(snap, "%s%d.trail",
oFname->name, ntrail);
else
sprintf(snap, "%s.trail",
oFname->name);
*q = '.';
if ((fd = fopen(snap, "r")) != NULL)
goto okay;
snap[strlen(snap)-2] = '\0'; /* last try */
if ((fd = fopen(snap, "r")) != NULL)
goto okay;
}
printf("spin: cannot find trail file\n");
alldone(1);
} }
okay:
if (xspin == 0 && newer(oFname->name, snap))
printf("spin: warning, \"%s\" is newer than %s\n",
oFname->name, snap);
Tval = 1;
/*
* sets Tval because timeouts may be part of trail
* this used to also set m_loss to 1, but that is
* better handled with the runtime -m flag
*/
hookup();
while (fscanf(fd, "%d:%d:%d\n", &depth, &pno, &nst) == 3)
{ if (depth == -2) { start_claim(pno); continue; }
if (depth == -4) { merger = 1; ana_src(0, 1); continue; }
if (depth == -1)
{ if (verbose)
{ if (columns == 2)
dotag(stdout, " CYCLE>\n");
else
dotag(stdout, "<<<<<START OF CYCLE>>>>>\n");
}
continue;
}
if (cutoff > 0 && depth >= cutoff)
{ printf("-------------\n");
printf("depth-limit (-u%d steps) reached\n", cutoff);
break;
}
if (Skip_claim && pno == 0) continue;
for (dothis = Al_El; dothis; dothis = dothis->Nxt)
{ if (dothis->Seqno == nst)
break;
}
if (!dothis)
{ printf("%3d: proc %d, no matching stmnt %d\n",
depth, pno - Have_claim, nst);
lost_trail();
}
i = nproc - nstop + Skip_claim;
if (dothis->n->ntyp == '@')
{ if (pno == i-1)
{ run = run->nxt;
nstop++;
if (verbose&4)
{ if (columns == 2)
{ dotag(stdout, "<end>\n");
continue;
}
if (Have_claim && pno == 0)
printf("%3d: claim terminates\n",
depth);
else
printf("%3d: proc %d terminates\n",
depth, pno - Have_claim);
}
continue;
}
if (pno <= 1) continue; /* init dies before never */
printf("%3d: stop error, ", depth);
printf("proc %d (i=%d) trans %d, %c\n",
pno - Have_claim, i, nst, dothis->n->ntyp);
lost_trail();
}
for (X = run; X; X = X->nxt)
{ if (--i == pno)
break;
}
if (!X)
{ printf("%3d: no process %d ", depth, pno - Have_claim);
printf("(state %d)\n", nst);
lost_trail();
}
X->pc = dothis;
lineno = dothis->n->ln;
Fname = dothis->n->fn;
if (dothis->n->ntyp == D_STEP)
{ Element *g, *og = dothis;
do {
g = eval_sub(og);
if (g && depth >= jumpsteps
&& ((verbose&32) || ((verbose&4) && not_claim())))
{ if (columns != 2)
{ p_talk(og, 1);
if (og->n->ntyp == D_STEP)
og = og->n->sl->this->frst;
printf("\t[");
comment(stdout, og->n, 0);
printf("]\n");
}
if (verbose&1) dumpglobals();
if (verbose&2) dumplocal(X);
if (xspin) printf("\n");
}
og = g;
} while (g && g != dothis->nxt);
if (X != NULL)
{ X->pc = g?huntele(g, 0, -1):g;
}
} else
/*
* Connect to peer server and auto-login, if possible.
* 1 2 3 4
* <site> [<port> [<user> [<pwd>]]]
*/
int Connection::setpeer(int argc, char *argv[])
{
PROC(("setpeer","%d [%s,%s,%s,%s]",argc,(argc>1)?argv[1]:"nil",(argc>2)?argv[2]:"nil",(argc>3)?argv[3]:"nil",(argc>4)?argv[4]:"nil"));
FP_Screen _scr;
WORD port;
if(argc < 2)
{
code = -1;
return FALSE;
}
/* if(!SocketStartup)
{
WORD wVerReq = MAKEWORD(1,1);
WSADATA WSAData;
if(WSAStartup(wVerReq, &WSAData) == 0)
{
SocketStartup = TRUE;
}
else
{
SocketInitializeError = WINPORT(WSAGetLastError)();
SocketError = SocketInitializeError;
WINPORT(SetLastError)(SocketInitializeError);
return FALSE;
}
}*/
//port
if(argc > 2)
port = htons(atoi(argv[2]));
else
port = 0;
if(!port)
{
servent *sp = getservbyname("ftp", "tcp");
if(!sp)
{
Log(("ftp: ftp/tcp: unknown service. Assume port number %d (default)",IPPORT_FTP));
port = htons(IPPORT_FTP);
}
else
{
port = sp->s_port;
Log(("ftp: port %08X",port));
}
}
//Check if need to close connection
if(connected)
{
if(StrCmpI(argv[1], hostname) != 0 ||
port != portnum)
disconnect();
}
do
{
//Make connection
if(!connected)
{
if(!hookup(argv[1], port)) //Open connection
{
code = -1;
break;
}
connected = 1;
}
//Login
UserName[0] = 0;
UserPassword[0] = 0;
if(argc > 3) StrCpy(UserName, argv[3], ARRAYSIZE(UserName));
if(argc > 4) StrCpy(UserPassword, argv[4], ARRAYSIZE(UserPassword));
if(!login())
{
disconnect();
break;
}
return TRUE;
}
while(0);
return FALSE;
}
static boolean addElementLen (FILE *fp, tree *tr, nodeptr p, boolean readBranchLengths, boolean readNodeLabels, int *lcount, analdef *adef, boolean storeBranchLabels)
{
nodeptr q;
int n, ch, fres;
if ((ch = treeGetCh(fp)) == '(')
{
n = (tr->nextnode)++;
if (n > 2*(tr->mxtips) - 2)
{
if (tr->rooted || n > 2*(tr->mxtips) - 1)
{
printf("ERROR: Too many internal nodes. Is tree rooted?\n");
printf(" Deepest splitting should be a trifurcation.\n");
return FALSE;
}
else
{
if(readNodeLabels)
{
printf("The program will exit with an error in the next source code line\n");
printf("You are probably trying to read in rooted trees with a RAxML option \n");
printf("that for some reason expects unrooted binary trees\n\n");
}
assert(!readNodeLabels);
tr->rooted = TRUE;
}
}
q = tr->nodep[n];
if (! addElementLen(fp, tr, q->next, readBranchLengths, readNodeLabels, lcount, adef, storeBranchLabels)) return FALSE;
if (! treeNeedCh(fp, ',', "in")) return FALSE;
if (! addElementLen(fp, tr, q->next->next, readBranchLengths, readNodeLabels, lcount, adef, storeBranchLabels)) return FALSE;
if (! treeNeedCh(fp, ')', "in")) return FALSE;
if(readNodeLabels)
{
char label[64];
int support;
if(treeGetLabel (fp, label, 10))
{
int val = sscanf(label, "%d", &support);
assert(val == 1);
/*printf("LABEL %s Number %d\n", label, support);*/
p->support = q->support = support;
/*printf("%d %d %d %d\n", p->support, q->support, p->number, q->number);*/
assert(p->number > tr->mxtips && q->number > tr->mxtips);
*lcount = *lcount + 1;
}
}
else
(void) treeFlushLabel(fp);
}
else
{
ungetc(ch, fp);
if ((n = treeFindTipName(fp, tr, TRUE)) <= 0) return FALSE;
q = tr->nodep[n];
if (tr->start->number > n) tr->start = q;
(tr->ntips)++;
}
if(readBranchLengths)
{
double
branch;
int
startCounter = tr->branchLabelCounter,
endCounter,
branchLabel = -1;
if (! treeNeedCh(fp, ':', "in")) return FALSE;
if (! treeProcessLength(fp, &branch, &branchLabel, storeBranchLabels, tr))
return FALSE;
endCounter = tr->branchLabelCounter;
/*printf("Branch %8.20f %d\n", branch, tr->numBranches);*/
if(adef->mode == CLASSIFY_ML)
{
double
x[NUM_BRANCHES];
assert(tr->NumberOfModels == 1);
assert(adef->useBinaryModelFile);
assert(tr->numBranches == 1);
x[0] = exp(-branch / tr->fracchange);
hookup(p, q, x, tr->numBranches);
}
else
hookup(p, q, &branch, tr->numBranches);
if(storeBranchLabels && (endCounter > startCounter))
{
assert(!isTip(p->number, tr->mxtips) && !isTip(q->number, tr->mxtips));
assert(branchLabel >= 0);
p->support = q->support = branchLabel;
}
}
else
{
fres = treeFlushLen(fp, tr);
if(!fres) return FALSE;
hookupDefault(p, q, tr->numBranches);
}
return TRUE;
}
static void insertFast (tree *tr, nodeptr p, nodeptr q, int numBranches)
{
nodeptr r, s;
int i;
r = q->back;
s = p->back;
for(i = 0; i < numBranches; i++)
tr->lzi[i] = q->z[i];
if(Thorough)
{
double zqr[NUM_BRANCHES], zqs[NUM_BRANCHES], zrs[NUM_BRANCHES], lzqr, lzqs, lzrs, lzsum, lzq, lzr, lzs, lzmax;
double defaultArray[NUM_BRANCHES];
double e1[NUM_BRANCHES], e2[NUM_BRANCHES], e3[NUM_BRANCHES];
double *qz;
qz = q->z;
for(i = 0; i < numBranches; i++)
defaultArray[i] = defaultz;
makenewzGeneric(tr, q, r, qz, iterations, zqr, FALSE);
makenewzGeneric(tr, q, s, defaultArray, iterations, zqs, FALSE);
makenewzGeneric(tr, r, s, defaultArray, iterations, zrs, FALSE);
for(i = 0; i < numBranches; i++)
{
lzqr = (zqr[i] > zmin) ? log(zqr[i]) : log(zmin);
lzqs = (zqs[i] > zmin) ? log(zqs[i]) : log(zmin);
lzrs = (zrs[i] > zmin) ? log(zrs[i]) : log(zmin);
lzsum = 0.5 * (lzqr + lzqs + lzrs);
lzq = lzsum - lzrs;
lzr = lzsum - lzqs;
lzs = lzsum - lzqr;
lzmax = log(zmax);
if (lzq > lzmax) {lzq = lzmax; lzr = lzqr; lzs = lzqs;}
else if (lzr > lzmax) {lzr = lzmax; lzq = lzqr; lzs = lzrs;}
else if (lzs > lzmax) {lzs = lzmax; lzq = lzqs; lzr = lzrs;}
e1[i] = exp(lzq);
e2[i] = exp(lzr);
e3[i] = exp(lzs);
}
hookup(p->next, q, e1, numBranches);
hookup(p->next->next, r, e2, numBranches);
hookup(p, s, e3, numBranches);
}
else
{
double z[NUM_BRANCHES];
for(i = 0; i < 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);
}
newviewGeneric(tr, p);
if(Thorough)
{
localSmooth(tr, p, smoothings);
for(i = 0; i < numBranches; i++)
{
tr->lzq[i] = p->next->z[i];
tr->lzr[i] = p->next->next->z[i];
tr->lzs[i] = p->z[i];
}
}
}
static void doNNIs(tree *tr, nodeptr p, double *lhVectors[3], boolean shSupport, int *interchanges, int *innerBranches,
double *pqz_0, double *pz1_0, double *pz2_0, double *qz1_0, double *qz2_0, double *pqz_1, double *pz1_1, double *pz2_1,
double *qz1_1, double *qz2_1, double *pqz_2, double *pz1_2, double *pz2_2, double *qz1_2, double *qz2_2)
{
nodeptr
q = p->back,
pb1 = p->next->back,
pb2 = p->next->next->back;
assert(!isTip(p->number, tr->mxtips));
if(!isTip(q->number, tr->mxtips))
{
int
whichNNI = 0;
nodeptr
qb1 = q->next->back,
qb2 = q->next->next->back;
double
lh[3];
*innerBranches = *innerBranches + 1;
nniSmooth(tr, p, 16);
if(shSupport)
{
evaluateGenericVector(tr, p);
memcpy(lhVectors[0], tr->perSiteLL, sizeof(double) * tr->cdta->endsite);
}
else
evaluateGeneric(tr, p);
lh[0] = tr->likelihood;
storeBranches(tr, p, pqz_0, pz1_0, pz2_0, qz1_0, qz2_0);
/*******************************************/
hookup(p, q, pqz_0, tr->numBranches);
hookup(p->next, qb1, qz1_0, tr->numBranches);
hookup(p->next->next, pb2, pz2_0, tr->numBranches);
hookup(q->next, pb1, pz1_0, tr->numBranches);
hookup(q->next->next, qb2, qz2_0, tr->numBranches);
newviewGeneric(tr, p);
newviewGeneric(tr, p->back);
nniSmooth(tr, p, 16);
if(shSupport)
{
evaluateGenericVector(tr, p);
memcpy(lhVectors[1], tr->perSiteLL, sizeof(double) * tr->cdta->endsite);
}
else
evaluateGeneric(tr, p);
lh[1] = tr->likelihood;
storeBranches(tr, p, pqz_1, pz1_1, pz2_1, qz1_1, qz2_1);
if(lh[1] > lh[0])
whichNNI = 1;
/*******************************************/
hookup(p, q, pqz_0, tr->numBranches);
hookup(p->next, qb1, qz1_0, tr->numBranches);
hookup(p->next->next, pb1, pz1_0, tr->numBranches);
hookup(q->next, pb2, pz2_0, tr->numBranches);
hookup(q->next->next, qb2, qz2_0, tr->numBranches);
newviewGeneric(tr, p);
newviewGeneric(tr, p->back);
nniSmooth(tr, p, 16);
if(shSupport)
{
evaluateGenericVector(tr, p);
memcpy(lhVectors[2], tr->perSiteLL, sizeof(double) * tr->cdta->endsite);
}
else
evaluateGeneric(tr, p);
lh[2] = tr->likelihood;
storeBranches(tr, p, pqz_2, pz1_2, pz2_2, qz1_2, qz2_2);
if(lh[2] > lh[0] && lh[2] > lh[1])
whichNNI = 2;
/*******************************************/
if(shSupport)
whichNNI = 0;
switch(whichNNI)
{
case 0:
hookup(p, q, pqz_0, tr->numBranches);
hookup(p->next, pb1, pz1_0, tr->numBranches);
hookup(p->next->next, pb2, pz2_0, tr->numBranches);
hookup(q->next, qb1, qz1_0, tr->numBranches);
hookup(q->next->next, qb2, qz2_0, tr->numBranches);
break;
case 1:
hookup(p, q, pqz_1, tr->numBranches);
hookup(p->next, qb1, pz1_1, tr->numBranches);
hookup(p->next->next, pb2, pz2_1, tr->numBranches);
hookup(q->next, pb1, qz1_1, tr->numBranches);
hookup(q->next->next, qb2, qz2_1, tr->numBranches);
break;
case 2:
hookup(p, q, pqz_2, tr->numBranches);
hookup(p->next, qb1, pz1_2, tr->numBranches);
hookup(p->next->next, pb1, pz2_2, tr->numBranches);
hookup(q->next, pb2, qz1_2, tr->numBranches);
hookup(q->next->next, qb2, qz2_2, tr->numBranches);
break;
default:
assert(0);
}
newviewGeneric(tr, p);
newviewGeneric(tr, q);
if(whichNNI > 0)
*interchanges = *interchanges + 1;
if(shSupport)
p->bInf->support = SHSupport(tr->cdta->endsite, 1000, tr->resample, lh, lhVectors);
}
if(!isTip(pb1->number, tr->mxtips))
doNNIs(tr, pb1, lhVectors, shSupport, interchanges, innerBranches,
pqz_0, pz1_0, pz2_0, qz1_0, qz2_0, pqz_1, pz1_1, pz2_1,
qz1_1, qz2_1, pqz_2, pz1_2, pz2_2, qz1_2, qz2_2);
if(!isTip(pb2->number, tr->mxtips))
doNNIs(tr, pb2, lhVectors, shSupport, interchanges, innerBranches,
pqz_0, pz1_0, pz2_0, qz1_0, qz2_0, pqz_1, pz1_1, pz2_1,
qz1_1, qz2_1, pqz_2, pz1_2, pz2_2, qz1_2, qz2_2);
return;
}
static void hookupBL(nodeptr p, nodeptr q, nodeptr bl_p, state *s)
{
set_branch_length_sliding_window(bl_p, s->tr->numBranches, s, FALSE);
hookup(p, q, bl_p->z, s->tr->numBranches);
}
static boolean addElementLen (FILE *fp, tree *tr, nodeptr p, boolean readBranchLengths, boolean readNodeLabels, int *lcount)
{
nodeptr q;
int n, ch, fres;
if ((ch = treeGetCh(fp)) == '(')
{
n = (tr->nextnode)++;
if (n > 2*(tr->mxtips) - 2)
{
if (tr->rooted || n > 2*(tr->mxtips) - 1)
{
printf("ERROR: Too many internal nodes. Is tree rooted?\n");
printf(" Deepest splitting should be a trifurcation.\n");
return FALSE;
}
else
{
assert(!readNodeLabels);
tr->rooted = TRUE;
}
}
q = tr->nodep[n];
if (! addElementLen(fp, tr, q->next, readBranchLengths, readNodeLabels, lcount)) return FALSE;
if (! treeNeedCh(fp, ',', "in")) return FALSE;
if (! addElementLen(fp, tr, q->next->next, readBranchLengths, readNodeLabels, lcount)) return FALSE;
if (! treeNeedCh(fp, ')', "in")) return FALSE;
if(readNodeLabels)
{
char label[64];
int support;
if(treeGetLabel (fp, label, 10))
{
int val = sscanf(label, "%d", &support);
assert(val == 1);
/*printf("LABEL %s Number %d\n", label, support);*/
/*p->support = q->support = support;*/
/*printf("%d %d %d %d\n", p->support, q->support, p->number, q->number);*/
assert(p->number > tr->mxtips && q->number > tr->mxtips);
*lcount = *lcount + 1;
}
}
else
(void) treeFlushLabel(fp);
}
else
{
ungetc(ch, fp);
if ((n = treeFindTipName(fp, tr)) <= 0) return FALSE;
q = tr->nodep[n];
if (tr->start->number > n) tr->start = q;
(tr->ntips)++;
}
if(readBranchLengths)
{
double branch;
if (! treeNeedCh(fp, ':', "in")) return FALSE;
if (! treeProcessLength(fp, &branch)) return FALSE;
/*printf("Branch %8.20f %d\n", branch, tr->numBranches);*/
hookup(p, q, &branch, tr->numBranches);
}
else
{
fres = treeFlushLen(fp);
if(!fres) return FALSE;
hookupDefault(p, q, tr->numBranches);
}
return TRUE;
}
int rearrangeBIG(tree *tr, nodeptr p, int mintrav, int maxtrav)
{
double p1z[NUM_BRANCHES], p2z[NUM_BRANCHES], q1z[NUM_BRANCHES], q2z[NUM_BRANCHES];
nodeptr p1, p2, q, q1, q2;
int mintrav2, i;
boolean doP = TRUE, doQ = TRUE;
if (maxtrav < 1 || mintrav > maxtrav) return 0;
q = p->back;
if(tr->constrained)
{
if(! tipHomogeneityChecker(tr, p->back, 0))
doP = FALSE;
if(! tipHomogeneityChecker(tr, q->back, 0))
doQ = FALSE;
if(doQ == FALSE && doP == FALSE)
return 0;
}
if (!isTip(p->number, tr->rdta->numsp) && doP)
{
p1 = p->next->back;
p2 = p->next->next->back;
if(!isTip(p1->number, tr->rdta->numsp) || !isTip(p2->number, tr->rdta->numsp))
{
for(i = 0; i < tr->numBranches; i++)
{
p1z[i] = p1->z[i];
p2z[i] = p2->z[i];
}
if (! removeNodeBIG(tr, p, tr->numBranches)) return badRear;
if (!isTip(p1->number, tr->rdta->numsp))
{
addTraverseBIG(tr, p, p1->next->back,
mintrav, maxtrav);
addTraverseBIG(tr, p, p1->next->next->back,
mintrav, maxtrav);
}
if (!isTip(p2->number, tr->rdta->numsp))
{
addTraverseBIG(tr, p, p2->next->back,
mintrav, maxtrav);
addTraverseBIG(tr, p, p2->next->next->back,
mintrav, maxtrav);
}
hookup(p->next, p1, p1z, tr->numBranches);
hookup(p->next->next, p2, p2z, tr->numBranches);
newviewGeneric(tr, p);
}
}
if (!isTip(q->number, tr->rdta->numsp) && maxtrav > 0 && doQ)
{
q1 = q->next->back;
q2 = q->next->next->back;
/*if (((!q1->tip) && (!q1->next->back->tip || !q1->next->next->back->tip)) ||
((!q2->tip) && (!q2->next->back->tip || !q2->next->next->back->tip))) */
if (
(
! isTip(q1->number, tr->rdta->numsp) &&
(! isTip(q1->next->back->number, tr->rdta->numsp) || ! isTip(q1->next->next->back->number, tr->rdta->numsp))
)
||
(
! isTip(q2->number, tr->rdta->numsp) &&
(! isTip(q2->next->back->number, tr->rdta->numsp) || ! isTip(q2->next->next->back->number, tr->rdta->numsp))
)
)
{
for(i = 0; i < tr->numBranches; i++)
{
q1z[i] = q1->z[i];
q2z[i] = q2->z[i];
}
if (! removeNodeBIG(tr, q, tr->numBranches)) return badRear;
mintrav2 = mintrav > 2 ? mintrav : 2;
if (/*! q1->tip*/ !isTip(q1->number, tr->rdta->numsp))
{
addTraverseBIG(tr, q, q1->next->back,
mintrav2 , maxtrav);
addTraverseBIG(tr, q, q1->next->next->back,
mintrav2 , maxtrav);
}
if (/*! q2->tip*/ ! isTip(q2->number, tr->rdta->numsp))
{
addTraverseBIG(tr, q, q2->next->back,
mintrav2 , maxtrav);
addTraverseBIG(tr, q, q2->next->next->back,
mintrav2 , maxtrav);
}
hookup(q->next, q1, q1z, tr->numBranches);
hookup(q->next->next, q2, q2z, tr->numBranches);
newviewGeneric(tr, q);
}
}
return 1;
}
boolean testInsertBIG (tree *tr, nodeptr p, nodeptr q)
{
double qz[NUM_BRANCHES], pz[NUM_BRANCHES];
nodeptr r;
boolean doIt = TRUE;
double startLH = tr->endLH;
int i;
r = q->back;
for(i = 0; i < tr->numBranches; i++)
{
qz[i] = q->z[i];
pz[i] = p->z[i];
}
if(tr->grouped)
{
int rNumber, qNumber, pNumber;
doIt = FALSE;
rNumber = tr->constraintVector[r->number];
qNumber = tr->constraintVector[q->number];
pNumber = tr->constraintVector[p->number];
if(pNumber == -9)
pNumber = checker(tr, p->back);
if(pNumber == -9)
doIt = TRUE;
else
{
if(qNumber == -9)
qNumber = checker(tr, q);
if(rNumber == -9)
rNumber = checker(tr, r);
if(pNumber == rNumber || pNumber == qNumber)
doIt = TRUE;
}
}
if(doIt)
{
if (! insertBIG(tr, p, q, tr->numBranches)) return FALSE;
evaluateGeneric(tr, p->next->next);
if(tr->likelihood > tr->bestOfNode)
{
tr->bestOfNode = tr->likelihood;
tr->insertNode = q;
tr->removeNode = p;
for(i = 0; i < tr->numBranches; i++)
{
tr->currentZQR[i] = tr->zqr[i];
tr->currentLZR[i] = tr->lzr[i];
tr->currentLZQ[i] = tr->lzq[i];
tr->currentLZS[i] = tr->lzs[i];
}
}
if(tr->likelihood > tr->endLH)
{
tr->insertNode = q;
tr->removeNode = p;
for(i = 0; i < tr->numBranches; i++)
tr->currentZQR[i] = tr->zqr[i];
tr->endLH = tr->likelihood;
}
hookup(q, r, qz, tr->numBranches);
p->next->next->back = p->next->back = (nodeptr) NULL;
if(Thorough)
{
nodeptr s = p->back;
hookup(p, s, pz, tr->numBranches);
}
if((tr->doCutoff) && (tr->likelihood < startLH))
{
tr->lhAVG += (startLH - tr->likelihood);
tr->lhDEC++;
if((startLH - tr->likelihood) >= tr->lhCutoff)
return FALSE;
else
return TRUE;
}
else
return TRUE;
}
else
return TRUE;
}
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);
}
reset_stNNI(state *s)
{
nodeptr p, q;
p = s->p;
q = p->back;
nodeptr pb1, pb2;
pb1 = p->next->back;
pb2 = p->next->next->back;
nodeptr qb1, qb2;
qb1 = q->next->back;
qb2 = q->next->next->back;
/* whichNNI 1*/
if(s->whichNNI == 1)
{
hookup(p, q, q->z_tmp, s->tr->numBranches);
hookup(p->next, qb1, p->next->z_tmp, s->tr->numBranches);
hookup(p->next->next, pb2, p->next->next->z_tmp, s->tr->numBranches);
hookup(q->next, pb1, q->next->z_tmp, s->tr->numBranches);
hookup(q->next->next, qb2, q->next->next->z_tmp, s->tr->numBranches);
}
else if(s->whichNNI == 2)
{
hookup(p, q, p->z_tmp, s->tr->numBranches);
hookup(p->next, pb1, p->next->z_tmp, s->tr->numBranches);
hookup(p->next->next, qb1, p->next->next->z_tmp, s->tr->numBranches);
hookup(q->next, pb2, q->next->z_tmp, s->tr->numBranches);
hookup(q->next->next, qb2, q->next->next->z_tmp, s->tr->numBranches);
}
else
{
assert(s->whichNNI == 0);
hookup(p, q, p->z_tmp, s->tr->numBranches);
hookup(p->next, pb1, p->next->z_tmp, s->tr->numBranches);
hookup(p->next->next, pb2, p->next->next->z_tmp, s->tr->numBranches);
hookup(q->next, qb1, q->next->z_tmp, s->tr->numBranches);
hookup(q->next->next, qb2, q->next->next->z_tmp, s->tr->numBranches);
}
/*
reset_branch_length(p, s->tr->numBranches);
reset_branch_length(p->next, s->tr->numBranches);
reset_branch_length(p->next->next, s->tr->numBranches);
reset_branch_length(q->next, s->tr->numBranches);
reset_branch_length(q->next->next, s->tr->numBranches);
*/
newviewGeneric(s->tr, p, FALSE);
newviewGeneric(s->tr, q, FALSE);
}
static boolean stNNIproposal(state *s)
{
//s->newprior = 1;
s->bl_prior = 0;
int attempts = 0;
do{
s->p = selectRandomInnerSubtree(s->tr); /* TODOFER do this ad hoc for NNI requirements*/
if (++attempts > 500)
return FALSE;
}while(isTip(s->p->number, s->tr->mxtips) || isTip(s->p->back->number, s->tr->mxtips));
assert(!isTip(s->p->number, s->tr->mxtips));
nodeptr
p = s->p,
q = s->p->back,
pb1 = s->p->next->back,
pb2 = s->p->next->next->back;
assert(!isTip(q->number, s->tr->mxtips));
nodeptr
qb1 = q->next->back,
qb2 = q->next->next->back;
recordNNIBranchInfo(p, s->tr->numBranches);
/* do only one type of NNI, nni1 */
double randprop = (double)rand()/(double)RAND_MAX;
boolean changeBL = TRUE;
if (randprop < 1.0 / 3.0)
{
s->whichNNI = 1;
if(!changeBL)
{
hookup(p, q, p->z, s->tr->numBranches);
hookup(p->next, qb1, q->next->z, s->tr->numBranches);
hookup(p->next->next, pb2, p->next->next->z, s->tr->numBranches);
hookup(q->next, pb1, p->next->z, s->tr->numBranches);
hookup(q->next->next, qb2, q->next->next->z, s->tr->numBranches);
}
else
{
hookupBL(p, q, p, s);
hookupBL(p->next, qb1, q->next, s);
hookupBL(p->next->next, pb2, p->next->next, s);
hookupBL(q->next, pb1, p->next, s);
hookupBL(q->next->next, qb2, q->next->next, s);
}
}
else if (randprop < 2.0 / 3.0)
{
s->whichNNI = 2;
if(!changeBL)
{
hookup(p, q, p->z, s->tr->numBranches);
hookup(p->next, pb1, p->next->z, s->tr->numBranches);
hookup(p->next->next, qb1, q->next->z, s->tr->numBranches);
hookup(q->next, pb2, p->next->next->z, s->tr->numBranches);
hookup(q->next->next, qb2, q->next->next->z, s->tr->numBranches);
}
else
{
hookupBL(p, q, p, s);
hookupBL(p->next, pb1, p->next, s);
hookupBL(p->next->next, qb1, q->next, s);
hookupBL(q->next, pb2, p->next->next, s);
hookupBL(q->next->next, qb2, q->next->next, s);
}
}
else
{
/* change only the branch lengths */
s->whichNNI = 0;
if(changeBL)
{
/* do it like this for symmetry */
hookupBL(p, q, p, s);
hookupBL(p->next, pb1, p->next, s);
hookupBL(p->next->next, pb2, p->next->next, s);
hookupBL(q->next, qb1, q->next, s);
hookupBL(q->next->next, qb2, q->next->next, s);
}
}
newviewGeneric(s->tr, p, FALSE);
newviewGeneric(s->tr, p->back, FALSE);
evaluateGeneric(s->tr, p, FALSE);
return TRUE;
}
void jointree()
{
/* calculate the tree */
long nc, nextnode, mini=0, minj=0, i, j, ia, ja, ii, jj, nude, iter;
double fotu2, total, tmin, dio, djo, bi, bj, bk, dmin=0, da;
long el[3];
vector av;
intvector oc;
/* for Y. Ina speedups */
double *R;
R = (double *)calloc(spp,sizeof(double));
for (i = 0; i <= spp - 2; i++) {
for (j = i + 1; j < spp; j++) {
da = (x[i][j] + x[j][i]) / 2.0;
x[i][j] = da;
x[j][i] = da;
}
}
/* First initialization */
fotu2 = spp - 2.0;
nextnode = spp + 1;
av = (vector)Malloc(spp*sizeof(double));
oc = (intvector)Malloc(spp*sizeof(long));
for (i = 0; i < spp; i++) {
av[i] = 0.0;
oc[i] = 1;
}
/* Enter the main cycle */
if (njoin)
iter = spp - 3;
else
iter = spp - 1;
for (nc = 1; nc <= iter; nc++) {
for (j = 2; j <= spp; j++) {
for (i = 0; i <= j - 2; i++)
x[j - 1][i] = x[i][j - 1];
}
tmin = 99999.0;
/* Compute sij and minimize */
if (njoin) { /* Y. Ina */
for (i = 0; i < spp; i++) { /* Y. Ina */
R[i] = 0.0; /* Y. Ina */
} /* Y. Ina */
for (ja = 2; ja <= spp; ja++) { /* Y. Ina */
jj = enterorder[ja - 1]; /* Y. Ina */
if (cluster[jj - 1] != NULL) { /* Y. Ina */
for (ia = 0; ia <= ja - 2; ia++) { /* Y. Ina */
ii = enterorder[ia]; /* Y. Ina */
if (cluster[ii - 1] != NULL) { /* Y. Ina */
R[ii - 1] += x[ii - 1][jj - 1]; /* Y. Ina */
R[jj - 1] += x[ii - 1][jj - 1]; /* Y. Ina */
} /* Y. Ina */
} /* Y. Ina */
} /* Y. Ina */
} /* Y. Ina */
} /* Y. Ina */
for (ja = 2; ja <= spp; ja++) {
jj = enterorder[ja - 1];
if (cluster[jj - 1] != NULL) {
for (ia = 0; ia <= ja - 2; ia++) {
ii = enterorder[ia];
if (cluster[ii - 1] != NULL) {
if (njoin) {
/* diq = 0.0;
djq = 0.0;
dij = x[ii - 1][jj - 1];
for (i = 0; i < spp; i++) {
diq += x[i][ii - 1];
djq += x[i][jj - 1];
}
total = fotu2 * dij - diq - djq; */ /* deleted by Y. Ina */
total = fotu2 * x[ii - 1][jj - 1] - R[ii - 1] - R[jj - 1]; /* Y. Ina */
} else
total = x[ii - 1][jj - 1];
if (total < tmin) {
tmin = total;
mini = ii;
minj = jj;
}
}
}
}
}
/* compute lengths and print */
if (njoin) {
dio = 0.0;
djo = 0.0;
for (i = 0; i < spp; i++) {
dio += x[i][mini - 1];
djo += x[i][minj - 1];
}
dmin = x[mini - 1][minj - 1];
dio = (dio - dmin) / fotu2;
djo = (djo - dmin) / fotu2;
bi = (dmin + dio - djo) * 0.5;
bj = dmin - bi;
bi -= av[mini - 1];
bj -= av[minj - 1];
} else {
bi = x[mini - 1][minj - 1] / 2.0 - av[mini - 1];
bj = x[mini - 1][minj - 1] / 2.0 - av[minj - 1];
av[mini - 1] += bi;
}
if (progress) {
printf("Cycle %3ld: ", iter - nc + 1);
if (njoin)
nodelabel(av[mini - 1] > 0.0);
else
nodelabel(oc[mini - 1] > 1.0);
printf("%3ld (%10.5f) joins ", mini, bi);
if (njoin)
nodelabel(av[minj - 1] > 0.0);
else
nodelabel(oc[minj - 1] > 1.0);
printf("%3ld (%10.5f)\n", minj, bj);
#ifdef WIN32
phyFillScreenColor();
#endif
}
hookup(curtree.nodep[nextnode - 1]->next, cluster[mini - 1]);
hookup(curtree.nodep[nextnode - 1]->next->next, cluster[minj - 1]);
cluster[mini - 1]->v = bi;
cluster[minj - 1]->v = bj;
cluster[mini - 1]->back->v = bi;
cluster[minj - 1]->back->v = bj;
cluster[mini - 1] = curtree.nodep[nextnode - 1];
cluster[minj - 1] = NULL;
nextnode++;
if (njoin)
av[mini - 1] = dmin * 0.5;
/* re-initialization */
fotu2 -= 1.0;
for (j = 0; j < spp; j++) {
if (cluster[j] != NULL) {
if (njoin) {
da = (x[mini - 1][j] + x[minj - 1][j]) * 0.5;
if (mini - j - 1 < 0)
x[mini - 1][j] = da;
if (mini - j - 1 > 0)
x[j][mini - 1] = da;
} else {
da = x[mini - 1][j] * oc[mini - 1] + x[minj - 1][j] * oc[minj - 1];
da /= oc[mini - 1] + oc[minj - 1];
x[mini - 1][j] = da;
x[j][mini - 1] = da;
}
}
}
for (j = 0; j < spp; j++) {
x[minj - 1][j] = 0.0;
x[j][minj - 1] = 0.0;
}
oc[mini - 1] += oc[minj - 1];
}
/* the last cycle */
nude = 1;
for (i = 1; i <= spp; i++) {
if (cluster[i - 1] != NULL) {
el[nude - 1] = i;
nude++;
}
}
if (!njoin) {
curtree.start = cluster[el[0] - 1];
curtree.start->back = NULL;
free(av);
free(oc);
return;
}
bi = (x[el[0] - 1][el[1] - 1] + x[el[0] - 1][el[2] - 1] - x[el[1] - 1]
[el[2] - 1]) * 0.5;
bj = x[el[0] - 1][el[1] - 1] - bi;
bk = x[el[0] - 1][el[2] - 1] - bi;
bi -= av[el[0] - 1];
bj -= av[el[1] - 1];
bk -= av[el[2] - 1];
if (progress) {
printf("last cycle:\n");
putchar(' ');
nodelabel(av[el[0] - 1] > 0.0);
printf("%3ld (%10.5f) joins ", el[0], bi);
nodelabel(av[el[1] - 1] > 0.0);
printf("%3ld (%10.5f) joins ", el[1], bj);
nodelabel(av[el[2] - 1] > 0.0);
printf("%3ld (%10.5f)\n", el[2], bk);
#ifdef WIN32
phyFillScreenColor();
#endif
}
hookup(curtree.nodep[nextnode - 1], cluster[el[0] - 1]);
hookup(curtree.nodep[nextnode - 1]->next, cluster[el[1] - 1]);
hookup(curtree.nodep[nextnode - 1]->next->next, cluster[el[2] - 1]);
cluster[el[0] - 1]->v = bi;
cluster[el[1] - 1]->v = bj;
cluster[el[2] - 1]->v = bk;
cluster[el[0] - 1]->back->v = bi;
cluster[el[1] - 1]->back->v = bj;
cluster[el[2] - 1]->back->v = bk;
curtree.start = cluster[el[0] - 1]->back;
free(av);
free(oc);
} /* jointree */
void computePlacementBias(tree *tr, analdef *adef)
{
int
windowSize = adef->slidingWindowSize,
k,
i,
tips,
numTraversalBranches = (2 * (tr->mxtips - 1)) - 3; /* compute number of branches into which we need to insert once we have removed a taxon */
char
fileName[1024];
FILE
*outFile;
/* data for each sliding window starting position */
positionData
*pd = (positionData *)malloc(sizeof(positionData) * (tr->cdta->endsite - windowSize));
double
*nodeDistances = (double*)calloc(tr->cdta->endsite, sizeof(double)), /* array to store node distnces ND for every sliding window position */
*distances = (double*)calloc(tr->cdta->endsite, sizeof(double)); /* array to store avg distances for every site */
strcpy(fileName, workdir);
strcat(fileName, "RAxML_SiteSpecificPlacementBias.");
strcat(fileName, run_id);
outFile = myfopen(fileName, "w");
printBothOpen("Likelihood of comprehensive tree %f\n\n", tr->likelihood);
if(windowSize > tr->cdta->endsite)
{
printBothOpen("The size of your sliding window is %d while the number of sites in the alignment is %d\n\n", windowSize, tr->cdta->endsite);
exit(-1);
}
if(windowSize >= (int)(0.9 * tr->cdta->endsite))
printBothOpen("WARNING: your sliding window of size %d is only slightly smaller than you alignment that has %d sites\n\n", windowSize, tr->cdta->endsite);
printBothOpen("Sliding window size: %d\n\n", windowSize);
/* prune and re-insert on tip at a time into all branches of the remaining tree */
for(tips = 1; tips <= tr->mxtips; tips++)
{
nodeptr
myStart,
p = tr->nodep[tips]->back, /* this is the node at which we are prunung */
p1 = p->next->back,
p2 = p->next->next->back;
double
pz[NUM_BRANCHES],
p1z[NUM_BRANCHES],
p2z[NUM_BRANCHES];
int
branchCounter = 0;
/* reset array values for this tip */
for(i = 0; i < tr->cdta->endsite; i++)
{
pd[i].lh = unlikely;
pd[i].p = (nodeptr)NULL;
}
/* store the three branch lengths adjacent to the position at which we prune */
for(i = 0; i < tr->numBranches; i++)
{
p1z[i] = p1->z[i];
p2z[i] = p2->z[i];
pz[i] = p->z[i];
}
/* prune the taxon, optimizing the branch between p1 and p2 */
removeNodeBIG(tr, p, tr->numBranches);
printBothOpen("Pruning taxon Number %d [%s]\n", tips, tr->nameList[tips]);
/* find any tip to start traversing the tree */
myStart = findAnyTip(p1, tr->mxtips);
/* insert taxon, compute likelihood and remove taxon again from all branches */
traverseBias(p, myStart->back, tr, &branchCounter, pd, windowSize);
assert(branchCounter == numTraversalBranches);
/* for every sliding window position calc ND to the true/correct position at p */
for(i = 0; i < tr->cdta->endsite - windowSize; i++)
nodeDistances[i] = getNodeDistance(p1, pd[i].p, tr->mxtips);
/* now analyze */
for(i = 0; i < tr->cdta->endsite; i++)
{
double
d = 0.0;
int
s = 0;
/*
check site position, i.e., doe we have windowSize data points available
or fewer because we are at the start or the end of the alignment
*/
/*
for each site just accumulate the node distances we have for all
sliding windows that passed over this site
*/
if(i < windowSize)
{
for(k = 0; k < i + 1; k++, s++)
d += nodeDistances[k];
}
else
{
if(i < tr->cdta->endsite - windowSize)
{
for(k = i - windowSize + 1; k <= i; k++, s++)
d += nodeDistances[k];
}
else
{
for(k = i - windowSize; k < (tr->cdta->endsite - windowSize); k++, s++)
d += nodeDistances[k + 1];
}
}
/*
now just divide the accumultaed ND distance by
the number of distances we have for this position and then add it to the acc
distances over all taxa.
I just realized that the version on which I did the tests
I sent to Simon I used
distances[i] = d / ((double)s);
instead of
distances[i] += d / ((double)s);
gamo tin poutana mou
*/
distances[i] += (d / ((double)s));
}
/*
re-connect taxon to its original position
*/
hookup(p->next, p1, p1z, tr->numBranches);
hookup(p->next->next, p2, p2z, tr->numBranches);
hookup(p, p->back, pz, tr->numBranches);
/*
fix likelihood vectors
*/
newviewGeneric(tr, p);
}
/*
now just compute the average ND over all taxa
*/
for(i = 0; i < tr->cdta->endsite; i++)
{
double
avg = distances[i] / ((double)tr->mxtips);
fprintf(outFile, "%d %f\n", i, avg);
}
printBothOpen("\nTime for EPA-based site-specific placement bias calculation: %f\n", gettime() - masterTime);
printBothOpen("Site-specific placement bias statistics written to file %s\n", fileName);
fclose(outFile);
exit(0);
}
static void testInsertParsimony (tree *tr, nodeptr p, nodeptr q, boolean saveBranches)
{
unsigned int
mp;
nodeptr
r = q->back;
boolean
doIt = TRUE;
if(tr->grouped)
{
int
rNumber = tr->constraintVector[r->number],
qNumber = tr->constraintVector[q->number],
pNumber = tr->constraintVector[p->number];
doIt = FALSE;
if(pNumber == -9)
pNumber = checkerPars(tr, p->back);
if(pNumber == -9)
doIt = TRUE;
else
{
if(qNumber == -9)
qNumber = checkerPars(tr, q);
if(rNumber == -9)
rNumber = checkerPars(tr, r);
if(pNumber == rNumber || pNumber == qNumber)
doIt = TRUE;
}
}
if(doIt)
{
double
z[NUM_BRANCHES];
if(saveBranches)
{
int i;
for(i = 0; i < tr->numBranches; i++)
z[i] = q->z[i];
}
insertParsimony(tr, p, q);
mp = evaluateParsimony(tr, p->next->next, FALSE);
if(mp < tr->bestParsimony)
{
tr->bestParsimony = mp;
tr->insertNode = q;
tr->removeNode = p;
}
if(saveBranches)
hookup(q, r, z, tr->numBranches);
else
hookupDefault(q, r, tr->numBranches);
p->next->next->back = p->next->back = (nodeptr) NULL;
}
return;
}
static double linearSPRs(tree *tr, int radius, boolean veryFast)
{
int
numberOfSubtrees = (tr->mxtips - 2) * 3,
count = 0,
k,
i;
double
fourScores[4];
nodeptr
*ptr = (nodeptr *)rax_malloc(sizeof(nodeptr) * numberOfSubtrees);
fourLikelihoods
*fourLi = (fourLikelihoods *)rax_malloc(sizeof(fourLikelihoods) * 4);
insertions
*ins = (insertions*)rax_malloc(sizeof(insertions));
ins->count = 0;
ins->maxCount = 2048;
ins->s = (scores *)rax_malloc(sizeof(scores) * ins->maxCount);
/* recursively compute the roots of all subtrees in the current tree
and store them in ptr */
getSubtreeRoots(tr->start->back, ptr, &count, tr->mxtips);
assert(count == numberOfSubtrees);
tr->startLH = tr->endLH = tr->likelihood;
/* loop over subtrees, i.e., execute a full SPR cycle */
for(i = 0; i < numberOfSubtrees; i++)
{
nodeptr
p = ptr[i],
p1 = p->next->back,
p2 = p->next->next->back;
double
p1z[NUM_BRANCHES],
p2z[NUM_BRANCHES];
ins->count = 0;
/*printf("Node %d %d\n", p->number, i);*/
tr->bestOfNode = unlikely;
for(k = 0; k < 4; k++)
fourScores[k] = unlikely;
assert(!isTip(p->number, tr->rdta->numsp));
if(!isTip(p1->number, tr->rdta->numsp) || !isTip(p2->number, tr->rdta->numsp))
{
double
max = unlikely;
int
maxInt = -1;
for(k = 0; k < tr->numBranches; k++)
{
p1z[k] = p1->z[k];
p2z[k] = p2->z[k];
}
/* remove the current subtree */
removeNodeBIG(tr, p, tr->numBranches);
/* pre score with fast insertions */
if(veryFast)
Thorough = 1;
else
Thorough = 0;
if (!isTip(p1->number, tr->rdta->numsp))
{
fourScores[0] = testInsertFast(tr, p, p1->next->back, ins, veryFast);
fourScores[1] = testInsertFast(tr, p, p1->next->next->back, ins, veryFast);
}
if (!isTip(p2->number, tr->rdta->numsp))
{
fourScores[2] = testInsertFast(tr, p, p2->next->back, ins, veryFast);
fourScores[3] = testInsertFast(tr, p, p2->next->next->back, ins, veryFast);
}
if(veryFast)
Thorough = 1;
else
Thorough = 0;
/* find the most promising direction */
if(!veryFast)
{
int
j = 0,
validEntries = 0;
double
lmax = unlikely,
posterior = 0.0;
for(k = 0; k < 4; k++)
{
fourLi[k].direction = k;
fourLi[k].likelihood = fourScores[k];
}
qsort(fourLi, 4, sizeof(fourLikelihoods), fourCompare);
for(k = 0; k < 4; k++)
if(fourLi[k].likelihood > unlikely)
validEntries++;
lmax = fourLi[0].likelihood;
while(posterior <= POSTERIOR_THRESHOLD && j < validEntries)
{
double
all = 0.0,
prob = 0.0;
for(k = 0; k < validEntries; k++)
all += exp(fourLi[k].likelihood - lmax);
posterior += (prob = (exp(fourLi[j].likelihood - lmax) / all));
switch(fourLi[j].direction)
{
case 0:
insertBeyond(tr, p, p1->next->back, radius, ins, veryFast);
break;
case 1:
insertBeyond(tr, p, p1->next->next->back, radius, ins, veryFast);
break;
case 2:
insertBeyond(tr, p, p2->next->back, radius, ins, veryFast);
break;
case 3:
insertBeyond(tr, p, p2->next->next->back, radius, ins, veryFast);
break;
default:
assert(0);
}
j++;
}
qsort(ins->s, ins->count, sizeof(scores), scoreCompare);
Thorough = 1;
for(k = 0; k < MIN(ins->count, 20); k++)
testInsertCandidates(tr, p, ins->s[k].p);
}
else
{
Thorough = 1;
for(k = 0; k < 4; k++)
{
if(max < fourScores[k])
{
max = fourScores[k];
maxInt = k;
}
}
/* descend into this direction and re-insert subtree there */
if(maxInt >= 0)
{
switch(maxInt)
{
case 0:
insertBeyond(tr, p, p1->next->back, radius, ins, veryFast);
break;
case 1:
insertBeyond(tr, p, p1->next->next->back, radius, ins, veryFast);
break;
case 2:
insertBeyond(tr, p, p2->next->back, radius, ins, veryFast);
break;
case 3:
insertBeyond(tr, p, p2->next->next->back, radius, ins, veryFast);
break;
default:
assert(0);
}
}
}
/* repair branch and reconnect subtree to its original position from which it was pruned */
hookup(p->next, p1, p1z, tr->numBranches);
hookup(p->next->next, p2, p2z, tr->numBranches);
/* repair likelihood vectors */
newviewGeneric(tr, p);
/* if the rearrangement of subtree rooted at p yielded a better likelihood score
restore the altered topology and use it from now on
*/
if(tr->endLH > tr->startLH)
{
restoreTreeFast(tr);
tr->startLH = tr->endLH = tr->likelihood;
}
}
}
return tr->startLH;
}
static nodeptr uprootTree (tree *tr, nodeptr p, boolean readBranchLengths, boolean readConstraint)
{
nodeptr q, r, s, start;
int n, i;
for(i = tr->mxtips + 1; i < 2 * tr->mxtips - 1; i++)
assert(i == tr->nodep[i]->number);
if(isTip(p->number, tr->mxtips) || p->back)
{
printf("ERROR: Unable to uproot tree.\n");
printf(" Inappropriate node marked for removal.\n");
assert(0);
}
assert(p->back == (nodeptr)NULL);
tr->nextnode = tr->nextnode - 1;
assert(tr->nextnode < 2 * tr->mxtips);
n = tr->nextnode;
assert(tr->nodep[tr->nextnode]);
if (n != tr->mxtips + tr->ntips - 1)
{
printf("ERROR: Unable to uproot tree. Inconsistent\n");
printf(" number of tips and nodes for rooted tree.\n");
assert(0);
}
q = p->next->back; /* remove p from tree */
r = p->next->next->back;
assert(p->back == (nodeptr)NULL);
if(readBranchLengths)
{
double b[NUM_BRANCHES];
int i;
for(i = 0; i < tr->numBranches; i++)
b[i] = (r->z[i] + q->z[i]);
hookup (q, r, b, tr->numBranches);
}
else
hookupDefault(q, r, tr->numBranches);
if(readConstraint && tr->grouped)
{
if(tr->constraintVector[p->number] != 0)
{
printf("Root node to remove should have top-level grouping of 0\n");
assert(0);
}
}
assert(!(isTip(r->number, tr->mxtips) && isTip(q->number, tr->mxtips)));
assert(p->number > tr->mxtips);
if(tr->ntips > 2 && p->number != n)
{
q = tr->nodep[n]; /* transfer last node's conections to p */
r = q->next;
s = q->next->next;
if(readConstraint && tr->grouped)
tr->constraintVector[p->number] = tr->constraintVector[q->number];
hookup(p, q->back, q->z, tr->numBranches); /* move connections to p */
hookup(p->next, r->back, r->z, tr->numBranches);
hookup(p->next->next, s->back, s->z, tr->numBranches);
q->back = q->next->back = q->next->next->back = (nodeptr) NULL;
}
else
p->back = p->next->back = p->next->next->back = (nodeptr) NULL;
assert(tr->ntips > 2);
start = findAnyTip(tr->nodep[tr->mxtips + 1], tr->mxtips);
assert(isTip(start->number, tr->mxtips));
tr->rooted = FALSE;
return start;
}
int main(int argc, char *argv[])
{
int master_fd, op, status;
pid_t pid, run_pid;
sv cmd;
fd_set readfds;
struct timeval tout;
if (argc != 2)
errx(1, "Need socket directory argument");
master_fd = hookup(argv[1]);
initscr();
signal(SIGWINCH, sig_winch);
nonl();
cbreak();
noecho();
for ( ; ; ) {
update_display();
FD_ZERO(&readfds);
FD_SET(master_fd, &readfds);
gettimeofday(&tout, NULL);
tout.tv_sec = 0;
tout.tv_usec = 1050000-tout.tv_usec;
if (select(master_fd+1, &readfds, NULL, NULL, &tout) < 0) {
if (errno == EINTR) continue;
err(4, "select");
}
if (!FD_ISSET(master_fd, &readfds))
continue;
readn(master_fd, &op, sizeof (int));
if (op == TOP_OP_EXIT) break;
switch (op) {
case TOP_OP_FETCH:
read_sv(master_fd, &cmd);
init_run(&cmd);
break;
case TOP_OP_ISSUE:
readn(master_fd, &pid, sizeof (pid_t));
readn(master_fd, &run_pid, sizeof (pid_t));
start_run(pid, run_pid);
break;
case TOP_OP_DONE:
readn(master_fd, &run_pid, sizeof (pid_t));
end_run(run_pid, 0);
break;
case TOP_OP_ATTN:
readn(master_fd, &run_pid, sizeof (pid_t));
readn(master_fd, &status, sizeof (pid_t));
end_run(run_pid, status);
break;
case TOP_OP_ONLINE:
sc++;
break;
case TOP_OP_OFFLINE:
sc--;
break;
default:
errx(5, "Unknown opcode %d", op);
}
}
endwin();
return 0;
}
