5 * Created by Sarah Westcott on 1/22/09.
6 * Copyright 2009 Schloss Lab UMASS Amherst. All rights reserved.
12 /*****************************************************************/
15 globaldata = GlobalData::getInstance();
16 m = MothurOut::getInstance();
19 numNodes = 2*numLeaves - 1;
21 tree.resize(numNodes);
24 m->errorOut(e, "Tree", "Tree - numNodes");
28 /*****************************************************************/
29 Tree::Tree(string g) {
31 globaldata = GlobalData::getInstance();
32 m = MothurOut::getInstance();
34 parseTreeFile(); globaldata->runParse = false;
37 m->errorOut(e, "Tree", "Tree - just parse");
41 /*****************************************************************/
44 globaldata = GlobalData::getInstance();
45 m = MothurOut::getInstance();
47 if (globaldata->runParse == true) { parseTreeFile(); globaldata->runParse = false; }
48 //for(int i = 0; i < globaldata->Treenames.size(); i++) { cout << i << '\t' << globaldata->Treenames[i] << endl; }
49 numLeaves = globaldata->Treenames.size();
50 numNodes = 2*numLeaves - 1;
52 tree.resize(numNodes);
54 //initialize groupNodeInfo
55 for (int i = 0; i < globaldata->gTreemap->namesOfGroups.size(); i++) {
56 groupNodeInfo[globaldata->gTreemap->namesOfGroups[i]].resize(0);
59 //initialize tree with correct number of nodes, name and group info.
60 for (int i = 0; i < numNodes; i++) {
61 //initialize leaf nodes
62 if (i <= (numLeaves-1)) {
63 tree[i].setName(globaldata->Treenames[i]);
66 string group = globaldata->gTreemap->getGroup(globaldata->Treenames[i]);
67 vector<string> tempGroups; tempGroups.push_back(group);
68 tree[i].setGroup(tempGroups);
69 groupNodeInfo[group].push_back(i);
71 //set pcount and pGroup for groupname to 1.
72 tree[i].pcount[group] = 1;
73 tree[i].pGroups[group] = 1;
75 //Treemap knows name, group and index to speed up search
76 globaldata->gTreemap->setIndex(globaldata->Treenames[i], i);
78 //intialize non leaf nodes
79 }else if (i > (numLeaves-1)) {
81 vector<string> tempGroups;
82 tree[i].setGroup(tempGroups);
87 m->errorOut(e, "Tree", "Tree");
92 /*****************************************************************/
94 /*****************************************************************/
95 void Tree::addNamesToCounts() {
97 //ex. seq1 seq2,seq3,se4
103 //before this function seq1.pcount = pasture -> 1
104 //after seq1.pcount = pasture -> 2, forest -> 1, ocean -> 1
106 //before this function seq1.pgroups = pasture -> 1
107 //after seq1.pgroups = pasture -> 1 since that is the dominant group
110 //go through each leaf and update its pcounts and pgroups
114 for (int i = 0; i < numLeaves; i++) {
116 string name = tree[i].getName();
118 map<string, string>::iterator itNames = globaldata->names.find(name);
120 if (itNames == globaldata->names.end()) { m->mothurOut(name + " is not in your name file, please correct."); m->mothurOutEndLine(); exit(1); }
122 vector<string> dupNames;
123 m->splitAtComma(globaldata->names[name], dupNames);
125 map<string, int>::iterator itCounts;
127 set<string> groupsAddedForThisNode;
128 for (int j = 0; j < dupNames.size(); j++) {
130 string group = globaldata->gTreemap->getGroup(dupNames[j]);
132 if (dupNames[j] != name) {//you already added yourself in the constructor
134 if (groupsAddedForThisNode.count(group) == 0) { groupNodeInfo[group].push_back(i); groupsAddedForThisNode.insert(group); } //if you have not already added this node for this group, then add it
137 itCounts = tree[i].pcount.find(group);
138 if (itCounts == tree[i].pcount.end()) { //new group, add it
139 tree[i].pcount[group] = 1;
141 tree[i].pcount[group]++;
145 itCounts = tree[i].pGroups.find(group);
146 if (itCounts == tree[i].pGroups.end()) { //new group, add it
147 tree[i].pGroups[group] = 1;
149 tree[i].pGroups[group]++;
153 if(tree[i].pGroups[group] > maxPars){
154 maxPars = tree[i].pGroups[group];
156 }else { groupsAddedForThisNode.insert(group); } //add it so you don't add it to groupNodeInfo again
159 if (maxPars > 1) { //then we have some more dominant groups
160 //erase all the groups that are less than maxPars because you found a more dominant group.
161 for(it=tree[i].pGroups.begin();it!=tree[i].pGroups.end();){
162 if(it->second < maxPars){
163 tree[i].pGroups.erase(it++);
166 //set one remaining groups to 1
167 for(it=tree[i].pGroups.begin();it!=tree[i].pGroups.end();it++){
168 tree[i].pGroups[it->first] = 1;
172 //update groups to reflect all the groups this node represents
173 vector<string> nodeGroups;
174 map<string, int>::iterator itGroups;
175 for (itGroups = tree[i].pcount.begin(); itGroups != tree[i].pcount.end(); itGroups++) {
176 nodeGroups.push_back(itGroups->first);
178 tree[i].setGroup(nodeGroups);
184 //cout << "addNamesToCounts\t" << (B - A) / CLOCKS_PER_SEC << endl;
187 catch(exception& e) {
188 m->errorOut(e, "Tree", "addNamesToCounts");
192 /*****************************************************************/
193 int Tree::getIndex(string searchName) {
195 //Treemap knows name, group and index to speed up search
196 // getIndex function will return the vector index or -1 if seq is not found.
197 int index = globaldata->gTreemap->getIndex(searchName);
201 catch(exception& e) {
202 m->errorOut(e, "Tree", "getIndex");
206 /*****************************************************************/
208 void Tree::setIndex(string searchName, int index) {
210 //set index in treemap
211 globaldata->gTreemap->setIndex(searchName, index);
213 catch(exception& e) {
214 m->errorOut(e, "Tree", "setIndex");
218 /*****************************************************************/
219 int Tree::assembleTree() {
223 //if user has given a names file we want to include that info in the pgroups and pcount info.
224 if(globaldata->names.size() != 0) { addNamesToCounts(); }
226 //build the pGroups in non leaf nodes to be used in the parsimony calcs.
227 for (int i = numLeaves; i < numNodes; i++) {
228 if (m->control_pressed) { return 1; }
230 tree[i].pGroups = (mergeGroups(i));
231 tree[i].pcount = (mergeGcounts(i));
234 //cout << "assembleTree\t" << (B-A) / CLOCKS_PER_SEC << endl;
237 catch(exception& e) {
238 m->errorOut(e, "Tree", "assembleTree");
242 /*****************************************************************/
243 int Tree::assembleTree(string n) {
246 //build the pGroups in non leaf nodes to be used in the parsimony calcs.
247 for (int i = numLeaves; i < numNodes; i++) {
248 if (m->control_pressed) { return 1; }
250 tree[i].pGroups = (mergeGroups(i));
251 tree[i].pcount = (mergeGcounts(i));
254 //cout << "assembleTree\t" << (B-A) / CLOCKS_PER_SEC << endl;
257 catch(exception& e) {
258 m->errorOut(e, "Tree", "assembleTree");
262 /*****************************************************************/
263 void Tree::getSubTree(Tree* copy, vector<string> Groups) {
266 //we want to select some of the leaf nodes to create the output tree
267 //go through the input Tree starting at parents of leaves
268 for (int i = 0; i < numNodes; i++) {
270 //initialize leaf nodes
271 if (i <= (numLeaves-1)) {
272 tree[i].setName(Groups[i]);
275 string group = globaldata->gTreemap->getGroup(Groups[i]);
276 vector<string> tempGroups; tempGroups.push_back(group);
277 tree[i].setGroup(tempGroups);
278 groupNodeInfo[group].push_back(i);
280 //set pcount and pGroup for groupname to 1.
281 tree[i].pcount[group] = 1;
282 tree[i].pGroups[group] = 1;
284 //Treemap knows name, group and index to speed up search
285 globaldata->gTreemap->setIndex(Groups[i], i);
287 //intialize non leaf nodes
288 }else if (i > (numLeaves-1)) {
290 vector<string> tempGroups;
291 tree[i].setGroup(tempGroups);
295 set<int> removedLeaves;
296 for (int i = 0; i < copy->getNumLeaves(); i++) {
298 if (removedLeaves.count(i) == 0) {
301 int parent = copy->tree[i].getParent();
305 if (m->inUsersGroups(copy->tree[i].getName(), Groups)) {
306 //find my siblings name
307 int parentRC = copy->tree[parent].getRChild();
308 int parentLC = copy->tree[parent].getLChild();
310 //if I am the right child, then my sib is the left child
311 int sibIndex = parentRC;
312 if (parentRC == i) { sibIndex = parentLC; }
314 string sibsName = copy->tree[sibIndex].getName();
316 //if yes, is my sibling
317 if ((m->inUsersGroups(sibsName, Groups)) || (sibsName == "")) {
318 //we both are okay no trimming required
320 //i am, my sib is not, so remove sib by setting my parent to my grandparent
321 int grandparent = copy->tree[parent].getParent();
322 int grandparentLC = copy->tree[grandparent].getLChild();
323 int grandparentRC = copy->tree[grandparent].getRChild();
325 //whichever of my granparents children was my parent now equals me
326 if (grandparentLC == parent) { grandparentLC = i; }
327 else { grandparentRC = i; }
329 copy->tree[i].setParent(grandparent);
330 copy->tree[i].setBranchLength((copy->tree[i].getBranchLength()+copy->tree[parent].getBranchLength()));
331 copy->tree[grandparent].setChildren(grandparentLC, grandparentRC);
332 removedLeaves.insert(sibIndex);
335 //find my siblings name
336 int parentRC = copy->tree[parent].getRChild();
337 int parentLC = copy->tree[parent].getLChild();
339 //if I am the right child, then my sib is the left child
340 int sibIndex = parentRC;
341 if (parentRC == i) { sibIndex = parentLC; }
343 string sibsName = copy->tree[sibIndex].getName();
345 //if no is my sibling
346 if ((m->inUsersGroups(sibsName, Groups)) || (sibsName == "")) {
347 //i am not, but my sib is
348 int grandparent = copy->tree[parent].getParent();
349 int grandparentLC = copy->tree[grandparent].getLChild();
350 int grandparentRC = copy->tree[grandparent].getRChild();
352 //whichever of my granparents children was my parent now equals my sib
353 if (grandparentLC == parent) { grandparentLC = sibIndex; }
354 else { grandparentRC = sibIndex; }
356 copy->tree[sibIndex].setParent(grandparent);
357 copy->tree[sibIndex].setBranchLength((copy->tree[sibIndex].getBranchLength()+copy->tree[parent].getBranchLength()));
358 copy->tree[grandparent].setChildren(grandparentLC, grandparentRC);
359 removedLeaves.insert(i);
361 //neither of us are, so we want to eliminate ourselves and our parent
362 //so set our parents sib to our great-grandparent
363 int parent = copy->tree[i].getParent();
364 int grandparent = copy->tree[parent].getParent();
366 if (grandparent != -1) {
367 int greatgrandparent = copy->tree[grandparent].getParent();
368 int greatgrandparentLC = copy->tree[greatgrandparent].getLChild();
369 int greatgrandparentRC = copy->tree[greatgrandparent].getRChild();
371 int grandparentLC = copy->tree[grandparent].getLChild();
372 int grandparentRC = copy->tree[grandparent].getRChild();
374 parentsSibIndex = grandparentLC;
375 if (grandparentLC == parent) { parentsSibIndex = grandparentRC; }
377 //whichever of my greatgrandparents children was my grandparent
378 if (greatgrandparentLC == grandparent) { greatgrandparentLC = parentsSibIndex; }
379 else { greatgrandparentRC = parentsSibIndex; }
381 copy->tree[parentsSibIndex].setParent(greatgrandparent);
382 copy->tree[parentsSibIndex].setBranchLength((copy->tree[parentsSibIndex].getBranchLength()+copy->tree[grandparent].getBranchLength()));
383 copy->tree[greatgrandparent].setChildren(greatgrandparentLC, greatgrandparentRC);
385 copy->tree[parent].setChildren(-1, -1);
386 cout << "issues with making subtree" << endl;
388 removedLeaves.insert(sibIndex);
389 removedLeaves.insert(i);
397 for (int i = 0; i < copy->getNumNodes(); i++) {
399 if (copy->tree[i].getParent() == -1) { root = i; break; }
402 int nextSpot = numLeaves;
403 populateNewTree(copy->tree, root, nextSpot);
406 catch(exception& e) {
407 m->errorOut(e, "Tree", "getCopy");
411 /*****************************************************************/
412 int Tree::populateNewTree(vector<Node>& oldtree, int node, int& index) {
415 if (oldtree[node].getLChild() != -1) {
416 int rc = populateNewTree(oldtree, oldtree[node].getLChild(), index);
417 int lc = populateNewTree(oldtree, oldtree[node].getRChild(), index);
419 tree[index].setChildren(lc, rc);
420 tree[rc].setParent(index);
421 tree[lc].setParent(index);
423 tree[index].setBranchLength(oldtree[node].getBranchLength());
424 tree[rc].setBranchLength(oldtree[oldtree[node].getLChild()].getBranchLength());
425 tree[lc].setBranchLength(oldtree[oldtree[node].getRChild()].getBranchLength());
428 }else { //you are a leaf
429 int indexInNewTree = globaldata->gTreemap->getIndex(oldtree[node].getName());
430 return indexInNewTree;
433 catch(exception& e) {
434 m->errorOut(e, "Tree", "populateNewTree");
438 /*****************************************************************/
439 void Tree::getCopy(Tree* copy) {
442 //for each node in the tree copy its info
443 for (int i = 0; i < numNodes; i++) {
445 tree[i].setName(copy->tree[i].getName());
448 tree[i].setGroup(copy->tree[i].getGroup());
451 tree[i].setBranchLength(copy->tree[i].getBranchLength());
454 tree[i].setParent(copy->tree[i].getParent());
457 tree[i].setChildren(copy->tree[i].getLChild(), copy->tree[i].getRChild());
459 //copy index in node and tmap
460 tree[i].setIndex(copy->tree[i].getIndex());
461 setIndex(copy->tree[i].getName(), getIndex(copy->tree[i].getName()));
464 tree[i].pGroups = copy->tree[i].pGroups;
467 tree[i].pcount = copy->tree[i].pcount;
470 groupNodeInfo = copy->groupNodeInfo;
473 catch(exception& e) {
474 m->errorOut(e, "Tree", "getCopy");
478 /*****************************************************************/
479 //returns a map with a groupname and the number of times that group was seen in the children
480 //for instance if your children are white and black then it would return a map with 2 entries
481 // p[white] = 1 and p[black] = 1. Now go up a level and merge that with a node who has p[white] = 1
482 //and you get p[white] = 2, p[black] = 1, but you erase the p[black] because you have a p value higher than 1.
484 map<string, int> Tree::mergeGroups(int i) {
486 int lc = tree[i].getLChild();
487 int rc = tree[i].getRChild();
489 //set parsimony groups to left child
490 map<string,int> parsimony = tree[lc].pGroups;
494 //look at right child groups and update maxPars if right child has something higher for that group.
495 for(it=tree[rc].pGroups.begin();it!=tree[rc].pGroups.end();it++){
496 it2 = parsimony.find(it->first);
497 if (it2 != parsimony.end()) {
498 parsimony[it->first]++;
500 parsimony[it->first] = 1;
503 if(parsimony[it->first] > maxPars){
504 maxPars = parsimony[it->first];
508 // this is true if right child had a greater parsimony for a certain group
510 //erase all the groups that are only 1 because you found something with 2.
511 for(it=parsimony.begin();it!=parsimony.end();){
513 parsimony.erase(it++);
516 //set one remaining groups to 1
517 //so with our above example p[white] = 2 would be left and it would become p[white] = 1
518 for(it=parsimony.begin();it!=parsimony.end();it++){
519 parsimony[it->first] = 1;
526 catch(exception& e) {
527 m->errorOut(e, "Tree", "mergeGroups");
531 /*****************************************************************/
532 //returns a map with a groupname and the number of times that group was seen in the children
533 //for instance if your children are white and black then it would return a map with 2 entries
534 // p[white] = 1 and p[black] = 1. Now go up a level and merge that with a node who has p[white] = 1
535 //and you get p[white] = 2, p[black] = 1, but you erase the p[black] because you have a p value higher than 1.
537 map<string, int> Tree::mergeUserGroups(int i, vector<string> g) {
540 int lc = tree[i].getLChild();
541 int rc = tree[i].getRChild();
543 //loop through nodes groups removing the ones the user doesn't want
544 for(it=tree[lc].pGroups.begin();it!=tree[lc].pGroups.end();){
545 if (m->inUsersGroups(it->first, g) != true) {
546 tree[lc].pGroups.erase(it++);
550 //loop through nodes groups removing the ones the user doesn't want
551 for(it=tree[rc].pGroups.begin();it!=tree[rc].pGroups.end();){
552 if (m->inUsersGroups(it->first, g) != true) {
553 tree[rc].pGroups.erase(it++);
557 //set parsimony groups to left child
558 map<string,int> parsimony = tree[lc].pGroups;
562 //look at right child groups and update maxPars if right child has something higher for that group.
563 for(it=tree[rc].pGroups.begin();it!=tree[rc].pGroups.end();it++){
564 it2 = parsimony.find(it->first);
565 if (it2 != parsimony.end()) {
566 parsimony[it->first]++;
568 parsimony[it->first] = 1;
571 if(parsimony[it->first] > maxPars){
572 maxPars = parsimony[it->first];
576 // this is true if right child had a greater parsimony for a certain group
578 //erase all the groups that are only 1 because you found something with 2.
579 for(it=parsimony.begin();it!=parsimony.end();){
581 parsimony.erase(it++);
585 for(it=parsimony.begin();it!=parsimony.end();it++){
586 parsimony[it->first] = 1;
592 catch(exception& e) {
593 m->errorOut(e, "Tree", "mergeUserGroups");
599 /**************************************************************************************************/
601 map<string,int> Tree::mergeGcounts(int position) {
603 map<string,int>::iterator pos;
605 int lc = tree[position].getLChild();
606 int rc = tree[position].getRChild();
608 map<string,int> sum = tree[lc].pcount;
610 for(it=tree[rc].pcount.begin();it!=tree[rc].pcount.end();it++){
611 sum[it->first] += it->second;
615 catch(exception& e) {
616 m->errorOut(e, "Tree", "mergeGcounts");
620 /**************************************************************************************************/
622 void Tree::randomLabels(vector<string> g) {
625 //initialize groupNodeInfo
626 for (int i = 0; i < globaldata->gTreemap->namesOfGroups.size(); i++) {
627 groupNodeInfo[globaldata->gTreemap->namesOfGroups[i]].resize(0);
630 for(int i = 0; i < numLeaves; i++){
632 //get random index to switch with
633 z = int((float)(i+1) * (float)(rand()) / ((float)RAND_MAX+1.0));
635 //you only want to randomize the nodes that are from a group the user wants analyzed, so
636 //if either of the leaf nodes you are about to switch are not in the users groups then you don't want to switch them.
639 treez = m->inUsersGroups(tree[z].getGroup(), g);
640 treei = m->inUsersGroups(tree[i].getGroup(), g);
642 if ((treez == true) && (treei == true)) {
643 //switches node i and node z's info.
644 map<string,int> lib_hold = tree[z].pGroups;
645 tree[z].pGroups = (tree[i].pGroups);
646 tree[i].pGroups = (lib_hold);
648 vector<string> zgroup = tree[z].getGroup();
649 tree[z].setGroup(tree[i].getGroup());
650 tree[i].setGroup(zgroup);
652 string zname = tree[z].getName();
653 tree[z].setName(tree[i].getName());
654 tree[i].setName(zname);
656 map<string,int> gcount_hold = tree[z].pcount;
657 tree[z].pcount = (tree[i].pcount);
658 tree[i].pcount = (gcount_hold);
661 for (int k = 0; k < (tree[i].getGroup()).size(); k++) { groupNodeInfo[(tree[i].getGroup())[k]].push_back(i); }
662 for (int k = 0; k < (tree[z].getGroup()).size(); k++) { groupNodeInfo[(tree[z].getGroup())[k]].push_back(z); }
665 catch(exception& e) {
666 m->errorOut(e, "Tree", "randomLabels");
670 /**************************************************************************************************
672 void Tree::randomLabels(string groupA, string groupB) {
674 int numSeqsA = globaldata->gTreemap->seqsPerGroup[groupA];
675 int numSeqsB = globaldata->gTreemap->seqsPerGroup[groupB];
677 vector<string> randomGroups(numSeqsA+numSeqsB, groupA);
678 for(int i=numSeqsA;i<randomGroups.size();i++){
679 randomGroups[i] = groupB;
681 random_shuffle(randomGroups.begin(), randomGroups.end());
683 int randomCounter = 0;
684 for(int i=0;i<numLeaves;i++){
685 if(tree[i].getGroup() == groupA || tree[i].getGroup() == groupB){
686 tree[i].setGroup(randomGroups[randomCounter]);
687 tree[i].pcount.clear();
688 tree[i].pcount[randomGroups[randomCounter]] = 1;
689 tree[i].pGroups.clear();
690 tree[i].pGroups[randomGroups[randomCounter]] = 1;
695 catch(exception& e) {
696 m->errorOut(e, "Tree", "randomLabels");
700 /**************************************************************************************************/
701 void Tree::randomBlengths() {
703 for(int i=numNodes-1;i>=0;i--){
704 int z = int((float)(i+1) * (float)(rand()) / ((float)RAND_MAX+1.0));
706 float bl_hold = tree[z].getBranchLength();
707 tree[z].setBranchLength(tree[i].getBranchLength());
708 tree[i].setBranchLength(bl_hold);
711 catch(exception& e) {
712 m->errorOut(e, "Tree", "randomBlengths");
716 /*************************************************************************************************/
717 void Tree::assembleRandomUnifracTree(vector<string> g) {
719 assembleTree("noNameCounts");
721 /*************************************************************************************************/
722 void Tree::assembleRandomUnifracTree(string groupA, string groupB) {
724 vector<string> temp; temp.push_back(groupA); temp.push_back(groupB);
726 assembleTree("noNameCounts");
729 /*************************************************************************************************/
730 //for now it's just random topology but may become random labels as well later that why this is such a simple function now...
731 void Tree::assembleRandomTree() {
735 /**************************************************************************************************/
737 void Tree::randomTopology() {
739 for(int i=0;i<numNodes;i++){
740 tree[i].setParent(-1);
742 for(int i=numLeaves;i<numNodes;i++){
743 tree[i].setChildren(-1, -1);
746 for(int i=numLeaves;i<numNodes;i++){
748 int rnd_index1, rnd_index2;
750 rnd_index1 = (int)(((double)rand() / (double) RAND_MAX)*i);
751 if(tree[rnd_index1].getParent() == -1){escape = 1;}
756 rnd_index2 = (int)(((double)rand() / (double) RAND_MAX)*i);
757 if(rnd_index2 != rnd_index1 && tree[rnd_index2].getParent() == -1){
762 tree[i].setChildren(rnd_index1,rnd_index2);
763 tree[i].setParent(-1);
764 tree[rnd_index1].setParent(i);
765 tree[rnd_index2].setParent(i);
768 catch(exception& e) {
769 m->errorOut(e, "Tree", "randomTopology");
773 /*****************************************************************/
774 void Tree::print(ostream& out) {
776 int root = findRoot();
777 printBranch(root, out, "branch");
780 catch(exception& e) {
781 m->errorOut(e, "Tree", "print");
785 /*****************************************************************/
786 void Tree::print(ostream& out, string mode) {
788 int root = findRoot();
789 printBranch(root, out, mode);
792 catch(exception& e) {
793 m->errorOut(e, "Tree", "print");
797 /*****************************************************************/
798 // This prints out the tree in Newick form.
799 void Tree::createNewickFile(string f) {
801 int root = findRoot();
802 //filename = m->getRootName(globaldata->getTreeFile()) + "newick";
805 m->openOutputFile(filename, out);
807 printBranch(root, out, "branch");
809 // you are at the end of the tree
813 catch(exception& e) {
814 m->errorOut(e, "Tree", "createNewickFile");
819 /*****************************************************************/
820 //This function finds the index of the root node.
822 int Tree::findRoot() {
824 for (int i = 0; i < numNodes; i++) {
826 if (tree[i].getParent() == -1) { return i; }
827 //cout << "i = " << i << endl;
828 //cout << "i's parent = " << tree[i].getParent() << endl;
832 catch(exception& e) {
833 m->errorOut(e, "Tree", "findRoot");
837 /*****************************************************************/
838 void Tree::printBranch(int node, ostream& out, string mode) {
841 // you are not a leaf
842 if (tree[node].getLChild() != -1) {
844 printBranch(tree[node].getLChild(), out, mode);
846 printBranch(tree[node].getRChild(), out, mode);
848 if (mode == "branch") {
849 //if there is a branch length then print it
850 if (tree[node].getBranchLength() != -1) {
851 out << ":" << tree[node].getBranchLength();
853 }else if (mode == "boot") {
854 //if there is a label then print it
855 if (tree[node].getLabel() != -1) {
856 out << tree[node].getLabel();
858 }else if (mode == "both") {
859 if (tree[node].getLabel() != -1) {
860 out << tree[node].getLabel();
862 //if there is a branch length then print it
863 if (tree[node].getBranchLength() != -1) {
864 out << ":" << tree[node].getBranchLength();
867 }else { //you are a leaf
868 string leafGroup = globaldata->gTreemap->getGroup(tree[node].getName());
870 if (mode == "branch") {
872 //if there is a branch length then print it
873 if (tree[node].getBranchLength() != -1) {
874 out << ":" << tree[node].getBranchLength();
876 }else if (mode == "boot") {
878 //if there is a label then print it
879 if (tree[node].getLabel() != -1) {
880 out << tree[node].getLabel();
882 }else if (mode == "both") {
883 out << tree[node].getName();
884 if (tree[node].getLabel() != -1) {
885 out << tree[node].getLabel();
887 //if there is a branch length then print it
888 if (tree[node].getBranchLength() != -1) {
889 out << ":" << tree[node].getBranchLength();
895 catch(exception& e) {
896 m->errorOut(e, "Tree", "printBranch");
900 /*****************************************************************/
901 void Tree::printBranch(int node, ostream& out, string mode, vector<Node>& theseNodes) {
904 // you are not a leaf
905 if (theseNodes[node].getLChild() != -1) {
907 printBranch(theseNodes[node].getLChild(), out, mode);
909 printBranch(theseNodes[node].getRChild(), out, mode);
911 if (mode == "branch") {
912 //if there is a branch length then print it
913 if (theseNodes[node].getBranchLength() != -1) {
914 out << ":" << theseNodes[node].getBranchLength();
916 }else if (mode == "boot") {
917 //if there is a label then print it
918 if (theseNodes[node].getLabel() != -1) {
919 out << theseNodes[node].getLabel();
921 }else if (mode == "both") {
922 if (theseNodes[node].getLabel() != -1) {
923 out << theseNodes[node].getLabel();
925 //if there is a branch length then print it
926 if (theseNodes[node].getBranchLength() != -1) {
927 out << ":" << theseNodes[node].getBranchLength();
930 }else { //you are a leaf
931 string leafGroup = globaldata->gTreemap->getGroup(theseNodes[node].getName());
933 if (mode == "branch") {
935 //if there is a branch length then print it
936 if (theseNodes[node].getBranchLength() != -1) {
937 out << ":" << theseNodes[node].getBranchLength();
939 }else if (mode == "boot") {
941 //if there is a label then print it
942 if (theseNodes[node].getLabel() != -1) {
943 out << theseNodes[node].getLabel();
945 }else if (mode == "both") {
946 out << theseNodes[node].getName();
947 if (theseNodes[node].getLabel() != -1) {
948 out << theseNodes[node].getLabel();
950 //if there is a branch length then print it
951 if (theseNodes[node].getBranchLength() != -1) {
952 out << ":" << theseNodes[node].getBranchLength();
958 catch(exception& e) {
959 m->errorOut(e, "Tree", "printBranch");
963 /*****************************************************************/
965 void Tree::printTree() {
967 for(int i=0;i<numNodes;i++){
974 /*****************************************************************/
975 //this code is a mess and should be rethought...-slw
976 void Tree::parseTreeFile() {
978 //only takes names from the first tree and assumes that all trees use the same names.
980 string filename = globaldata->getTreeFile();
982 m->openInputFile(filename, filehandle);
987 //ifyou are not a nexus file
988 if((c = filehandle.peek()) != '#') {
989 while((c = filehandle.peek()) != ';') {
990 while ((c = filehandle.peek()) != ';') {
998 if((c == '(') && (comment != 1)){ break; }
1002 done = readTreeString(filehandle);
1003 if (done == 0) { break; }
1005 //ifyou are a nexus file
1006 }else if((c = filehandle.peek()) == '#') {
1009 // get past comments
1010 while(holder != "translate" && holder != "Translate"){
1011 if(holder == "[" || holder == "[!"){
1017 filehandle >> holder;
1019 //if there is no translate then you must read tree string otherwise use translate to get names
1020 if((holder == "tree") && (comment != 1)){
1021 //pass over the "tree rep.6878900 = "
1022 while (((c = filehandle.get()) != '(') && ((c = filehandle.peek()) != EOF)) {;}
1024 if(c == EOF) { break; }
1025 filehandle.putback(c); //put back first ( of tree.
1026 done = readTreeString(filehandle);
1031 if (done == 0) { break; }
1034 //use nexus translation rather than parsing tree to save time
1035 if((holder == "translate") || (holder == "Translate")) {
1037 string number, name, h;
1038 h = ""; // so it enters the loop the first time
1039 while((h != ";") && (number != ";")) {
1040 filehandle >> number;
1043 //c = , until done with translation then c = ;
1044 h = name.substr(name.length()-1, name.length());
1045 name.erase(name.end()-1); //erase the comma
1046 globaldata->Treenames.push_back(number);
1048 if(number == ";") { globaldata->Treenames.pop_back(); } //in case ';' from translation is on next line instead of next to last name
1053 //for (int i = 0; i < globaldata->Treenames.size(); i++) {
1054 //cout << globaldata->Treenames[i] << endl; }
1055 //cout << globaldata->Treenames.size() << endl;
1057 catch(exception& e) {
1058 m->errorOut(e, "Tree", "parseTreeFile");
1062 /*******************************************************/
1064 /*******************************************************/
1065 int Tree::readTreeString(ifstream& filehandle) {
1070 while((c = filehandle.peek()) != ';') {
1072 //cout << " at beginning of while " << k << endl;
1074 //to pass over labels in trees
1076 while((c!=',') && (c != -1) && (c!= ':') && (c!=';')){ c=filehandle.get(); }
1077 filehandle.putback(c);
1079 if(c == ';') { return 0; }
1080 if(c == -1) { return 0; }
1082 if((c != '(') && (c != ')') && (c != ',') && (c != ':') && (c != '\n') && (c != '\t') && (c != 32)) { //32 is space
1084 c = filehandle.get();
1086 //cout << k << endl;
1087 while ((c != '(') && (c != ')') && (c != ',') && (c != ':') && (c != '\n') && (c != 32) && (c != '\t')) {
1089 c = filehandle.get();
1091 //cout << " in name while " << k << endl;
1094 //cout << "name = " << name << endl;
1095 globaldata->Treenames.push_back(name);
1096 filehandle.putback(c);
1098 //cout << " after putback" << k << endl;
1101 if(c == ':') { //read until you reach the end of the branch length
1102 while ((c != '(') && (c != ')') && (c != ',') && (c != ';') && (c != '\n') && (c != '\t') && (c != 32)) {
1103 c = filehandle.get();
1105 //cout << " in branch while " << k << endl;
1107 filehandle.putback(c);
1110 c = filehandle.get();
1112 //cout << " here after get " << k << endl;
1113 if(c == ';') { return 0; }
1114 if(c == ')') { filehandle.putback(c); }
1116 //cout << k << endl;
1121 catch(exception& e) {
1122 m->errorOut(e, "Tree", "readTreeString");
1127 /*******************************************************/
1129 /*******************************************************/