]> git.donarmstrong.com Git - mothur.git/blobdiff - validcalculator.cpp
added calcs to tree.shared. working on remove.rare command
[mothur.git] / validcalculator.cpp
index 4c05e4a8e466e2a99a2628e0ca7e1cf31c5e4bfe..6583bbefc9564d17959d4b1240fc589fea54751d 100644 (file)
@@ -12,6 +12,8 @@
 /********************************************************************/
 ValidCalculators::ValidCalculators() {
        try {
+                m = MothurOut::getInstance();
+               
                 initialSingle();
                 initialShared();
                 initialRarefaction();
@@ -21,15 +23,15 @@ ValidCalculators::ValidCalculators() {
                 initialVennSingle();
                 initialVennShared();
                 initialTreeGroups();
+                initialBoot();
+                initialDistance();
+                initialMatrix();
+                initialHeat();
        }
        catch(exception& e) {
-               cout << "Standard Error: " << e.what() << " has occurred in the ValidCalculator class Function ValidCalculator. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+               m->errorOut(e, "ValidCalculator", "ValidCalculator");
                exit(1);
        }
-       catch(...) {
-               cout << "An unknown error has occurred in the ValidCalculator class function ValidCalculator. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
-               exit(1);
-       }                
 }
 
 /********************************************************************/
@@ -46,11 +48,11 @@ bool ValidCalculators::isValidCalculator(string parameter, string calculator) {
                        if ((single.find(calculator)) != (single.end())) {
                                return true;
                        }else { 
-                               cout << calculator << " is not a valid estimator for the collect.single command and will be disregarded. Valid estimators are ";
+                               m->mothurOut(calculator + " is not a valid estimator for the collect.single command and will be disregarded. Valid estimators are ");
                                for (it = single.begin(); it != single.end(); it++) {
-                                       cout << it->first << ", ";
+                                       m->mothurOut(it->first + ", ");
                                }
-                               cout << endl;
+                               m->mothurOutEndLine();
                                return false; }
                //are you looking for a calculator for a shared parameter
                }else if (parameter == "shared") {
@@ -58,11 +60,11 @@ bool ValidCalculators::isValidCalculator(string parameter, string calculator) {
                        if ((shared.find(calculator)) != (shared.end())) {
                                return true;
                        }else { 
-                               cout << calculator << " is not a valid estimator for the collect.shared command and will be disregarded.  Valid estimators are ";
+                               m->mothurOut(calculator +  " is not a valid estimator for the collect.shared command and will be disregarded.  Valid estimators are ");
                                for (it = shared.begin(); it != shared.end(); it++) {
-                                       cout << it->first << ", ";
+                                       m->mothurOut(it->first + ", ");
                                }
-                               cout << endl;
+                               m->mothurOutEndLine();
                                return false; }
                //are you looking for a calculator for a rarefaction parameter
                }else if (parameter == "rarefaction") {
@@ -70,11 +72,11 @@ bool ValidCalculators::isValidCalculator(string parameter, string calculator) {
                        if ((rarefaction.find(calculator)) != (rarefaction.end())) {
                                return true;
                        }else { 
-                               cout << calculator << " is not a valid estimator for the rarefaction.single command and will be disregarded. Valid estimators are ";
+                               m->mothurOut(calculator + " is not a valid estimator for the rarefaction.single command and will be disregarded. Valid estimators are ");
                                for (it = rarefaction.begin(); it != rarefaction.end(); it++) {
-                                       cout << it->first << ", ";
+                                       m->mothurOut(it->first + ", ");
                                }
-                               cout << endl;
+                               m->mothurOutEndLine();
                                return false; }
                //are you looking for a calculator for a summary parameter
                }else if (parameter == "summary") {
@@ -82,11 +84,11 @@ bool ValidCalculators::isValidCalculator(string parameter, string calculator) {
                        if ((summary.find(calculator)) != (summary.end())) {
                                return true;
                        }else { 
-                               cout << calculator << " is not a valid estimator for the summary.shared command and will be disregarded. Valid estimators are ";
+                               m->mothurOut(calculator + " is not a valid estimator for the summary.shared command and will be disregarded. Valid estimators are ");
                                for (it = summary.begin(); it != summary.end(); it++) {
-                                       cout << it->first << ", ";
+                                       m->mothurOut(it->first + ", ");
                                }
-                               cout << endl;
+                               m->mothurOutEndLine();
                                return false; }
                //are you looking for a calculator for a sharedsummary parameter
                }else if (parameter == "sharedsummary") {
@@ -94,69 +96,108 @@ bool ValidCalculators::isValidCalculator(string parameter, string calculator) {
                        if ((sharedsummary.find(calculator)) != (sharedsummary.end())) {
                                return true;
                        }else { 
-                               cout << calculator << " is not a valid estimator for the summary.shared command and will be disregarded. Valid estimators are ";
+                               m->mothurOut(calculator +  " is not a valid estimator for the summary.shared command and will be disregarded. Valid estimators are ");
                                for (it = sharedsummary.begin(); it != sharedsummary.end(); it++) {
-                                       cout << it->first << ", ";
+                                       m->mothurOut(it->first + ", ");
                                }
-                               cout << endl;
+                               m->mothurOutEndLine();
                                return false; }
                }else if (parameter == "sharedrarefaction") {
                        //is it valid
                        if ((sharedrarefaction.find(calculator)) != (sharedrarefaction.end())) {
                                return true;
                        }else { 
-                               cout << calculator << " is not a valid estimator for the rarefaction.shared command and will be disregarded. Valid estimator is ";
+                               m->mothurOut(calculator + " is not a valid estimator for the rarefaction.shared command and will be disregarded. Valid estimator is ");
                                for (it = sharedrarefaction.begin(); it != sharedrarefaction.end(); it++) {
-                                       cout << it->first << ", ";
+                                       m->mothurOut(it->first + ", ");
                                }
-                               cout << endl;
+                               m->mothurOutEndLine();
                                return false; }
                }else if (parameter == "vennsingle") {
                        //is it valid
                        if ((vennsingle.find(calculator)) != (vennsingle.end())) {
                                return true;
                        }else { 
-                               cout << calculator << " is not a valid estimator for the venn command in single mode and will be disregarded. Valid estimators are ";
+                               m->mothurOut(calculator + " is not a valid estimator for the venn command in single mode and will be disregarded. Valid estimators are ");
                                for (it = vennsingle.begin(); it != vennsingle.end(); it++) {
-                                       cout << it->first << ", ";
+                                       m->mothurOut(it->first + ", ");
                                }
-                               cout << endl;
+                               m->mothurOutEndLine();
                                return false; }
                }else if (parameter == "vennshared") {
                        //is it valid
                        if ((vennshared.find(calculator)) != (vennshared.end())) {
                                return true;
                        }else { 
-                               cout << calculator << " is not a valid estimator for the venn command in shared mode and will be disregarded. Valid estimators are ";
+                               m->mothurOut(calculator + " is not a valid estimator for the venn command in shared mode and will be disregarded. Valid estimators are ");
                                for (it = vennshared.begin(); it != vennshared.end(); it++) {
-                                       cout << it->first << ", ";
+                                       m->mothurOut(it->first + ", ");
                                }
-                               cout << endl;
+                               m->mothurOutEndLine();
                                return false; }
                }else if (parameter == "treegroup") {
                        //is it valid
                        if ((treegroup.find(calculator)) != (treegroup.end())) {
                                return true;
                        }else { 
-                               cout << calculator << " is not a valid estimator for the tree.groups command in shared mode and will be disregarded. Valid estimators are ";
+                               m->mothurOut(calculator + " is not a valid estimator for the tree.shared command and will be disregarded. Valid estimators are ");
                                for (it = treegroup.begin(); it != treegroup.end(); it++) {
-                                       cout << it->first << ", ";
+                                       m->mothurOut(it->first + ", ");
                                }
-                               cout << endl;
+                               m->mothurOutEndLine();
+                               return false; }
+               }else if (parameter == "matrix") {
+                       //is it valid
+                       if ((matrix.find(calculator)) != (matrix.end())) {
+                               return true;
+                       }else { 
+                               m->mothurOut(calculator +  " is not a valid estimator for the matrix.output command and will be disregarded. Valid estimators are ");
+                               for (it = matrix.begin(); it != matrix.end(); it++) {
+                                       m->mothurOut(it->first + ", ");
+                               }
+                               m->mothurOutEndLine();
+                               return false; }
+               }else if (parameter == "heat") {
+                       //is it valid
+                       if ((heat.find(calculator)) != (heat.end())) {
+                               return true;
+                       }else { 
+                               m->mothurOut(calculator + " is not a valid estimator for the heatmap.sim command and will be disregarded. Valid estimators are ");
+                               for (it = heat.begin(); it != heat.end(); it++) {
+                                       m->mothurOut(it->first + ", ");
+                               }
+                               m->mothurOutEndLine();
+                               return false; }
+               }else if (parameter == "boot") {
+                       //is it valid
+                       if ((boot.find(calculator)) != (boot.end())) {
+                               return true;
+                       }else { 
+                               m->mothurOut(calculator + " is not a valid estimator for the bootstrap.shared command and will be disregarded. Valid estimators are ");
+                               for (it = boot.begin(); it != boot.end(); it++) {
+                                       m->mothurOut(it->first + ", ");
+                               }
+                               m->mothurOutEndLine();
+                               return false; }
+               }else if (parameter == "distance") {
+                       //is it valid
+                       if ((distance.find(calculator)) != (distance.end())) {
+                               return true;
+                       }else { 
+                               m->mothurOut(calculator +  " is not a valid estimator for the distance command and will be disregarded. Valid calculators are ");
+                               for (it = distance.begin(); it != distance.end(); it++) {
+                                       m->mothurOut(it->first + ", ");
+                               }
+                               m->mothurOutEndLine();
                                return false; }
-
                //not a valid parameter
                }else { return false; }
                
        }
        catch(exception& e) {
-               cout << "Standard Error: " << e.what() << " has occurred in the ValidCalculator class Function isValidCalculator. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+               m->errorOut(e, "ValidCalculator", "isValidCalculator");
                exit(1);
        }
-       catch(...) {
-               cout << "An unknown error has occurred in the ValidCalculator class function isValidCalculator. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
-               exit(1);
-       }       
 }
 
 /********************************************************************/
@@ -168,24 +209,31 @@ void ValidCalculators::initialSingle() {
                single["jack"]              = "jack";
                single["shannon"]           = "shannon";
                single["npshannon"]     = "npshannon";
+               single["shannoneven"]   = "shannoneven";
+               single["smithwilson"]   = "smithwilson";
+               single["heip"]                  = "heip";
                single["simpson"]           = "simpson";
+               single["simpsoneven"]   = "simpsoneven";
+               single["invsimpson"]    = "invsimpson";
                single["bergerparker"]  = "bergerparker";
                single["bootstrap"]     = "bootstrap";
-               single["geom"]          = "geom";
-               single["logsd"]         = "logsd";
+               single["geometric"]     = "geometric";
+               single["logseries"]             = "logseries";
                single["qstat"]         = "qstat";
                single["bstick"]        = "bstick";
+               single["goodscoverage"] = "goodscoverage";
                single["nseqs"]                 = "nseqs";
+               single["coverage"]              = "coverage";
+               single["efron"]         = "efron";
+               single["boneh"]         = "boneh";
+               single["solow"]         = "solow";
+               single["shen"]          = "shen";
                single["default"]           = "default";
        }
        catch(exception& e) {
-               cout << "Standard Error: " << e.what() << " has occurred in the ValidCalculator class Function initialSingle. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+               m->errorOut(e, "ValidCalculator", "initialSingle");
                exit(1);
        }
-       catch(...) {
-               cout << "An unknown error has occurred in the ValidCalculator class function initialSingle. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
-               exit(1);
-       }       
 }
 
 /********************************************************************/
@@ -195,7 +243,7 @@ void ValidCalculators::initialShared() {
                shared["sharedchao"]                    = "sharedchao";
                shared["sharedace"]                             = "sharedace";
                shared["jabund"]                                = "jabund";
-               shared["sorensonabund"]                 = "sorensonabund";
+               shared["sorabund"]                              = "sorabund";
                shared["jclass"]                                = "jclass";
                shared["sorclass"]                              = "sorclass";
                shared["jest"]                                  = "jest";
@@ -203,7 +251,7 @@ void ValidCalculators::initialShared() {
                shared["thetayc"]                               = "thetayc";
                shared["thetan"]                                = "thetan";
                shared["kstest"]                                = "kstest";
-               shared["bdiversity"]                    = "bdiversity";
+               shared["whittaker"]                         = "whittaker";
                shared["sharednseqs"]                   = "sharednseqs";
                shared["ochiai"]                                = "ochiai";
                shared["anderberg"]                             = "anderberg";
@@ -212,16 +260,30 @@ void ValidCalculators::initialShared() {
                shared["lennon"]                                = "lennon";
                shared["morisitahorn"]                  = "morisitahorn";
                shared["braycurtis"]                    = "braycurtis";
+               shared["odum"]                                  = "odum";
+               shared["canberra"]                              = "canberra";
+               shared["structeuclidean"]               = "structeuclidean";
+               shared["structchord"]                   = "structchord";
+               shared["hellinger"]                             = "hellinger";
+               shared["manhattan"]                             = "manhattan";
+               shared["structpearson"]                 = "structpearson";
+               shared["soergel"]                               = "soergel";
+               shared["spearman"]                              = "spearman";
+               shared["structkulczynski"]              = "structkulczynski";
+               shared["structchi2"]                    = "structchi2";
+               shared["speciesprofile"]                = "speciesprofile";
+               shared["hamming"]                               = "hamming";
+               shared["gower"]                                 = "gower";
+               shared["memchi2"]                               = "memchi2";
+               shared["memchord"]                              = "memchord";
+               shared["memeuclidean"]                  = "memeuclidean";
+               shared["mempearson"]                    = "mempearson";
                shared["default"]                   = "default";
        }
        catch(exception& e) {
-               cout << "Standard Error: " << e.what() << " has occurred in the ValidCalculator class Function initialShared. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+               m->errorOut(e, "ValidCalculator", "initialShared");
                exit(1);
        }
-       catch(...) {
-               cout << "An unknown error has occurred in the ValidCalculator class function initialShared. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
-               exit(1);
-       }       
 }
 
 /********************************************************************/
@@ -232,20 +294,22 @@ void ValidCalculators::initialRarefaction() {
                rarefaction["ace"]                      = "ace";
                rarefaction["jack"]                     = "jack";
                rarefaction["shannon"]          = "shannon";
+               rarefaction["smithwilson"]      = "smithwilson";
+               rarefaction["heip"]                     = "heip";
                rarefaction["npshannon"]        = "npshannon";
+               rarefaction["shannoneven"]      = "shannoneven";
                rarefaction["simpson"]          = "simpson";
+               rarefaction["invsimpson"]       = "invsimpson";
+               rarefaction["simpsoneven"]      = "simpsoneven";
                rarefaction["bootstrap"]        = "bootstrap";
                rarefaction["nseqs"]            = "nseqs";
+               rarefaction["coverage"]         = "coverage";
                rarefaction["default"]      = "default";
        }
        catch(exception& e) {
-               cout << "Standard Error: " << e.what() << " has occurred in the ValidCalculator class Function initialRarefaction. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+               m->errorOut(e, "ValidCalculator", "initialRarefaction");
                exit(1);
        }
-       catch(...) {
-               cout << "An unknown error has occurred in the ValidCalculator class function initialRarefaction. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
-               exit(1);
-       }       
 }
 
 /********************************************************************/
@@ -257,25 +321,32 @@ void ValidCalculators::initialSummary() {
                summary["ace"]                  = "ace";
                summary["jack"]                 = "jack";
                summary["shannon"]              = "shannon";
+               summary["heip"]                 = "heip";
+               summary["shannoneven"]  = "shannoneven";
+               summary["smithwilson"]  = "smithwilson";
+               summary["invsimpson"]   = "invsimpson";
                summary["npshannon"]    = "npshannon";
                summary["simpson"]              = "simpson";
+               summary["simpsoneven"]  = "simpsoneven";
                summary["bergerparker"] = "bergerparker";
-               summary["geom"]         = "geom";
+               summary["geometric"]    = "geometric";
                summary["bootstrap"]    = "bootstrap";
-               summary["logsd"]        = "logsd";
+               summary["logseries"]    = "logseries";
                summary["qstat"]        = "qstat";
                summary["bstick"]       = "bstick";
                summary["nseqs"]                = "nseqs";
+               summary["goodscoverage"]= "goodscoverage";
+               summary["coverage"]             = "coverage";
+               summary["efron"]        = "efron";
+               summary["boneh"]        = "boneh";
+               summary["solow"]        = "solow";
+               summary["shen"]         = "shen";
                summary["default"]          = "default";
        }
        catch(exception& e) {
-               cout << "Standard Error: " << e.what() << " has occurred in the ValidCalculator class Function initialSummary. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+               m->errorOut(e, "ValidCalculator", "initialSummary");
                exit(1);
        }
-       catch(...) {
-               cout << "An unknown error has occurred in the ValidCalculator class function initialSummary. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
-               exit(1);
-       }       
 }
 
 /********************************************************************/
@@ -285,7 +356,7 @@ void ValidCalculators::initialSharedSummary() {
                sharedsummary["sharedchao"]                             = "sharedchao";
                sharedsummary["sharedace"]                              = "sharedace";
                sharedsummary["jabund"]                                 = "jabund";
-               sharedsummary["sorensonabund"]                  = "sorensonabund";
+               sharedsummary["sorabund"]                               = "sorabund";
                sharedsummary["jclass"]                                 = "jclass";
                sharedsummary["sorclass"]                               = "sorclass";
                sharedsummary["jest"]                                   = "jest";
@@ -293,7 +364,7 @@ void ValidCalculators::initialSharedSummary() {
                sharedsummary["thetayc"]                                = "thetayc";
                sharedsummary["thetan"]                                 = "thetan";
                sharedsummary["kstest"]                                 = "kstest";
-               sharedsummary["bdiversity"]                             = "bdiversity";
+               sharedsummary["whittaker"]                              = "whittaker";
                sharedsummary["sharednseqs"]                    = "sharednseqs";
                sharedsummary["ochiai"]                                 = "ochiai";
                sharedsummary["anderberg"]                              = "anderberg";
@@ -302,16 +373,30 @@ void ValidCalculators::initialSharedSummary() {
                sharedsummary["lennon"]                                 = "lennon";
                sharedsummary["morisitahorn"]                   = "morisitahorn";
                sharedsummary["braycurtis"]                             = "braycurtis";
+               sharedsummary["odum"]                                   = "odum";
+               sharedsummary["canberra"]                               = "canberra";
+               sharedsummary["structeuclidean"]                = "structeuclidean";
+               sharedsummary["structchord"]                    = "structchord";
+               sharedsummary["hellinger"]                              = "hellinger";
+               sharedsummary["manhattan"]                              = "manhattan";
+               sharedsummary["structpearson"]                  = "structpearson";
+               sharedsummary["structkulczynski"]               = "structkulczynski";
+               sharedsummary["structchi2"]                             = "structchi2";
+               sharedsummary["soergel"]                                = "soergel";
+               sharedsummary["spearman"]                               = "spearman";
+               sharedsummary["speciesprofile"]                 = "speciesprofile";
+               sharedsummary["hamming"]                                = "hamming";
+               sharedsummary["gower"]                                  = "gower";
+               sharedsummary["memchi2"]                                = "memchi2";
+               sharedsummary["memchord"]                               = "memchord";
+               sharedsummary["memeuclidean"]                   = "memeuclidean";
+               sharedsummary["mempearson"]                             = "mempearson";
                sharedsummary["default"]                                = "default";
        }
        catch(exception& e) {
-               cout << "Standard Error: " << e.what() << " has occurred in the ValidCalculator class Function initialSharedSummary. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+               m->errorOut(e, "ValidCalculator", "initialSharedSummary");
                exit(1);
        }
-       catch(...) {
-               cout << "An unknown error has occurred in the ValidCalculator class function initialSharedSummary. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
-               exit(1);
-       }       
 }
 
 
@@ -324,13 +409,9 @@ void ValidCalculators::initialSharedRarefact() {
                sharedrarefaction["default"]        = "default";
        }
        catch(exception& e) {
-               cout << "Standard Error: " << e.what() << " has occurred in the ValidCalculator class Function initialSharedRarefact. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+               m->errorOut(e, "ValidCalculator", "initialSharedRarefact");
                exit(1);
        }
-       catch(...) {
-               cout << "An unknown error has occurred in the ValidCalculator class function initialSharedRarefact. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
-               exit(1);
-       }       
 }
 
 
@@ -344,13 +425,9 @@ void ValidCalculators::initialVennSingle() {
                vennsingle["default"]           = "default";
        }
        catch(exception& e) {
-               cout << "Standard Error: " << e.what() << " has occurred in the ValidCalculator class Function initialSingle. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+               m->errorOut(e, "ValidCalculator", "initialVennSingle");
                exit(1);
        }
-       catch(...) {
-               cout << "An unknown error has occurred in the ValidCalculator class function initialSingle. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
-               exit(1);
-       }       
 }
 
 /********************************************************************/
@@ -362,41 +439,201 @@ void ValidCalculators::initialVennShared() {
                vennshared["default"]           = "default";
        }
        catch(exception& e) {
-               cout << "Standard Error: " << e.what() << " has occurred in the ValidCalculator class Function initialSingle. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+               m->errorOut(e, "ValidCalculator", "initialVennShared");
                exit(1);
        }
-       catch(...) {
-               cout << "An unknown error has occurred in the ValidCalculator class function initialSingle. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
-               exit(1);
-       }       
 }
 
 /********************************************************************/
 void ValidCalculators::initialTreeGroups() {
        try {   
+               treegroup["sharedsobs"]                         = "sharedsobs";
+               treegroup["sharedchao"]                         = "sharedchao";
+               treegroup["sharedace"]                          = "sharedace";
                treegroup["jabund"]                                     = "jabund";
-               treegroup["sorensonabund"]                      = "sorensonabund";
+               treegroup["sorabund"]                           = "sorabund";
                treegroup["jclass"]                                     = "jclass";
                treegroup["sorclass"]                           = "sorclass";
                treegroup["jest"]                                       = "jest";
                treegroup["sorest"]                                     = "sorest";
                treegroup["thetayc"]                            = "thetayc";
                treegroup["thetan"]                                     = "thetan";
+               treegroup["kstest"]                                     = "kstest";
+               treegroup["whittaker"]                          = "whittaker";
+               treegroup["sharednseqs"]                        = "sharednseqs";
+               treegroup["ochiai"]                                     = "ochiai";
+               treegroup["anderberg"]                          = "anderberg";
+               treegroup["kulczynski"]                         = "kulczynski";
+               treegroup["kulczynskicody"]                     = "kulczynskicody";
+               treegroup["lennon"]                                     = "lennon";
                treegroup["morisitahorn"]                       = "morisitahorn";
+               treegroup["braycurtis"]                         = "braycurtis";
+               treegroup["odum"]                                       = "odum";
+               treegroup["canberra"]                           = "canberra";
+               treegroup["structeuclidean"]            = "structeuclidean";
+               treegroup["structchord"]                        = "structchord";
+               treegroup["hellinger"]                          = "hellinger";
+               treegroup["manhattan"]                          = "manhattan";
+               treegroup["structpearson"]                      = "structpearson";
+               treegroup["structkulczynski"]           = "structkulczynski";
+               treegroup["structchi2"]                         = "structchi2";
+               treegroup["soergel"]                            = "soergel";
+               treegroup["spearman"]                           = "spearman";
+               treegroup["speciesprofile"]                     = "speciesprofile";
+               treegroup["hamming"]                            = "hamming";
+               treegroup["gower"]                                      = "gower";
+               treegroup["memchi2"]                            = "memchi2";
+               treegroup["memchord"]                           = "memchord";
+               treegroup["memeuclidean"]                       = "memeuclidean";
+               treegroup["mempearson"]                         = "mempearson";
+               
        }
        catch(exception& e) {
-               cout << "Standard Error: " << e.what() << " has occurred in the ValidCalculator class Function initialTreeGroups. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+               m->errorOut(e, "ValidCalculator", "initialTreeGroups");
                exit(1);
        }
-       catch(...) {
-               cout << "An unknown error has occurred in the ValidCalculator class function initialTreeGroups. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+}
+/********************************************************************/
+void ValidCalculators::initialHeat() {
+       try {   
+               heat["jabund"]                          = "jabund";
+               heat["sorabund"]                        = "sorabund";
+               heat["jclass"]                          = "jclass";
+               heat["sorclass"]                        = "sorclass";
+               heat["jest"]                            = "jest";
+               heat["sorest"]                          = "sorest";
+               heat["thetayc"]                         = "thetayc";
+               heat["thetan"]                          = "thetan";
+               heat["morisitahorn"]            = "morisitahorn";
+               heat["braycurtis"]                      = "braycurtis";
+       }
+       catch(exception& e) {
+               m->errorOut(e, "ValidCalculator", "initialHeat");
                exit(1);
-       }       
+       }
 }
 
-
 /********************************************************************/
+void ValidCalculators::initialMatrix() {
+       try {   
+               matrix["jabund"]                                = "jabund";
+               matrix["sorabund"]                              = "sorabund";
+               matrix["jclass"]                                = "jclass";
+               matrix["sorclass"]                              = "sorclass";
+               matrix["jest"]                                  = "jest";
+               matrix["sorest"]                                = "sorest";
+               matrix["thetayc"]                               = "thetayc";
+               matrix["thetan"]                                = "thetan";
+               matrix["morisitahorn"]                  = "morisitahorn";
+               matrix["braycurtis"]                    = "braycurtis";
+       }
+       catch(exception& e) {
+               m->errorOut(e, "ValidCalculator", "initialMatrix");
+               exit(1);
+       }
+}
 
+/********************************************************************/
+void ValidCalculators::initialBoot() {
+       try {   
+               boot["jabund"]                          = "jabund";
+               boot["sorabund"]                        = "sorabund";
+               boot["jclass"]                          = "jclass";
+               boot["sorclass"]                        = "orclass";
+               boot["jest"]                            = "jest";
+               boot["sorest"]                          = "sorest";
+               boot["thetayc"]                         = "thetayc";
+               boot["thetan"]                          = "thetan";
+               boot["morisitahorn"]            = "morisitahorn";
+               boot["braycurtis"]                      = "braycurtis";
+       }
+       catch(exception& e) {
+               m->errorOut(e, "ValidCalculator", "initialBoot");
+               exit(1);
+       }
+}
+/********************************************************************/
+void ValidCalculators::initialDistance() {
+       try {   
+               distance["nogaps"]              = "nogaps";
+               distance["eachgap"]             = "eachgap";
+               distance["onegap"]              = "onegap";
+       }
+       catch(exception& e) {
+               m->errorOut(e, "ValidCalculator", "initialDistance");
+               exit(1);
+       }
+}
 
+/********************************************************************/
+void ValidCalculators::printCalc(string parameter, ostream& out) {
+       try{
+               out << "The available estimators for calc are ";
+               //are you looking for a calculator for a single parameter
+               if (parameter == "single") {
+                       for (it = single.begin(); it != single.end(); it++) {
+                               out << it->first << ", ";
+                       }
+               //are you looking for a calculator for a shared parameter
+               }else if (parameter == "shared") {
+                       for (it = shared.begin(); it != shared.end(); it++) {
+                               out << it->first << ", ";
+                       }
+               //are you looking for a calculator for a rarefaction parameter
+               }else if (parameter == "rarefaction") {
+                       for (it = rarefaction.begin(); it != rarefaction.end(); it++) {
+                               out << it->first << ", ";
+                       }
+               //are you looking for a calculator for a summary parameter
+               }else if (parameter == "summary") {
+                       for (it = summary.begin(); it != summary.end(); it++) {
+                               out << it->first << ", ";
+                       }
+               //are you looking for a calculator for a sharedsummary parameter
+               }else if (parameter == "sharedsummary") {
+                       for (it = sharedsummary.begin(); it != sharedsummary.end(); it++) {
+                               out << it->first << ", ";
+                       }
+               }else if (parameter == "sharedrarefaction") {
+                       for (it = sharedrarefaction.begin(); it != sharedrarefaction.end(); it++) {
+                               out << it->first << ", ";
+                       }
+               }else if (parameter == "vennsingle") {
+                       for (it = vennsingle.begin(); it != vennsingle.end(); it++) {
+                               out << it->first << ", ";
+                       }
+               }else if (parameter == "vennshared") {
+                       for (it = vennshared.begin(); it != vennshared.end(); it++) {
+                               out << it->first << ", ";
+                       }
+               }else if (parameter == "treegroup") {
+                       for (it = treegroup.begin(); it != treegroup.end(); it++) {
+                               out << it->first << ", ";
+                       }
+               }else if (parameter == "matrix") {
+                       for (it = matrix.begin(); it != matrix.end(); it++) {
+                               out << it->first << ", ";
+                       }
+               }else if (parameter == "heat") {
+                       for (it = heat.begin(); it != heat.end(); it++) {
+                               out << it->first << ", ";
+                       }
+               }else if (parameter == "boot") {
+                       for (it = boot.begin(); it != boot.end(); it++) {
+                               out << it->first << ", ";
+                       }
+               }else if (parameter == "distance") {
+                       for (it = distance.begin(); it != distance.end(); it++) {
+                               out << it->first << ", ";
+                       }
+               }
 
+               out << endl;
+       }
+       catch(exception& e) {
+               m->errorOut(e, "ValidCalculator", "printCalc");
+               exit(1);
+       }
+}
+/********************************************************************/