static void addMultifurcation (FILE *fp, tree *tr, nodeptr _p, analdef *adef, int *nextnode)
{
nodeptr
p,
initial_p;
int
n,
ch,
fres;
if ((ch = treeGetCh(fp)) == '(')
{
int
i = 0;
nextNodeOutOfBounds(tr, *nextnode);
initial_p = p = tr->nodep[*nextnode];
*nextnode = *nextnode + 1;
do
{
nextNodeOutOfBounds(tr, *nextnode);
p->next = tr->nodep[*nextnode];
*nextnode = *nextnode + 1;
p = p->next;
addMultifurcation(fp, tr, p, adef, nextnode);
i++;
}
while((ch = treeGetCh(fp)) == ',');
ungetc(ch, fp);
p->next = initial_p;
if (! treeNeedCh(fp, ')', "in"))
assert(0);
treeFlushLabel(fp);
}
else
{
ungetc(ch, fp);
if ((n = treeFindTipName(fp, tr, FALSE)) <= 0)
assert(0);
p = tr->nodep[n];
initial_p = p;
tr->start = p;
(tr->ntips)++;
}
fres = treeFlushLen(fp, tr);
if(!fres)
assert(0);
hookupDefault(initial_p, _p, 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;
}
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 boolean addElementLenMULT (FILE *fp, tree *tr, nodeptr p, int partitionCounter)
{
nodeptr q, r, s;
int n, ch, fres, rn;
double randomResolution;
int old;
tr->constraintVector[p->number] = partitionCounter;
if ((ch = treeGetCh(fp)) == '(')
{
partCount++;
old = partCount;
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
{
tr->rooted = TRUE;
}
}
q = tr->nodep[n];
tr->constraintVector[q->number] = partCount;
if (! addElementLenMULT(fp, tr, q->next, old)) return FALSE;
if (! treeNeedCh(fp, ',', "in")) return FALSE;
if (! addElementLenMULT(fp, tr, q->next->next, old)) return FALSE;
hookupDefault(p, q, tr->numBranches);
while((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
{
tr->rooted = TRUE;
}
}
r = tr->nodep[n];
tr->constraintVector[r->number] = partCount;
rn = randomInt(10000);
if(rn == 0)
randomResolution = 0;
else
randomResolution = ((double)rn)/10000.0;
if(randomResolution < 0.5)
{
s = q->next->back;
r->back = q->next;
q->next->back = r;
r->next->back = s;
s->back = r->next;
addElementLenMULT(fp, tr, r->next->next, old);
}
else
{
s = q->next->next->back;
r->back = q->next->next;
q->next->next->back = r;
r->next->back = s;
s->back = r->next;
addElementLenMULT(fp, tr, r->next->next, old);
}
}
if(ch != ')')
{
printf("Missing /) in treeReadLenMULT\n");
exit(-1);
}
(void) treeFlushLabel(fp);
}
else
{
ungetc(ch, fp);
if ((n = treeFindTipName(fp, tr, TRUE)) <= 0) return FALSE;
q = tr->nodep[n];
tr->constraintVector[q->number] = partitionCounter;
if (tr->start->number > n) tr->start = q;
(tr->ntips)++;
hookupDefault(p, q, tr->numBranches);
}
fres = treeFlushLen(fp, tr);
if(!fres) return FALSE;
return TRUE;
}
