collectsharedcommand.cpp

   1 /*
   2  *  collectsharedcommand.cpp
   3  *  Dotur
   4  *
   5  *  Created by Sarah Westcott on 1/2/09.
   6  *  Copyright 2009 Schloss Lab UMASS Amherst. All rights reserved.
   7  *
   8  */
   9
  10 #include "collectsharedcommand.h"
  11 #include "sharedsobscollectsummary.h"
  12 #include "sharedchao1.h"
  13 #include "sharedace.h"
  14 #include "sharedjabund.h"
  15 #include "sharedsorabund.h"
  16 #include "sharedjclass.h"
  17 #include "sharedsorclass.h"
  18 #include "sharedjest.h"
  19 #include "sharedsorest.h"
  20 #include "sharedthetayc.h"
  21 #include "sharedthetan.h"
  22 #include "sharedkstest.h"
  23 #include "whittaker.h"
  24 #include "sharednseqs.h"
  25 #include "sharedochiai.h"
  26 #include "sharedanderbergs.h"
  27 #include "sharedkulczynski.h"
  28 #include "sharedkulczynskicody.h"
  29 #include "sharedlennon.h"
  30 #include "sharedmorisitahorn.h"
  31 #include "sharedbraycurtis.h"
  32 #include "sharedjackknife.h"
  33 #include "whittaker.h"
  34
  35
  36
  37 //**********************************************************************************************************************
  38
  39 CollectSharedCommand::CollectSharedCommand(string option){
  40         try {
  41                 globaldata = GlobalData::getInstance();
  42                 abort = false;
  43                 allLines = 1;
  44                 labels.clear();
  45                 Estimators.clear();
  46                 Groups.clear();
  47
  48                 //allow user to run help
  49                 if(option == "help") { validCalculator = new ValidCalculators(); help(); abort = true; }
  50
  51                 else {
  52                         //valid paramters for this command
  53                         string Array[] =  {"freq","label","calc","groups","all","outputdir","inputdir"};
  54                         vector<string> myArray (Array, Array+(sizeof(Array)/sizeof(string)));
  55
  56                         OptionParser parser(option);
  57                         map<string,string> parameters=parser.getParameters();
  58
  59                         ValidParameters validParameter;
  60
  61                         //check to make sure all parameters are valid for command
  62                         for (map<string,string>::iterator it = parameters.begin(); it != parameters.end(); it++) {
  63                                 if (validParameter.isValidParameter(it->first, myArray, it->second) != true) {  abort = true;  }
  64                         }
  65
  66                         //if the user changes the output directory command factory will send this info to us in the output parameter
  67                         outputDir = validParameter.validFile(parameters, "outputdir", false);           if (outputDir == "not found"){  outputDir = "";         }
  68
  69
  70                         //make sure the user has already run the read.otu command
  71                         if (globaldata->getSharedFile() == "") {
  72                                 if (globaldata->getListFile() == "") { mothurOut("You must read a list and a group, or a shared before you can use the collect.shared command."); mothurOutEndLine(); abort = true; }
  73                                 else if (globaldata->getGroupFile() == "") { mothurOut("You must read a list and a group, or a shared before you can use the collect.shared command."); mothurOutEndLine(); abort = true; }
  74                         }
  75
  76
  77                         //check for optional parameter and set defaults
  78                         // ...at some point should added some additional type checking..
  79                         label = validParameter.validFile(parameters, "label", false);
  80                         if (label == "not found") { label = ""; }
  81                         else {
  82                                 if(label != "all") {  splitAtDash(label, labels);  allLines = 0;  }
  83                                 else { allLines = 1;  }
  84                         }
  85
  86                         //if the user has not specified any labels use the ones from read.otu
  87                         if(label == "") {
  88                                 allLines = globaldata->allLines;
  89                                 labels = globaldata->labels;
  90                         }
  91
  92                         calc = validParameter.validFile(parameters, "calc", false);
  93                         if (calc == "not found") { calc = "sharedsobs-sharedchao-sharedace-jabund-sorabund-jclass-sorclass-jest-sorest-thetayc-thetan";  }
  94                         else {
  95                                  if (calc == "default")  {  calc = "sharedsobs-sharedchao-sharedace-jabund-sorabund-jclass-sorclass-jest-sorest-thetayc-thetan";  }
  96                         }
  97                         splitAtDash(calc, Estimators);
  98
  99                         groups = validParameter.validFile(parameters, "groups", false);
 100                         if (groups == "not found") { groups = ""; }
 101                         else {
 102                                 splitAtDash(groups, Groups);
 103                         }
 104                         globaldata->Groups = Groups;
 105
 106                         string temp;
 107                         temp = validParameter.validFile(parameters, "freq", false);                     if (temp == "not found") { temp = "100"; }
 108                         convert(temp, freq);
 109
 110                         temp = validParameter.validFile(parameters, "all", false);                              if (temp == "not found") { temp = "false"; }
 111                         all = isTrue(temp);
 112
 113                         if (abort == false) {
 114
 115                                 if (outputDir == "") { outputDir += hasPath(globaldata->inputFileName); }
 116                                 string fileNameRoot = outputDir + getRootName(getSimpleName(globaldata->inputFileName));
 117                                 format = globaldata->getFormat();
 118                                 int i;
 119
 120                                 validCalculator = new ValidCalculators();
 121                                 util = new SharedUtil();
 122
 123                                 for (i=0; i<Estimators.size(); i++) {
 124                                         if (validCalculator->isValidCalculator("shared", Estimators[i]) == true) {
 125                                                 if (Estimators[i] == "sharedchao") {
 126                                                         cDisplays.push_back(new CollectDisplay(new SharedChao1(), new SharedOneColumnFile(fileNameRoot+"shared.chao")));
 127                                                 }else if (Estimators[i] == "sharedsobs") {
 128                                                         cDisplays.push_back(new CollectDisplay(new SharedSobsCS(), new SharedOneColumnFile(fileNameRoot+"shared.sobs")));
 129                                                 }else if (Estimators[i] == "sharedace") {
 130                                                         cDisplays.push_back(new CollectDisplay(new SharedAce(), new SharedOneColumnFile(fileNameRoot+"shared.ace")));
 131                                                 }else if (Estimators[i] == "jabund") {
 132                                                         cDisplays.push_back(new CollectDisplay(new JAbund(), new SharedOneColumnFile(fileNameRoot+"jabund")));
 133                                                 }else if (Estimators[i] == "sorabund") {
 134                                                         cDisplays.push_back(new CollectDisplay(new SorAbund(), new SharedOneColumnFile(fileNameRoot+"sorabund")));
 135                                                 }else if (Estimators[i] == "jclass") {
 136                                                         cDisplays.push_back(new CollectDisplay(new Jclass(), new SharedOneColumnFile(fileNameRoot+"jclass")));
 137                                                 }else if (Estimators[i] == "sorclass") {
 138                                                         cDisplays.push_back(new CollectDisplay(new SorClass(), new SharedOneColumnFile(fileNameRoot+"sorclass")));
 139                                                 }else if (Estimators[i] == "jest") {
 140                                                         cDisplays.push_back(new CollectDisplay(new Jest(), new SharedOneColumnFile(fileNameRoot+"jest")));
 141                                                 }else if (Estimators[i] == "sorest") {
 142                                                         cDisplays.push_back(new CollectDisplay(new SorEst(), new SharedOneColumnFile(fileNameRoot+"sorest")));
 143                                                 }else if (Estimators[i] == "thetayc") {
 144                                                         cDisplays.push_back(new CollectDisplay(new ThetaYC(), new SharedOneColumnFile(fileNameRoot+"thetayc")));
 145                                                 }else if (Estimators[i] == "thetan") {
 146                                                         cDisplays.push_back(new CollectDisplay(new ThetaN(), new SharedOneColumnFile(fileNameRoot+"thetan")));
 147                                                 }else if (Estimators[i] == "kstest") {
 148                                                         cDisplays.push_back(new CollectDisplay(new KSTest(), new SharedOneColumnFile(fileNameRoot+"kstest")));
 149                                                 }else if (Estimators[i] == "whittaker") {
 150                                                         cDisplays.push_back(new CollectDisplay(new Whittaker(), new SharedOneColumnFile(fileNameRoot+"whittaker")));
 151                                                 }else if (Estimators[i] == "sharednseqs") {
 152                                                         cDisplays.push_back(new CollectDisplay(new SharedNSeqs(), new SharedOneColumnFile(fileNameRoot+"shared.nseqs")));
 153                                                 }else if (Estimators[i] == "ochiai") {
 154                                                         cDisplays.push_back(new CollectDisplay(new Ochiai(), new SharedOneColumnFile(fileNameRoot+"ochiai")));
 155                                                 }else if (Estimators[i] == "anderberg") {
 156                                                         cDisplays.push_back(new CollectDisplay(new Anderberg(), new SharedOneColumnFile(fileNameRoot+"anderberg")));
 157                                                 }else if (Estimators[i] == "skulczynski") {
 158                                                         cDisplays.push_back(new CollectDisplay(new Kulczynski(), new SharedOneColumnFile(fileNameRoot+"kulczynski")));
 159                                                 }else if (Estimators[i] == "kulczynskicody") {
 160                                                         cDisplays.push_back(new CollectDisplay(new KulczynskiCody(), new SharedOneColumnFile(fileNameRoot+"kulczynskicody")));
 161                                                 }else if (Estimators[i] == "lennon") {
 162                                                         cDisplays.push_back(new CollectDisplay(new Lennon(), new SharedOneColumnFile(fileNameRoot+"lennon")));
 163                                                 }else if (Estimators[i] == "morisitahorn") {
 164                                                         cDisplays.push_back(new CollectDisplay(new MorHorn(), new SharedOneColumnFile(fileNameRoot+"morisitahorn")));
 165                                                 }else if (Estimators[i] == "braycurtis") {
 166                                                         cDisplays.push_back(new CollectDisplay(new BrayCurtis(), new SharedOneColumnFile(fileNameRoot+"braycurtis")));
 167                                                 }
 168                                         }
 169                                 }
 170                         }
 171                 }
 172
 173         }
 174         catch(exception& e) {
 175                 errorOut(e, "CollectSharedCommand", "CollectSharedCommand");
 176                 exit(1);
 177         }
 178 }
 179 //**********************************************************************************************************************
 180
 181 void CollectSharedCommand::help(){
 182         try {
 183                 mothurOut("The collect.shared command can only be executed after a successful read.otu command.\n");
 184                 mothurOut("The collect.shared command parameters are label, freq, calc and groups.  No parameters are required \n");
 185                 mothurOut("The collect.shared command should be in the following format: \n");
 186                 mothurOut("collect.shared(label=yourLabel, freq=yourFreq, calc=yourEstimators, groups=yourGroups).\n");
 187                 mothurOut("Example collect.shared(label=unique-.01-.03, freq=10, groups=B-C, calc=sharedchao-sharedace-jabund-sorensonabund-jclass-sorclass-jest-sorest-thetayc-thetan).\n");
 188                 mothurOut("The default values for freq is 100 and calc are sharedsobs-sharedchao-sharedace-jabund-sorensonabund-jclass-sorclass-jest-sorest-thetayc-thetan.\n");
 189                 mothurOut("The default value for groups is all the groups in your groupfile.\n");
 190                 validCalculator->printCalc("shared", cout);
 191                 mothurOut("The label parameter is used to analyze specific labels in your input.\n");
 192                 mothurOut("The all parameter is used to specify if you want the estimate of all your groups together.  This estimate can only be made for sharedsobs and sharedchao calculators. The default is false.\n");
 193                 mothurOut("If you use sharedchao and run into memory issues, set all to false. \n");
 194                 mothurOut("The groups parameter allows you to specify which of the groups in your groupfile you would like analyzed.  You must enter at least 2 valid groups.\n");
 195                 mothurOut("Note: No spaces between parameter labels (i.e. list), '=' and parameters (i.e.yourListfile).\n\n");
 196
 197         }
 198         catch(exception& e) {
 199                 errorOut(e, "CollectSharedCommand", "help");
 200                 exit(1);
 201         }
 202 }
 203
 204 //**********************************************************************************************************************
 205
 206 CollectSharedCommand::~CollectSharedCommand(){
 207         if (abort == false) {
 208                 delete input; globaldata->ginput = NULL;
 209                 delete read;
 210                 delete util;
 211                 delete validCalculator;
 212                 globaldata->gorder = NULL;
 213         }
 214 }
 215
 216 //**********************************************************************************************************************
 217
 218 int CollectSharedCommand::execute(){
 219         try {
 220
 221                 if (abort == true) {    return 0;       }
 222
 223                 //if the users entered no valid calculators don't execute command
 224                 if (cDisplays.size() == 0) { return 0; }
 225                 for(int i=0;i<cDisplays.size();i++){    cDisplays[i]->setAll(all);      }
 226
 227                 read = new ReadOTUFile(globaldata->inputFileName);
 228                 read->read(&*globaldata);
 229
 230                 input = globaldata->ginput;
 231                 order = input->getSharedOrderVector();
 232                 string lastLabel = order->getLabel();
 233
 234                 //if the users enters label "0.06" and there is no "0.06" in their file use the next lowest label.
 235                 set<string> processedLabels;
 236                 set<string> userLabels = labels;
 237
 238                 //set users groups
 239                 util->setGroups(globaldata->Groups, globaldata->gGroupmap->namesOfGroups, "collect");
 240                 util->updateGroupIndex(globaldata->Groups, globaldata->gGroupmap->groupIndex);
 241
 242                 while((order != NULL) && ((allLines == 1) || (userLabels.size() != 0))) {
 243
 244                         if(allLines == 1 || labels.count(order->getLabel()) == 1){
 245
 246                                 //create collectors curve
 247                                 cCurve = new Collect(order, cDisplays);
 248                                 cCurve->getSharedCurve(freq);
 249                                 delete cCurve;
 250
 251                                 mothurOut(order->getLabel()); mothurOutEndLine();
 252                                 processedLabels.insert(order->getLabel());
 253                                 userLabels.erase(order->getLabel());
 254                         }
 255
 256                         //you have a label the user want that is smaller than this label and the last label has not already been processed
 257                         if ((anyLabelsToProcess(order->getLabel(), userLabels, "") == true) && (processedLabels.count(lastLabel) != 1)) {
 258                                 string saveLabel = order->getLabel();
 259
 260                                 delete order;
 261                                 order = input->getSharedOrderVector(lastLabel);
 262
 263                                 //create collectors curve
 264                                 cCurve = new Collect(order, cDisplays);
 265                                 cCurve->getSharedCurve(freq);
 266                                 delete cCurve;
 267
 268                                 mothurOut(order->getLabel()); mothurOutEndLine();
 269                                 processedLabels.insert(order->getLabel());
 270                                 userLabels.erase(order->getLabel());
 271
 272                                 //restore real lastlabel to save below
 273                                 order->setLabel(saveLabel);
 274                         }
 275
 276
 277                         lastLabel = order->getLabel();
 278
 279                         //get next line to process
 280                         delete order;
 281                         order = input->getSharedOrderVector();
 282                 }
 283
 284                 //output error messages about any remaining user labels
 285                 set<string>::iterator it;
 286                 bool needToRun = false;
 287                 for (it = userLabels.begin(); it != userLabels.end(); it++) {
 288                         mothurOut("Your file does not include the label " + *it);
 289                         if (processedLabels.count(lastLabel) != 1) {
 290                                 mothurOut(". I will use " + lastLabel + "."); mothurOutEndLine();
 291                                 needToRun = true;
 292                         }else {
 293                                 mothurOut(". Please refer to " + lastLabel + "."); mothurOutEndLine();
 294                         }
 295                 }
 296
 297                 //run last label if you need to
 298                 if (needToRun == true)  {
 299                         if (order != NULL) {  delete order;  }
 300                         order = input->getSharedOrderVector(lastLabel);
 301
 302                         cCurve = new Collect(order, cDisplays);
 303                         cCurve->getSharedCurve(freq);
 304                         delete cCurve;
 305
 306                         mothurOut(order->getLabel()); mothurOutEndLine();
 307                         delete order;
 308                 }
 309
 310                 for(int i=0;i<cDisplays.size();i++){    delete cDisplays[i];    }
 311
 312                 //reset groups parameter
 313                 globaldata->Groups.clear();
 314
 315                 return 0;
 316         }
 317         catch(exception& e) {
 318                 errorOut(e, "CollectSharedCommand", "execute");
 319                 exit(1);
 320         }
 321 }
 322
 323 /***********************************************************/