validparameter.cpp

   1 /*
   2  *  validparameter.cpp
   3  *  Dotur
   4  *
   5  *  Created by Sarah Westcott on 1/5/09.
   6  *  Copyright 2009 Schloss Lab UMASS Amherst. All rights reserved.
   7  *
   8  */
   9
  10 #include "validparameter.h"
  11
  12 /***********************************************************************/
  13
  14 ValidParameters::ValidParameters() {
  15         try {
  16                 parameters["phylip"]            = "phylip";
  17                 parameters["column"]                = "column";
  18                 parameters["list"]                      = "list";
  19                 parameters["rabund"]            = "rabund";
  20                 parameters["sabund"]            = "sabund";
  21                 parameters["name"]                      = "name";
  22                 parameters["group"]                     = "group";
  23                 parameters["order"]             = "order";
  24                 parameters["fasta"]                         = "fasta";
  25                 parameters["tree"]                      = "tree";
  26                 parameters["fileroot"]                  = "fileroot";
  27                 parameters["cutoff"]                    = "cutoff";
  28                 parameters["method"]                    = "method";
  29                 parameters["format"]                    = "format";
  30                 parameters["precision"]                 = "precision";
  31                 parameters["label"]                             = "label";
  32                 parameters["line"]                              = "line";
  33                 parameters["iters"]                             = "iters";
  34                 parameters["jumble"]                    = "jumble";
  35                 parameters["freq"]                              = "freq";
  36                 parameters["abund"]             = "abund";
  37                 parameters["random"]                    = "random";
  38                 parameters["groups"]                    = "groups";
  39                 parameters["calc"]                              = "calc";
  40                 parameters["sharedrarefaction"] = "sharedrarefaction";
  41                 parameters["sharedsummary"]     = "sharedsummary";
  42                 parameters["shared"]            = "shared";
  43                 parameters["single"]            = "single";
  44                 parameters["rarefaction"]       = "rarefaction";
  45
  46                 initCommandParameters();
  47                 initParameterRanges();
  48         }
  49         catch(exception& e) {
  50                 cout << "Standard Error: " << e.what() << " has occurred in the ValidParameters class Function ValidParameters. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
  51                 exit(1);
  52         }
  53         catch(...) {
  54                 cout << "An unknown error has occurred in the ValidParameters class function ValidParameters. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
  55                 exit(1);
  56         }
  57 }
  58
  59 /***********************************************************************/
  60
  61 ValidParameters::~ValidParameters() {}
  62
  63
  64 /***********************************************************************/
  65 bool ValidParameters::isValidParameter(string parameter, string command, string value) {
  66         try {
  67                 bool valid = false;
  68                 vector<string> cParams = commandParameters[command];
  69                 int numParams = cParams.size();
  70                 for(int i = 0; i < numParams; i++)
  71                 {
  72                         if(cParams.at(i).compare(parameter) == 0)
  73                         {
  74                                 valid = true;
  75                                 i = numParams;
  76                         }
  77                 }
  78                 if(!valid)
  79                 {
  80                         cout << "'" << parameter << "' is not a valid parameter for the " << command << " command.\n";
  81                         return false;
  82                 }
  83
  84                 if(parameterRanges.count(parameter) != 1)
  85                         return true;
  86
  87                 int pVal;
  88                 double piSentinel = 3.14159;
  89                 vector<string> range = parameterRanges[parameter];
  90
  91                 valid = convertTest(value, pVal);
  92
  93                 if(!valid)
  94                         return false;
  95
  96
  97
  98                 /********************************************************************************************************
  99                        Special Cases
 100             *********************************************************************************************************/
 101
 102                 if(parameter.compare("precision") == 0)
 103                 {
 104                         double logNum = log10((double)pVal);
 105                         double diff = (double)((int)logNum - logNum);
 106                         if(diff != 0)
 107                         {
 108                                 cout << "The precision parameter can only take powers of 10 as a value (e.g. 10,1000,1000, etc.)\n";
 109                                 return false;
 110                         }
 111                 }
 112
 113                 /************************************************************************************************************/
 114
 115
 116
 117                 double a,b,c,d,e;
 118
 119                 if(range.at(1).compare("NA") == 0)
 120                         a = piSentinel;
 121                 else
 122                         a = atoi(range.at(1).c_str());
 123
 124                 if(range.at(3).compare("NA") == 0)
 125                         b = piSentinel;
 126                 else
 127                         b = atoi(range.at(3).c_str());
 128
 129                 if(range.at(4).compare("between") == 0)
 130                         c = 0;
 131                 else if(range.at(4).compare("only") == 0)
 132                         c = 1;
 133                 else
 134                 {
 135                         cout << "The range can only be 'between' or 'only' the bounding numbers.\n";
 136                         return false;
 137                 }
 138
 139                 if(range.at(0).compare(">") == 0)
 140                         d = 0;
 141                 else if(range.at(0).compare(">=") == 0 || range[3].compare("=>") == 0)
 142                         d = 1;
 143                 else
 144                 {
 145                         cout << "The parameter value can only be '>', '>=', or '=>' the lower bounding number.\n";
 146                         return false;
 147                 }
 148
 149                 if(range.at(2).compare("<") == 0)
 150                         e = 0;
 151                 else if(range.at(2).compare("<=") == 0 || range[4].compare("=<") == 0)
 152                         e = 1;
 153                 else
 154                 {
 155                         cout << "The parameter value can only be '<', '<=', or '=<' the upper bounding number.\n";
 156                         return false;
 157                 }
 158
 159                 bool a0 = pVal > a;
 160                 bool a1 = pVal >= a;
 161                 bool b0 = pVal < b;
 162                 bool b1 = pVal <= b;
 163
 164                 if(c != 1)
 165                 {
 166                         if(a == piSentinel && b == piSentinel)
 167                                 return true;
 168                         if(a != piSentinel && b == piSentinel)
 169                         {
 170                                 if(d == 0)
 171                                         valid = a0;
 172                                 else
 173                                         valid = a1;
 174                         }
 175                         else if(a == piSentinel && b != piSentinel)
 176                         {
 177                                 if(e == 0)
 178                                         valid = b0;
 179                                 else
 180                                         valid = b1;
 181                         }
 182                         else
 183                         {
 184                                 if(d == 0 && e == 0)
 185                                         valid = (a0 && b0);
 186                                 else if(d == 0 && e == 1)
 187                                         valid = (a0 && b1);
 188                                 else if(d == 1 && e == 0)
 189                                         valid = (a1 && b0);
 190                                 else
 191                                         valid = (a1 && b1);
 192                         }
 193                 }
 194                 else
 195                 {
 196                         if(a == piSentinel && b == piSentinel)
 197                                 return true;
 198                         if(a != piSentinel && b == piSentinel)
 199                                 valid = (pVal == a);
 200                         else if(a == piSentinel && b != piSentinel)
 201                                 valid = (pVal == b);
 202                         else
 203                                 valid = (pVal == a || pVal == b);
 204                 }
 205
 206                 if(valid)
 207                         return true;
 208
 209                 else
 210                 {
 211                         cout << "The '" << parameter << "' parameter needs to be ";
 212                         if(c == 1)
 213                                 cout << "either '" << a << "' or '" << b << "'.\n";
 214                         else
 215                         {
 216                                 if(a != piSentinel)
 217                                 {
 218                                         cout << ">";
 219                                         if(d != 0)
 220                                                 cout << "=";
 221                                         cout << " '" << a << "'";
 222                                 }
 223                                 if(b == piSentinel)
 224                                         cout << ".\n";
 225                                 else if(a != piSentinel)
 226                                         cout << " and ";
 227                                 if(b != piSentinel)
 228                                 {
 229                                         cout << "<";
 230                                         if(e != 0)
 231                                                 cout << "=";
 232                                         cout << " '" << b << ".\n";
 233                                 }
 234                         }
 235                         return false;
 236                 }
 237         }
 238         catch(exception& e) {
 239                 cout << "Standard Error: " << e.what() << " has occurred in the ValidParameters class Function isValidParameter. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
 240                 exit(1);
 241         }
 242         catch(...) {
 243                 cout << "An unknown error has occurred in the ValidParameters class function isValidParameter. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
 244                 exit(1);
 245         }
 246 }
 247
 248 /***********************************************************************/
 249
 250 /***********************************************************************/
 251 void ValidParameters::initCommandParameters() {
 252         try {
 253                 //{"parameter1","parameter2",...,"last parameter"};
 254
 255                 string readdistArray[] = {"phylip","name","cutoff","precision"};
 256                 commandParameters["read.dist"] = addParameters(readdistArray, sizeof(readdistArray)/sizeof(string));
 257
 258                 string readotuArray[] =  {"list","order","group","shared", "sabund"};
 259                 commandParameters["read.otu"] = addParameters(readotuArray, sizeof(readotuArray)/sizeof(string));
 260
 261                 string clusterArray[] =  {"cutoff","precision","method"};
 262                 commandParameters["cluster"] = addParameters(clusterArray, sizeof(clusterArray)/sizeof(string));
 263
 264                 string deconvoluteArray[] =  {"fasta"};
 265                 commandParameters["deconvolute"] = addParameters(deconvoluteArray, sizeof(deconvoluteArray)/sizeof(string));
 266
 267                 string collectsingleArray[] =  {"freq","line","label","single","precision","abund"};
 268                 commandParameters["collect.single"] = addParameters(collectsingleArray, sizeof(collectsingleArray)/sizeof(string));
 269
 270                 string collectsharedArray[] =  {"jumble","freq","line","label","shared","groups"};
 271                 commandParameters["collect.shared"] = addParameters(collectsharedArray, sizeof(collectsharedArray)/sizeof(string));
 272
 273                 string getgroupArray[] =  {};
 274                 commandParameters["get.group"]   = addParameters(getgroupArray, sizeof(getgroupArray)/sizeof(string));
 275
 276                 string getlabelArray[] =  {};
 277                 commandParameters["get.label"]  = addParameters(getlabelArray, sizeof(getlabelArray)/sizeof(string));
 278
 279                 string getlineArray[] =  {};
 280                 commandParameters["get.line"] = addParameters(getlineArray, sizeof(getlineArray)/sizeof(string));
 281
 282                 string rarefactionsingleArray[] =  {"iters","freq","line","label","rarefaction","abund"};
 283                 commandParameters["rarefaction.single"] = addParameters(rarefactionsingleArray, sizeof(rarefactionsingleArray)/sizeof(string));
 284
 285                 string rarefactionsharedArray[] =  {"iters","jumble","line","label","sharedrarefaction"};
 286                 commandParameters["rarefaction.shared"] = addParameters(rarefactionsharedArray, sizeof(rarefactionsharedArray)/sizeof(string));
 287
 288                 string summarysingleArray[] =  {"line","label","summary","abund"};
 289                 commandParameters["summary.single"] = addParameters(summarysingleArray, sizeof(summarysingleArray)/sizeof(string));
 290
 291                 string summarysharedArray[] =  {"jumble","line","label","sharedsummary"};
 292                 commandParameters["summary.shared"] = addParameters(summarysharedArray, sizeof(summarysharedArray)/sizeof(string));
 293
 294                 string quitArray[] = {};
 295                 commandParameters["quit"] = addParameters(quitArray, sizeof(quitArray)/sizeof(string));
 296
 297         }
 298         catch(exception& e) {
 299                 cout << "Standard Error: " << e.what() << " has occurred in the ValidParameters class Function isValidParameter. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
 300                 exit(1);
 301         }
 302         catch(...) {
 303                 cout << "An unknown error has occurred in the ValidParameters class function isValidParameter. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
 304                 exit(1);
 305         }
 306 }
 307
 308 /***********************************************************************/
 309
 310 /***********************************************************************/
 311 void ValidParameters::initParameterRanges() {
 312         try {
 313                 int rangeSize = 5;
 314
 315                 /**************************************************************************************************************
 316                         {">=" or "=>" or ">" if the value should be greater than or equal to or just greater than the lower bound,
 317                     A number representing the lower bound ("NA" if there is no lower bound),
 318                    "<=" or "=<" or "<" if the value shoud be less than or equal to or just less than the upper bound,
 319                     A number representing the upper bound ("NA" if there is no lower bound),
 320                    "between" if between lower and upper bounds or "only" if exactly one of the bounds};
 321
 322                    # = parameter
 323                    # (>, >=) lower bound, # (<, <=) upperbound, # should be (between, only) lower and upper bounds.
 324                    ***********************************************************************************************************/
 325
 326                 string precisionArray[] = {">=","10", "<","NA", "between"};
 327                 parameterRanges["precision"] = addParameters(precisionArray, rangeSize);
 328
 329                 string itersArray[] = {">=","10", "<","NA", "between"};
 330                 parameterRanges["iters"] = addParameters(itersArray, rangeSize);
 331
 332                 string jumbleArray[] = {">","0", "<","1", "only"};
 333                 parameterRanges["jumble"] = addParameters(jumbleArray, rangeSize);
 334
 335                 string freqArray[] = {">","1", "<","NA", "between"};
 336                 parameterRanges["freq"] = addParameters(freqArray, rangeSize);
 337
 338                 string lineArray[] = {">=","1", "<","NA", "between"};
 339                 parameterRanges["line"] = addParameters(lineArray, rangeSize);
 340
 341                 string abundArray[] = {">=","5", "<","NA", "between"};
 342                 parameterRanges["abund"] = addParameters(abundArray, rangeSize);
 343         }
 344         catch(exception& e) {
 345                 cout << "Standard Error: " << e.what() << " has occurred in the ValidParameters class Function isValidParameter. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
 346                 exit(1);
 347         }
 348         catch(...) {
 349                 cout << "An unknown error has occurred in the ValidParameters class function isValidParameter. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
 350                 exit(1);
 351         }
 352 }
 353
 354 /***********************************************************************/
 355
 356 /***********************************************************************/
 357 vector<string> ValidParameters::addParameters(string parameters[], int size) {
 358         try {
 359                 vector<string> pVector (parameters, parameters+size);
 360                 return pVector;
 361         }
 362         catch(exception& e) {
 363                 cout << "Standard Error: " << e.what() << " has occurred in the ValidParameters class Function isValidParameter. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
 364                 exit(1);
 365         }
 366         catch(...) {
 367                 cout << "An unknown error has occurred in the ValidParameters class function isValidParameter. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
 368                 exit(1);
 369         }
 370 }
 371
 372 /***********************************************************************/
 373