readtreecommand.cpp

   1 /*
   2  *  readtreecommand.cpp
   3  *  Mothur
   4  *
   5  *  Created by Sarah Westcott on 1/23/09.
   6  *  Copyright 2009 Schloss Lab UMASS Amherst. All rights reserved.
   7  *
   8  */
   9
  10 #include "readtreecommand.h"
  11
  12 //**********************************************************************************************************************
  13 ReadTreeCommand::ReadTreeCommand(string option){
  14         try {
  15                 globaldata = GlobalData::getInstance();
  16                 abort = false;
  17
  18                 //allow user to run help
  19                 if(option == "help") { help(); abort = true; }
  20
  21                 else {
  22                         //valid paramters for this command
  23                         string Array[] =  {"tree","group","outputdir","inputdir"};
  24                         vector<string> myArray (Array, Array+(sizeof(Array)/sizeof(string)));
  25
  26                         OptionParser parser(option);
  27                         map<string, string> parameters = parser.getParameters();
  28
  29                         ValidParameters validParameter;
  30                         map<string, string>::iterator it;
  31
  32                         //check to make sure all parameters are valid for command
  33                         for (it = parameters.begin(); it != parameters.end(); it++) {
  34                                 if (validParameter.isValidParameter(it->first, myArray, it->second) != true) {  abort = true;  }
  35                         }
  36
  37                         globaldata->newRead();
  38
  39                         //if the user changes the input directory command factory will send this info to us in the output parameter
  40                         string inputDir = validParameter.validFile(parameters, "inputdir", false);
  41                         if (inputDir == "not found"){   inputDir = "";          }
  42                         else {
  43                                 string path;
  44                                 it = parameters.find("tree");
  45                                 //user has given a template file
  46                                 if(it != parameters.end()){
  47                                         path = hasPath(it->second);
  48                                         //if the user has not given a path then, add inputdir. else leave path alone.
  49                                         if (path == "") {       parameters["tree"] = inputDir + it->second;             }
  50                                 }
  51
  52                                 it = parameters.find("group");
  53                                 //user has given a template file
  54                                 if(it != parameters.end()){
  55                                         path = hasPath(it->second);
  56                                         //if the user has not given a path then, add inputdir. else leave path alone.
  57                                         if (path == "") {       parameters["group"] = inputDir + it->second;            }
  58                                 }
  59                         }
  60
  61
  62                         //check for required parameters
  63                         treefile = validParameter.validFile(parameters, "tree", true);
  64                         if (treefile == "not open") { abort = true; }
  65                         else if (treefile == "not found") { treefile = ""; mothurOut("tree is a required parameter for the read.tree command."); mothurOutEndLine(); abort = true;  }
  66                         else {  globaldata->setTreeFile(treefile);  globaldata->setFormat("tree");      }
  67
  68                         groupfile = validParameter.validFile(parameters, "group", true);
  69                         if (groupfile == "not open") { abort = true; }
  70                         else if (groupfile == "not found") { groupfile = ""; mothurOut("group is a required parameter for the read.tree command."); mothurOutEndLine(); abort = true;   }
  71                         else {
  72                                 globaldata->setGroupFile(groupfile);
  73                                 //read in group map info.
  74                                 treeMap = new TreeMap(groupfile);
  75                                 treeMap->readMap();
  76                                 globaldata->gTreemap = treeMap;
  77                         }
  78
  79                         if (abort == false) {
  80                                 filename = treefile;
  81                                 read = new ReadNewickTree(filename);
  82                         }
  83
  84                 }
  85         }
  86         catch(exception& e) {
  87                 errorOut(e, "ReadTreeCommand", "ReadTreeCommand");
  88                 exit(1);
  89         }
  90 }
  91 //**********************************************************************************************************************
  92
  93 void ReadTreeCommand::help(){
  94         try {
  95                 mothurOut("The read.tree command must be run before you execute a unifrac.weighted, unifrac.unweighted. \n");
  96                 mothurOut("It also must be run before using the parsimony command, unless you are using the randomtree parameter.\n");
  97                 mothurOut("The read.tree command should be in the following format: read.tree(tree=yourTreeFile, group=yourGroupFile).\n");
  98                 mothurOut("The tree and group parameters are both required.\n");
  99                 mothurOut("Note: No spaces between parameter labels (i.e. tree), '=' and parameters (i.e.yourTreefile).\n\n");
 100         }
 101         catch(exception& e) {
 102                 errorOut(e, "ReadTreeCommand", "help");
 103                 exit(1);
 104         }
 105 }
 106
 107 //**********************************************************************************************************************
 108
 109 ReadTreeCommand::~ReadTreeCommand(){
 110         if (abort == false) { delete read; }
 111 }
 112
 113 //**********************************************************************************************************************
 114
 115 int ReadTreeCommand::execute(){
 116         try {
 117
 118                 if (abort == true) { return 0; }
 119
 120                 int readOk;
 121
 122                 readOk = read->read();
 123
 124                 if (readOk != 0) { mothurOut("Read Terminated."); mothurOutEndLine(); globaldata->gTree.clear(); delete globaldata->gTreemap; return 0; }
 125
 126                 vector<Tree*> T = globaldata->gTree;
 127
 128                 //assemble users trees
 129                 for (int i = 0; i < T.size(); i++) {
 130                         T[i]->assembleTree();
 131                 }
 132
 133                 //output any names that are in names file but not in tree
 134                 if (globaldata->Treenames.size() < treeMap->getNumSeqs()) {
 135                         for (int i = 0; i < treeMap->namesOfSeqs.size(); i++) {
 136                                 //is that name in the tree?
 137                                 int count = 0;
 138                                 for (int j = 0; j < globaldata->Treenames.size(); j++) {
 139                                         if (treeMap->namesOfSeqs[i] == globaldata->Treenames[j]) { break; } //found it
 140                                         count++;
 141                                 }
 142
 143                                 //then you did not find it so report it
 144                                 if (count == globaldata->Treenames.size()) {
 145                                         mothurOut(treeMap->namesOfSeqs[i] + " is in your namefile and not in your tree. It will be disregarded."); mothurOutEndLine();
 146                                         treeMap->removeSeq(treeMap->namesOfSeqs[i]);
 147                                 }
 148                         }
 149                 }
 150
 151                 return 0;
 152         }
 153         catch(exception& e) {
 154                 errorOut(e, "ReadTreeCommand", "execute");
 155                 exit(1);
 156         }
 157 }
 158
 159 //**********************************************************************************************************************