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