cutoff = globaldata->getCutOff();
format = globaldata->getFormat();
method = globaldata->getMethod();
+ randomtree = globaldata->getRandomTree();
+ sharedfile = globaldata->getSharedFile();
+
- string p[] = {
+/* string p[] = {
"phylip", //0
"column", //1
"list", //2
intParams[p[13]] = ipv2;
intParams[p[14]] = ipv3;
intParams[p[17]] = ipv4;
- intParams[p[26]] = ipv5;
+ intParams[p[26]] = ipv5; */
- randomtree = globaldata->getRandomTree();
- sharedfile = globaldata->getSharedFile();
}
/*******************************************************/
//is it a valid parameter
if (validParameter->isValidParameter(parameter) != true) { return false; }
- if(!validCommandParameter(parameter,commandName)) {
- cout << "'" << parameter << "' is not a valid parameter for the " << commandName << " command.\n";
- return false;
- }
- if(!validParameterValue(value, parameter)) {
- if(parameter.compare("precision") == 0)
- cout << "The precision parameter can only take powers of 10 as a value (e.g. 10,1000,1000, etc.)\n";
- else {
- vector<double> bounds = intParams[parameter];
+ //if(!validCommandParameter(parameter,commandName)) {
+ // cout << "'" << parameter << "' is not a valid parameter for the " << commandName << " command.\n";
+ // return false;
+ //}
+ //if(!validParameterValue(value, parameter)) {
+ // if(parameter.compare("precision") == 0)
+ // cout << "The precision parameter can only take powers of 10 as a value (e.g. 10,1000,1000, etc.)\n";
+ // else {
+ /* vector<double> bounds = intParams[parameter];
double a = bounds.at(0);
double b = bounds.at(1);
double c = bounds.at(2);
}
}
return false;
- }
+ } */
if (parameter == "phylip" ) { phylipfile = value; }
if (parameter == "column" ) { columnfile = value; }
splitAtEquals(parameter, value);
//is it a valid parameter
if (validParameter->isValidParameter(parameter) != true) { return false; }
- if(!validCommandParameter(parameter,commandName)) {
- cout << "'" << parameter << "' is not a valid parameter for the " << commandName << " command.\n";
- return false;
- }
- if(!validParameterValue(value, parameter)) {
+ // if(!validCommandParameter(parameter,commandName)) {
+ // cout << "'" << parameter << "' is not a valid parameter for the " << commandName << " command.\n";
+ // return false;
+ // }
+ /* if(!validParameterValue(value, parameter)) {
if(parameter.compare("precision") == 0)
cout << "The precision parameter can only take powers of 10 as a value (e.g. 10,1000,1000, etc.)\n";
else {
}
}
return false;
- }
+ }*/
if (parameter == "phylip" ) { phylipfile = value; }
if (parameter == "column" ) { columnfile = value; }
if (parameter == "list" ) { listfile = value; }
}
/*******************************************************/
-/******************************************************/
+/******************************************************
//This function checks to see if the given paramter
//is a valid paramter for the given command.
bool ErrorCheck::validCommandParameter(string parameter, string commandName) {
}
/*******************************************************/
-/******************************************************/
+/******************************************************
//This function checks to see if the given paramter value
//is convertable into an int if that parameter requires it.
bool ErrorCheck::validParameterValue(string value, string parameter) {
ValidCommands* validCommand;
ValidParameters* validParameter;
void validateReadFiles();
- bool validCommandParameter(string, string);
- bool validParameterValue(string, string);
+ // bool validCommandParameter(string, string);
+ // bool validParameterValue(string, string);
void validateReadDist();
void validateReadPhil();
void validateParseFiles();
bool errorFree;
vector<string> sharedGroups;
- map <string, vector<string> > commandParameters;
- map <string, vector<double> > intParams;
- double piSent;
+ // map <string, vector<string> > commandParameters;
+ /// map <string, vector<double> > intParams;
+ // double piSent;
};
#endif
//add in all the groups the users wanted
for (it = t->tree[i].pGroups.begin(); it != t->tree[i].pGroups.end(); it++) {
- if (inUsersGroups(it->first) == true) { iSize++; }
+ if (inUsersGroups(it->first, globaldata->Groups) == true) { iSize++; }
}
//if that leaves no groups give it 1 so it will cause no change to parent
//add in all the groups the users wanted
for (it = t->tree[rc].pGroups.begin(); it != t->tree[rc].pGroups.end(); it++) {
- if (inUsersGroups(it->first) == true) { rcSize++; }
+ if (inUsersGroups(it->first, globaldata->Groups) == true) { rcSize++; }
}
//if that leaves no groups give it 1 so it will cause no change to parent
//add in all the groups the users wanted
for (it = t->tree[lc].pGroups.begin(); it != t->tree[lc].pGroups.end(); it++) {
- if (inUsersGroups(it->first) == true) { lcSize++; }
+ if (inUsersGroups(it->first, globaldata->Groups) == true) { lcSize++; }
}
//if that leaves no groups give it 1 so it will cause no change to parent
}
}
-/**************************************************************************************************/
-bool Parsimony::inUsersGroups(string groupname) {
- try {
- for (int i = 0; i < globaldata->Groups.size(); i++) {
- if (groupname == globaldata->Groups[i]) { return true; }
- }
- return false;
- }
- catch(exception& e) {
- cout << "Standard Error: " << e.what() << " has occurred in the Parsimony class Function inUsersGroups. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
- exit(1);
- }
- catch(...) {
- cout << "An unknown error has occurred in the Parsimony class function inUsersGroups. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
- exit(1);
- }
-}
-/**************************************************************************************************/
GlobalData* globaldata;
EstOutput data;
TreeMap* tmap;
- bool inUsersGroups(string);
map<string, int>::iterator it;
};
openOutputFile(sumFile, outSum);
distFile = globaldata->getTreeFile() + ".pdistrib";
openOutputFile(distFile, outDist);
-
- //if the user has not entered specific groups to analyze then do them all
- if (globaldata->Groups.size() != 0) {
- //check that groups are valid
- for (int i = 0; i < globaldata->Groups.size(); i++) {
- if (tmap->isValidGroup(globaldata->Groups[i]) != true) {
- cout << globaldata->Groups[i] << " is not a valid group, and will be disregarded." << endl;
- // erase the invalid group from globaldata->Groups
- globaldata->Groups.erase (globaldata->Groups.begin()+i);
- }
- }
-
- //if the user only entered invalid groups
- if (globaldata->Groups.size() == 0) {
- cout << "When using the groups parameter you must have at least 1 valid group. I will run the command using all the groups in your groupfile." << endl;
- for (int i = 0; i < tmap->namesOfGroups.size(); i++) {
- globaldata->Groups.push_back(tmap->namesOfGroups[i]);
- }
- }
- }else {
- for (int i = 0; i < tmap->namesOfGroups.size(); i++) {
- globaldata->Groups.push_back(tmap->namesOfGroups[i]);
- }
- }
-
+ //set users groups to analyze
+ setGroups();
}else { //user wants random distribution
savetmap = globaldata->gTreemap;
getUserInput();
}
/***********************************************************/
+void ParsimonyCommand::setGroups() {
+ try {
+ //if the user has not entered specific groups to analyze then do them all
+ if (globaldata->Groups.size() != 0) {
+ //check that groups are valid
+ for (int i = 0; i < globaldata->Groups.size(); i++) {
+ if (tmap->isValidGroup(globaldata->Groups[i]) != true) {
+ cout << globaldata->Groups[i] << " is not a valid group, and will be disregarded." << endl;
+ // erase the invalid group from globaldata->Groups
+ globaldata->Groups.erase (globaldata->Groups.begin()+i);
+ }
+ }
+
+ //if the user only entered invalid groups
+ if (globaldata->Groups.size() == 0) {
+ cout << "When using the groups parameter you must have at least 1 valid group. I will run the command using all the groups in your groupfile." << endl;
+ for (int i = 0; i < tmap->namesOfGroups.size(); i++) {
+ globaldata->Groups.push_back(tmap->namesOfGroups[i]);
+ }
+ }
+
+ }else {
+ for (int i = 0; i < tmap->namesOfGroups.size(); i++) {
+ globaldata->Groups.push_back(tmap->namesOfGroups[i]);
+ }
+ }
+ }
+ catch(exception& e) {
+ cout << "Standard Error: " << e.what() << " has occurred in the ParsimonyCommand class Function setGroups. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+ exit(1);
+ }
+ catch(...) {
+ cout << "An unknown error has occurred in the ParsimonyCommand class function setGroups. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+ exit(1);
+ }
+
+}
+/*****************************************************************/
+
+
void printParsimonyFile();
void printUSummaryFile();
void getUserInput();
+ void setGroups();
};
void Tree::randomLabels() {
try {
+
+ //set up the groups the user wants to include
+ setGroups();
+
for(int i=numLeaves-1;i>=0;i--){
if(tree[i].pGroups.size() == 0){
continue;
}
-
+
int escape = 1;
int z;
while(escape == 1){
+ //get random index to switch with
z = int((float)(i+1) * (float)(rand()) / ((float)RAND_MAX+1.0));
if(tree[z].pGroups.size() != 0){
escape = 0;
}
}
+
+ //you only want to randomize the nodes that are from a group the user wants analyzed, so
+ //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.
+ bool treez, treei;
+
+ //leaves have only one group so you can just set it to begin()
+ it = tree[z].pGroups.begin();
+ treez = inUsersGroups(it->first, globaldata->Groups);
+
+ it = tree[i].pGroups.begin();
+ treei = inUsersGroups(it->first, globaldata->Groups);
+
+ if ((treez == true) && (treei == true)) {
+ //switches node i and node z's info.
+ map<string,int> lib_hold = tree[z].pGroups;
+ tree[z].pGroups = (tree[i].pGroups);
+ tree[i].pGroups = (lib_hold);
+ tree[z].setGroup(tree[z].pGroups.begin()->first);
+ tree[i].setGroup(tree[i].pGroups.begin()->first);
- map<string,int> lib_hold = tree[z].pGroups;
- tree[z].pGroups = (tree[i].pGroups);
- tree[i].pGroups = (lib_hold);
-
- tree[z].setGroup(tree[z].pGroups.begin()->first);
- tree[i].setGroup(tree[i].pGroups.begin()->first);
-
- map<string,int> gcount_hold = tree[z].pcount;
- tree[z].pcount = (tree[i].pcount);
- tree[i].pcount = (gcount_hold);
+ map<string,int> gcount_hold = tree[z].pcount;
+ tree[z].pcount = (tree[i].pcount);
+ tree[i].pcount = (gcount_hold);
+ }
}
}
catch(exception& e) {
}
/*****************************************************************/
+void Tree::setGroups() {
+ try {
+ //if the user has not entered specific groups to analyze then do them all
+ if (globaldata->Groups.size() != 0) {
+ //check that groups are valid
+ for (int i = 0; i < globaldata->Groups.size(); i++) {
+ if (globaldata->gTreemap->isValidGroup(globaldata->Groups[i]) != true) {
+ cout << globaldata->Groups[i] << " is not a valid group, and will be disregarded." << endl;
+ // erase the invalid group from globaldata->Groups
+ globaldata->Groups.erase (globaldata->Groups.begin()+i);
+ }
+ }
+
+ //if the user only entered invalid groups
+ if (globaldata->Groups.size() == 0) {
+ cout << "When using the groups parameter you must have at least 1 valid group. I will run the command using all the groups in your groupfile." << endl;
+ for (int i = 0; i < globaldata->gTreemap->namesOfGroups.size(); i++) {
+ globaldata->Groups.push_back(globaldata->gTreemap->namesOfGroups[i]);
+ }
+ }
+
+ }else {
+ for (int i = 0; i < globaldata->gTreemap->namesOfGroups.size(); i++) {
+ globaldata->Groups.push_back(globaldata->gTreemap->namesOfGroups[i]);
+ }
+ }
+ }
+ catch(exception& e) {
+ cout << "Standard Error: " << e.what() << " has occurred in the Tree class Function setGroups. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+ exit(1);
+ }
+ catch(...) {
+ cout << "An unknown error has occurred in the Tree class function setGroups. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+ exit(1);
+ }
-
+}
void randomLabels();
int findRoot(); //return index of root node
void printBranch(int); //recursively print out tree
+ void setGroups();
};
#endif
openOutputFile(sumFile, outSum);
distFile = globaldata->getTreeFile() + ".uwdistrib";
openOutputFile(distFile, outDist);
-
- //if the user has not entered specific groups to analyze then do them all
- if (globaldata->Groups.size() != 0) {
- //check that groups are valid
- for (int i = 0; i < globaldata->Groups.size(); i++) {
- if (tmap->isValidGroup(globaldata->Groups[i]) != true) {
- cout << globaldata->Groups[i] << " is not a valid group, and will be disregarded." << endl;
- // erase the invalid group from globaldata->Groups
- globaldata->Groups.erase (globaldata->Groups.begin()+i);
- }
- }
-
- //if the user only entered invalid groups
- if (globaldata->Groups.size() == 0) {
- cout << "When using the groups parameter you must have at least 1 valid group. I will run the command using all the groups in your groupfile." << endl;
- for (int i = 0; i < tmap->namesOfGroups.size(); i++) {
- globaldata->Groups.push_back(tmap->namesOfGroups[i]);
- }
- }
- }else {
- for (int i = 0; i < tmap->namesOfGroups.size(); i++) {
- globaldata->Groups.push_back(tmap->namesOfGroups[i]);
- }
- }
-
+ setGroups(); //sets users groups to analyze
convert(globaldata->getIters(), iters); //how many random trees to generate
unweighted = new Unweighted(tmap);
//format output
outDist.setf(ios::fixed, ios::floatfield); outDist.setf(ios::showpoint);
+
+ outDist << "Groups Used ";
+ for (int m = 0; m < globaldata->Groups.size(); m++) {
+ outDist << globaldata->Groups[m] << " ";
+ }
+ outDist << endl;
+
outDist << "Tree#" << '\t' << "Iter" << '\t' << "UWScore" << endl;
//create new tree with same num nodes and leaves as users
randT = new Tree();
-
+
//get pscores for users trees
for (int i = 0; i < T.size(); i++) {
cout << "Processing tree " << i+1 << endl;
try {
//column headers
+ out << "Groups Used ";
+ for (int m = 0; m < globaldata->Groups.size(); m++) {
+ out << globaldata->Groups[m] << " ";
+ }
+ out << endl;
+
out << "Score" << '\t' << "UserFreq" << '\t' << "UserCumul" << '\t' << "RandFreq" << '\t' << "RandCumul" << endl;
//format output
void UnifracUnweightedCommand::printUWSummaryFile() {
try {
//column headers
+
+ outSum << "Groups Used ";
+ for (int m = 0; m < globaldata->Groups.size(); m++) {
+ outSum << globaldata->Groups[m] << " ";
+ }
+ outSum << endl;
+
outSum << "Tree#" << '\t' << "UWScore" << '\t' << '\t' << "UWSig" << endl;
//format output
}
}
-/***********************************************************/
\ No newline at end of file
+/***********************************************************/
+
+void UnifracUnweightedCommand::setGroups() {
+ try {
+ //if the user has not entered specific groups to analyze then do them all
+ if (globaldata->Groups.size() != 0) {
+ //check that groups are valid
+ for (int i = 0; i < globaldata->Groups.size(); i++) {
+ if (tmap->isValidGroup(globaldata->Groups[i]) != true) {
+ cout << globaldata->Groups[i] << " is not a valid group, and will be disregarded." << endl;
+ // erase the invalid group from globaldata->Groups
+ globaldata->Groups.erase (globaldata->Groups.begin()+i);
+ }
+ }
+
+ //if the user only entered invalid groups
+ if (globaldata->Groups.size() == 0) {
+ cout << "When using the groups parameter you must have at least 1 valid group. I will run the command using all the groups in your groupfile." << endl;
+ for (int i = 0; i < tmap->namesOfGroups.size(); i++) {
+ globaldata->Groups.push_back(tmap->namesOfGroups[i]);
+ }
+ }
+
+ }else {
+ for (int i = 0; i < tmap->namesOfGroups.size(); i++) {
+ globaldata->Groups.push_back(tmap->namesOfGroups[i]);
+ }
+ }
+ }
+ catch(exception& e) {
+ cout << "Standard Error: " << e.what() << " has occurred in the UnifracUnweightedCommand class Function setGroups. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+ exit(1);
+ }
+ catch(...) {
+ cout << "An unknown error has occurred in the UnifracUnweightedCommand class function setGroups. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+ exit(1);
+ }
+
+}
+/*****************************************************************/
+
void printUWSummaryFile();
void printUnweightedFile();
- void saveRandomScores();
+ void saveRandomScores();
+ void setGroups();
};
//clear out old values
data.resize(1,0);
- penalty.resize(t->getNumLeaves(), 0);
- map<string,double> unique; //group, total of all branch lengths of nodes with that group.
- double shared = 0.0000;
- double UW=0.0000;
+ float UniqueBL=0.0000; //a branch length is unique if it's chidren are from the same group
+ float totalBL = 0.00; //all branch lengths
+ float UW = 0.00; //Unweighted Value = UniqueBL / totalBL;
- //add up the branch lengths for each group.
- for(int i=0;i<t->getNumLeaves();i++){
- if(t->tree[i].pGroups.size() > 0){
- unique[t->tree[i].pGroups.begin()->first] += t->tree[i].getBranchLength();
- }
- }
-
- //for each non-leaf node
+ map<string, int>::iterator it; //iterator to traverse pgroups
+ map<string, int> copyLCpcount;
+ map<string, int> copyRCpcount;
+ map<string, int> copyIpcount;
+
for(int i=t->getNumLeaves();i<t->getNumNodes();i++){
int lc = t->tree[i].getLChild(); //lc = vector index of left child
int rc = t->tree[i].getRChild(); //rc = vector index of right child
- //get penalty values
- if(t->tree[rc].pGroups.size() == 0 || t->tree[lc].pGroups.size() == 0){
- penalty.push_back(penalty[t->tree[rc].getIndex()]+penalty[t->tree[lc].getIndex()]);
- }
- else if(t->tree[i].pGroups.size() > t->tree[rc].pGroups.size() || t->tree[i].pGroups.size() > t->tree[lc].pGroups.size()){
- penalty.push_back(penalty[t->tree[rc].getIndex()]+penalty[t->tree[lc].getIndex()]+1);
+ /**********************************************************************/
+ //This section adds in all lengths that are non leaf
+
+ //copy left childs pGroups and remove groups that the user doesn't want
+ copyIpcount = t->tree[i].pcount;
+ for (it = copyIpcount.begin(); it != copyIpcount.end(); it++) {
+ if (inUsersGroups(it->first, globaldata->Groups) != true) { copyIpcount.erase(it->first); }
}
- else{
- penalty.push_back(penalty[t->tree[rc].getIndex()]+penalty[t->tree[lc].getIndex()]);
+
+ //copy left childs pGroups and remove groups that the user doesn't want
+ copyLCpcount = t->tree[lc].pcount;
+ for (it = copyLCpcount.begin(); it != copyLCpcount.end(); it++) {
+ if (inUsersGroups(it->first, globaldata->Groups) != true) { copyLCpcount.erase(it->first); }
}
- //not sure when this would ever be true??? if your parent is root could be, but pGroups.size() should never be 0.
- if(t->tree[i].getParent() == -1 && (t->tree[lc].pGroups.size() == 0 || t->tree[rc].pGroups.size() == 0)){
- shared -= 1;
+ //copy right childs pGroups and remove groups that the user doesn't want
+ copyRCpcount = t->tree[rc].pcount;
+ for (it = copyRCpcount.begin(); it != copyRCpcount.end(); it++) {
+ if (inUsersGroups(it->first, globaldata->Groups) != true) { copyRCpcount.erase(it->first); }
}
- else if(penalty[i] != 0 && t->tree[i].pGroups.size() != 0){
- shared += t->tree[i].getBranchLength();
+
+ //if i's children are from the same group and i has a BL then add i's length to unique
+ //if copyRCpcount.size() = 0 && copyLCpcount.size() = 0 they are from a branch that is entirely from a group the user doesn't want
+ if ((copyRCpcount.size() == 0) && (copyLCpcount.size() == 0)) { }
+ else {
+ if ((copyRCpcount == copyLCpcount) && (t->tree[i].getBranchLength() != -1)) { UniqueBL += t->tree[i].getBranchLength(); }
+ //if either childs groups = 0 then all of there groups were not valid making the parent unique
+ else if (((copyRCpcount.size() == 0) || (copyLCpcount.size() == 0)) && (t->tree[i].getBranchLength() != -1)) { UniqueBL += t->tree[i].getBranchLength(); }
}
- else if( t->tree[i].pGroups.size() != 0){
- unique[t->tree[i].pGroups.begin()->first] += t->tree[i].getBranchLength();
+
+ //add i's BL to total if it is from the groups the user wants
+ if ((t->tree[i].getBranchLength() != -1) && (copyIpcount.size() != 0)) {
+ totalBL += t->tree[i].getBranchLength();
}
- }
-
- map<string,double>::iterator pos;
- for(pos=unique.begin();pos!=unique.end();pos++){
- if((pos->first!="xxx") && (inUsersGroups(pos->first))){
- UW += unique[pos->first];
+
+ /**********************************************************************/
+ //This section adds in all lengths that are leaf
+
+ //if i's chidren are leaves
+ if (t->tree[rc].getRChild() == -1) {
+ //if rc is a valid group and rc has a BL
+ if ((inUsersGroups(t->tree[rc].getGroup(), globaldata->Groups) == true) && (t->tree[rc].getBranchLength() != -1)) {
+ UniqueBL += t->tree[rc].getBranchLength();
+ totalBL += t->tree[rc].getBranchLength();
+ }
+ }
+
+ if (t->tree[lc].getLChild() == -1) {
+ //if lc is a valid group and lc has a BL
+ if ((inUsersGroups(t->tree[lc].getGroup(), globaldata->Groups) == true) && (t->tree[lc].getBranchLength() != -1)) {
+ UniqueBL += t->tree[lc].getBranchLength();
+ totalBL += t->tree[lc].getBranchLength();
+ }
}
+
+ /**********************************************************************/
+
}
-
- UW /= (UW + shared);
+
+ UW = (UniqueBL / totalBL);
if (isnan(UW) || isinf(UW)) { UW = 0; }
}
-/**************************************************************************************************/
-bool Unweighted::inUsersGroups(string groupname) {
- try {
- for (int i = 0; i < globaldata->Groups.size(); i++) {
- if (groupname == globaldata->Groups[i]) { return true; }
- }
- return false;
- }
- catch(exception& e) {
- cout << "Standard Error: " << e.what() << " has occurred in the Unweighted class Function inUsersGroups. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
- exit(1);
- }
- catch(...) {
- cout << "An unknown error has occurred in the Unweighted class function inUsersGroups. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
- exit(1);
- }
-}
\ No newline at end of file
private:
GlobalData* globaldata;
EstOutput data;
- vector<int> penalty;
TreeMap* tmap;
- bool inUsersGroups(string);
};
using namespace std;
#include "mothur.h"
+#include "treemap.h"
typedef unsigned long long ull;
}
}
-/*******************************************************/
-
+/**************************************************************************************************/
+inline bool inUsersGroups(string groupname, vector<string> Groups) {
+ try {
+ for (int i = 0; i < Groups.size(); i++) {
+ if (groupname == Groups[i]) { return true; }
+ }
+ return false;
+ }
+ catch(exception& e) {
+ cout << "Standard Error: " << e.what() << " has occurred in the utilities class Function inUsersGroups. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+ exit(1);
+ }
+ catch(...) {
+ cout << "An unknown error has occurred in the utilities class function inUsersGroups. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+ exit(1);
+ }
+}
#endif
parameters["iters"] = "iters";
parameters["jumble"] = "jumble";
parameters["freq"] = "freq";
- parameters["single"] = "single";
- parameters["rarefaction"] = "rarefaction";
- parameters["sharedrarefaction"] = "sharedrarefaction";
- parameters["shared"] = "shared";
- parameters["summary"] = "summary";
- parameters["sharedsummary"] = "sharedsummary";
parameters["abund"] = "abund";
parameters["random"] = "random";
parameters["groups"] = "groups";
projects / mothur.git / commitdiff