exit(1);
}
}
-
+/*****************************************************************/
+Tree::Tree(TreeMap* t, vector< vector<double> >& sims) : tmap(t) {
+ try {
+ m = MothurOut::getInstance();
+
+ if (m->runParse == true) { parseTreeFile(); m->runParse = false; }
+ //for(int i = 0; i < globaldata->Treenames.size(); i++) { cout << i << '\t' << globaldata->Treenames[i] << endl; }
+ numLeaves = m->Treenames.size();
+ numNodes = 2*numLeaves - 1;
+
+ tree.resize(numNodes);
+
+ //initialize groupNodeInfo
+ for (int i = 0; i < (tmap->getNamesOfGroups()).size(); i++) {
+ groupNodeInfo[(tmap->getNamesOfGroups())[i]].resize(0);
+ }
+
+ //initialize tree with correct number of nodes, name and group info.
+ for (int i = 0; i < numNodes; i++) {
+ //initialize leaf nodes
+ if (i <= (numLeaves-1)) {
+ tree[i].setName(m->Treenames[i]);
+
+ //save group info
+ string group = tmap->getGroup(m->Treenames[i]);
+
+ vector<string> tempGroups; tempGroups.push_back(group);
+ tree[i].setGroup(tempGroups);
+ groupNodeInfo[group].push_back(i);
+
+ //set pcount and pGroup for groupname to 1.
+ tree[i].pcount[group] = 1;
+ tree[i].pGroups[group] = 1;
+
+ //Treemap knows name, group and index to speed up search
+ tmap->setIndex(m->Treenames[i], i);
+
+ //intialize non leaf nodes
+ }else if (i > (numLeaves-1)) {
+ tree[i].setName("");
+ vector<string> tempGroups;
+ tree[i].setGroup(tempGroups);
+ }
+ }
+
+ //build tree from matrix
+ //initialize indexes
+ map<int, int> indexes; //maps row in simMatrix to vector index in the tree
+ int numGroups = (tmap->getNamesOfGroups()).size();
+ for (int g = 0; g < numGroups; g++) { indexes[g] = g; }
+
+ //do merges and create tree structure by setting parents and children
+ //there are numGroups - 1 merges to do
+ for (int i = 0; i < (numGroups - 1); i++) {
+ float largest = -1000.0;
+
+ if (m->control_pressed) { break; }
+
+ int row, column;
+ //find largest value in sims matrix by searching lower triangle
+ for (int j = 1; j < sims.size(); j++) {
+ for (int k = 0; k < j; k++) {
+ if (sims[j][k] > largest) { largest = sims[j][k]; row = j; column = k; }
+ }
+ }
+
+ //set non-leaf node info and update leaves to know their parents
+ //non-leaf
+ tree[numGroups + i].setChildren(indexes[row], indexes[column]);
+
+ //parents
+ tree[indexes[row]].setParent(numGroups + i);
+ tree[indexes[column]].setParent(numGroups + i);
+
+ //blength = distance / 2;
+ float blength = ((1.0 - largest) / 2);
+
+ //branchlengths
+ tree[indexes[row]].setBranchLength(blength - tree[indexes[row]].getLengthToLeaves());
+ tree[indexes[column]].setBranchLength(blength - tree[indexes[column]].getLengthToLeaves());
+
+ //set your length to leaves to your childs length plus branchlength
+ tree[numGroups + i].setLengthToLeaves(tree[indexes[row]].getLengthToLeaves() + tree[indexes[row]].getBranchLength());
+
+
+ //update index
+ indexes[row] = numGroups+i;
+ indexes[column] = numGroups+i;
+
+ //remove highest value that caused the merge.
+ sims[row][column] = -1000.0;
+ sims[column][row] = -1000.0;
+
+ //merge values in simsMatrix
+ for (int n = 0; n < sims.size(); n++) {
+ //row becomes merge of 2 groups
+ sims[row][n] = (sims[row][n] + sims[column][n]) / 2;
+ sims[n][row] = sims[row][n];
+ //delete column
+ sims[column][n] = -1000.0;
+ sims[n][column] = -1000.0;
+ }
+ }
+
+ //adjust tree to make sure root to tip length is .5
+ int root = findRoot();
+ tree[root].setBranchLength((0.5 - tree[root].getLengthToLeaves()));
+ }
+ catch(exception& e) {
+ m->errorOut(e, "Tree", "Tree");
+ exit(1);
+ }
+}
/*****************************************************************/
Tree::~Tree() {}
/*****************************************************************/
-void Tree::addNamesToCounts() {
+void Tree::addNamesToCounts(map<string, string> nameMap) {
try {
//ex. seq1 seq2,seq3,se4
// seq1 = pasture
string name = tree[i].getName();
- map<string, string>::iterator itNames = m->names.find(name);
+ map<string, string>::iterator itNames = nameMap.find(name);
- if (itNames == m->names.end()) { m->mothurOut(name + " is not in your name file, please correct."); m->mothurOutEndLine(); exit(1); }
+ if (itNames == nameMap.end()) { m->mothurOut(name + " is not in your name file, please correct."); m->mothurOutEndLine(); exit(1); }
else {
vector<string> dupNames;
- m->splitAtComma(m->names[name], dupNames);
+ m->splitAtComma(nameMap[name], dupNames);
map<string, int>::iterator itCounts;
int maxPars = 1;
//float A = clock();
//if user has given a names file we want to include that info in the pgroups and pcount info.
- if(m->names.size() != 0) { addNamesToCounts(); }
+ if(m->names.size() != 0) { addNamesToCounts(m->names); }
//build the pGroups in non leaf nodes to be used in the parsimony calcs.
for (int i = numLeaves; i < numNodes; i++) {
}
}
/*****************************************************************/
-void Tree::getSubTree(Tree* copy, vector<string> Groups) {
+//assumes leaf node names are in groups and no names file - used by indicator command
+void Tree::getSubTree(Tree* Ctree, vector<string> Groups) {
try {
-
+
+ //copy Tree since we are going to destroy it
+ Tree* copy = new Tree(tmap);
+ copy->getCopy(Ctree);
+ copy->assembleTree("nonames");
+
//we want to select some of the leaf nodes to create the output tree
//go through the input Tree starting at parents of leaves
for (int i = 0; i < numNodes; i++) {
//you found the root
if (copy->tree[i].getParent() == -1) { root = i; break; }
}
-
+
int nextSpot = numLeaves;
populateNewTree(copy->tree, root, nextSpot);
+
+ delete copy;
}
catch(exception& e) {
- m->errorOut(e, "Tree", "getCopy");
+ m->errorOut(e, "Tree", "getSubTree");
+ exit(1);
+ }
+}
+/*****************************************************************/
+//assumes nameMap contains unique names as key or is empty.
+//assumes numLeaves defined in tree constructor equals size of seqsToInclude and seqsToInclude only contains unique seqs.
+int Tree::getSubTree(Tree* copy, vector<string> seqsToInclude, map<string, string> nameMap) {
+ try {
+
+ if (numLeaves != seqsToInclude.size()) { m->mothurOut("[ERROR]: numLeaves does not equal numUniques, cannot create subtree.\n"); m->control_pressed = true; return 0; }
+
+ getSubTree(copy, seqsToInclude);
+ if (nameMap.size() != 0) { addNamesToCounts(nameMap); }
+
+ //build the pGroups in non leaf nodes to be used in the parsimony calcs.
+ for (int i = numLeaves; i < numNodes; i++) {
+ if (m->control_pressed) { return 1; }
+
+ tree[i].pGroups = (mergeGroups(i));
+ tree[i].pcount = (mergeGcounts(i));
+ }
+
+ return 0;
+ }
+ catch(exception& e) {
+ m->errorOut(e, "Tree", "getSubTree");
exit(1);
}
}
}
}
/**************************************************************************************************/
-
void Tree::randomLabels(vector<string> g) {
try {
exit(1);
}
}
-/**************************************************************************************************
-
-void Tree::randomLabels(string groupA, string groupB) {
- try {
- int numSeqsA = globaldata->gTreemap->seqsPerGroup[groupA];
- int numSeqsB = globaldata->gTreemap->seqsPerGroup[groupB];
-
- vector<string> randomGroups(numSeqsA+numSeqsB, groupA);
- for(int i=numSeqsA;i<randomGroups.size();i++){
- randomGroups[i] = groupB;
- }
- random_shuffle(randomGroups.begin(), randomGroups.end());
-
- int randomCounter = 0;
- for(int i=0;i<numLeaves;i++){
- if(tree[i].getGroup() == groupA || tree[i].getGroup() == groupB){
- tree[i].setGroup(randomGroups[randomCounter]);
- tree[i].pcount.clear();
- tree[i].pcount[randomGroups[randomCounter]] = 1;
- tree[i].pGroups.clear();
- tree[i].pGroups[randomGroups[randomCounter]] = 1;
- randomCounter++;
- }
- }
- }
- catch(exception& e) {
- m->errorOut(e, "Tree", "randomLabels");
- exit(1);
- }
-}
-**************************************************************************************************/
+/**************************************************************************************************/
void Tree::randomBlengths() {
try {
for(int i=numNodes-1;i>=0;i--){
*/
#include "unifracweightedcommand.h"
+#include "consensus.h"
+#include "subsample.h"
//**********************************************************************************************************************
vector<string> UnifracWeightedCommand::setParameters(){
CommandParameter pgroups("groups", "String", "", "", "", "", "",false,false); parameters.push_back(pgroups);
CommandParameter piters("iters", "Number", "", "1000", "", "", "",false,false); parameters.push_back(piters);
CommandParameter pprocessors("processors", "Number", "", "1", "", "", "",false,false); parameters.push_back(pprocessors);
- CommandParameter prandom("random", "Boolean", "", "F", "", "", "",false,false); parameters.push_back(prandom);
+ CommandParameter psubsample("subsample", "String", "", "", "", "", "",false,false); parameters.push_back(psubsample);
+ CommandParameter pconsensus("consensus", "Boolean", "", "F", "", "", "",false,false); parameters.push_back(pconsensus);
+ CommandParameter prandom("random", "Boolean", "", "F", "", "", "",false,false); parameters.push_back(prandom);
CommandParameter pdistance("distance", "Multiple", "column-lt-square", "column", "", "", "",false,false); parameters.push_back(pdistance);
CommandParameter proot("root", "Boolean", "F", "", "", "", "",false,false); parameters.push_back(proot);
CommandParameter pinputdir("inputdir", "String", "", "", "", "", "",false,false); parameters.push_back(pinputdir);
string UnifracWeightedCommand::getHelpString(){
try {
string helpString = "";
- helpString += "The unifrac.weighted command parameters are tree, group, name, groups, iters, distance, processors, root and random. tree parameter is required unless you have valid current tree file.\n";
+ helpString += "The unifrac.weighted command parameters are tree, group, name, groups, iters, distance, processors, root, subsample, consensus and random. tree parameter is required unless you have valid current tree file.\n";
helpString += "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";
helpString += "The group names are separated by dashes. The iters parameter allows you to specify how many random trees you would like compared to your tree.\n";
helpString += "The distance parameter allows you to create a distance file from the results. The default is false.\n";
helpString += "The random parameter allows you to shut off the comparison to random trees. The default is false, meaning don't compare your trees with randomly generated trees.\n";
helpString += "The root parameter allows you to include the entire root in your calculations. The default is false, meaning stop at the root for this comparision instead of the root of the entire tree.\n";
helpString += "The processors parameter allows you to specify the number of processors to use. The default is 1.\n";
- helpString += "The unifrac.weighted command should be in the following format: unifrac.weighted(groups=yourGroups, iters=yourIters).\n";
+ helpString += "The subsample parameter allows you to enter the size pergroup of the sample or you can set subsample=T and mothur will use the size of your smallest group. The subsample parameter may only be used with a group file.\n";
+ helpString += "The consensus parameter allows you to indicate you would like trees built from distance matrices created with the results, as well as a consensus tree built from these trees. Default=F.\n";
+ helpString += "The unifrac.weighted command should be in the following format: unifrac.weighted(groups=yourGroups, iters=yourIters).\n";
helpString += "Example unifrac.weighted(groups=A-B-C, iters=500).\n";
helpString += "The default value for groups is all the groups in your groupfile, and iters is 1000.\n";
helpString += "The unifrac.weighted command output two files: .weighted and .wsummary their descriptions are in the manual.\n";
outputTypes["wsummary"] = tempOutNames;
outputTypes["phylip"] = tempOutNames;
outputTypes["column"] = tempOutNames;
+ outputTypes["tree"] = tempOutNames;
}
catch(exception& e) {
m->errorOut(e, "UnifracWeightedCommand", "UnifracWeightedCommand");
outputTypes["wsummary"] = tempOutNames;
outputTypes["phylip"] = tempOutNames;
outputTypes["column"] = tempOutNames;
+ outputTypes["tree"] = tempOutNames;
//if the user changes the input directory command factory will send this info to us in the output parameter
string inputDir = validParameter.validFile(parameters, "inputdir", false);
else if (namefile == "not found") { namefile = ""; }
else { m->setNameFile(namefile); }
- outputDir = validParameter.validFile(parameters, "outputdir", false); if (outputDir == "not found"){ outputDir = ""; }
+ outputDir = validParameter.validFile(parameters, "outputdir", false); if (outputDir == "not found"){ outputDir = m->hasPath(treefile); }
//check for optional parameter and set defaults
temp = validParameter.validFile(parameters, "processors", false); if (temp == "not found"){ temp = m->getProcessors(); }
m->setProcessors(temp);
m->mothurConvert(temp, processors);
+
+ temp = validParameter.validFile(parameters, "subsample", false); if (temp == "not found") { temp = "F"; }
+ if (m->isNumeric1(temp)) { m->mothurConvert(temp, subsampleSize); subsample = true; }
+ else {
+ if (m->isTrue(temp)) { subsample = true; subsampleSize = -1; } //we will set it to smallest group later
+ else { subsample = false; }
+ }
- if (!random) { iters = 0; } //turn off random calcs
-
+ if (!subsample) { subsampleIters = 0; }
+ else { subsampleIters = iters; }
+
+ temp = validParameter.validFile(parameters, "consensus", false); if (temp == "not found") { temp = "F"; }
+ consensus = m->isTrue(temp);
+
+ if (subsample && random) { m->mothurOut("[ERROR]: random must be false, if subsample=t.\n"); abort=true; }
+ if (subsample && (groupfile == "")) { m->mothurOut("[ERROR]: if subsample=t, a group file must be provided.\n"); abort=true; }
+ if (subsample && (!phylip)) { phylip=true; outputForm = "lt"; }
+ if (consensus && (!subsample)) { m->mothurOut("[ERROR]: you cannot use consensus without subsample.\n"); abort=true; }
+
if (namefile == "") {
vector<string> files; files.push_back(treefile);
parser.getNameFile(files);
m->setTreeFile(treefile);
- if (groupfile != "") {
+ readTrees(); if (m->control_pressed) { delete tmap; for (int i = 0; i < T.size(); i++) { delete T[i]; } return 0; }
+
+ sumFile = outputDir + m->getSimpleName(treefile) + ".wsummary";
+ m->openOutputFile(sumFile, outSum);
+ outputNames.push_back(sumFile); outputTypes["wsummary"].push_back(sumFile);
+
+ SharedUtil util;
+ string s; //to make work with setgroups
+ Groups = m->getGroups();
+ vector<string> nameGroups = tmap->getNamesOfGroups();
+ util.setGroups(Groups, nameGroups, s, numGroups, "weighted"); //sets the groups the user wants to analyze
+ m->setGroups(Groups);
+
+ if (m->control_pressed) { delete tmap; for (int i = 0; i < T.size(); i++) { delete T[i]; } return 0; }
+
+ Weighted weighted(tmap, includeRoot);
+
+ int start = time(NULL);
+
+ //set or check size
+ if (subsample) {
+ //user has not set size, set size = smallest samples size
+ if (subsampleSize == -1) {
+ vector<string> temp; temp.push_back(Groups[0]);
+ subsampleSize = (tmap->getNamesSeqs(temp)).size(); //num in first group
+ for (int i = 1; i < Groups.size(); i++) {
+ temp.clear(); temp.push_back(Groups[i]);
+ int thisSize = (tmap->getNamesSeqs(temp)).size();
+ if (thisSize < subsampleSize) { subsampleSize = thisSize; }
+ }
+ m->mothurOut("\nSetting subsample size to " + toString(subsampleSize) + ".\n\n");
+ }else { //eliminate any too small groups
+ vector<string> newGroups = Groups;
+ Groups.clear();
+ for (int i = 0; i < newGroups.size(); i++) {
+ vector<string> thisGroup; thisGroup.push_back(newGroups[i]);
+ vector<string> thisGroupsSeqs = tmap->getNamesSeqs(thisGroup);
+ int thisSize = thisGroupsSeqs.size();
+
+ if (thisSize >= subsampleSize) { Groups.push_back(newGroups[i]); }
+ else { m->mothurOut("You have selected a size that is larger than "+newGroups[i]+" number of sequences, removing "+newGroups[i]+".\n"); }
+ }
+ m->setGroups(Groups);
+ }
+ }
+
+ //here in case some groups are removed by subsample
+ util.getCombos(groupComb, Groups, numComp);
+
+ if (numComp < processors) { processors = numComp; }
+
+ if (consensus && (numComp < 2)) { m->mothurOut("consensus can only be used with numComparisions greater than 1, setting consensus=f.\n"); consensus=false; }
+
+ //get weighted scores for users trees
+ for (int i = 0; i < T.size(); i++) {
+
+ if (m->control_pressed) { delete tmap; for (int i = 0; i < T.size(); i++) { delete T[i]; } outSum.close(); for (int i = 0; i < outputNames.size(); i++) { m->mothurRemove(outputNames[i]); } return 0; }
+
+ counter = 0;
+ rScores.resize(numComp); //data[0] = weightedscore AB, data[1] = weightedscore AC...
+ uScores.resize(numComp); //data[0] = weightedscore AB, data[1] = weightedscore AC...
+
+ vector<double> userData; userData.resize(numComp,0); //weighted score info for user tree. data[0] = weightedscore AB, data[1] = weightedscore AC...
+ vector<double> randomData; randomData.resize(numComp,0); //weighted score info for random trees. data[0] = weightedscore AB, data[1] = weightedscore AC...
+
+ if (random) {
+ output = new ColumnFile(outputDir + m->getSimpleName(treefile) + toString(i+1) + ".weighted", itersString);
+ outputNames.push_back(outputDir + m->getSimpleName(treefile) + toString(i+1) + ".weighted");
+ outputTypes["weighted"].push_back(outputDir + m->getSimpleName(treefile) + toString(i+1) + ".weighted");
+ }
+
+ userData = weighted.getValues(T[i], processors, outputDir); //userData[0] = weightedscore
+ if (m->control_pressed) { delete tmap; for (int i = 0; i < T.size(); i++) { delete T[i]; } if (random) { delete output; } outSum.close(); for (int i = 0; i < outputNames.size(); i++) { m->mothurRemove(outputNames[i]); } return 0; }
+
+ //save users score
+ for (int s=0; s<numComp; s++) {
+ //add users score to vector of user scores
+ uScores[s].push_back(userData[s]);
+ //save users tree score for summary file
+ utreeScores.push_back(userData[s]);
+ }
+
+ if (random) { runRandomCalcs(T[i], userData); }
+
+ //clear data
+ rScores.clear();
+ uScores.clear();
+ validScores.clear();
+
+ //subsample loop
+ vector< vector<double> > calcDistsTotals; //each iter, each groupCombos dists. this will be used to make .dist files
+ for (int thisIter = 0; thisIter < subsampleIters; thisIter++) { //subsampleIters=0, if subsample=f.
+
+ if (m->control_pressed) { break; }
+
+ //copy to preserve old one - would do this in subsample but tree needs it and memory cleanup becomes messy.
+ TreeMap* newTmap = new TreeMap();
+ newTmap->getCopy(tmap);
+
+ SubSample sample;
+ Tree* subSampleTree = sample.getSample(T[i], newTmap, nameMap, subsampleSize);
+
+ //call new weighted function
+ vector<double> iterData; iterData.resize(numComp,0);
+ Weighted thisWeighted(newTmap, includeRoot);
+ iterData = thisWeighted.getValues(subSampleTree, processors, outputDir); //userData[0] = weightedscore
+
+ //save data to make ave dist, std dist
+ calcDistsTotals.push_back(iterData);
+
+ delete newTmap;
+ delete subSampleTree;
+ }
+
+ if (m->control_pressed) { delete tmap; for (int i = 0; i < T.size(); i++) { delete T[i]; } if (random) { delete output; } outSum.close(); for (int i = 0; i < outputNames.size(); i++) { m->mothurRemove(outputNames[i]); } return 0; }
+
+ if (subsample) { getAverageSTDMatrices(calcDistsTotals, i); }
+ if (consensus) { getConsensusTrees(calcDistsTotals, i); }
+ }
+
+
+ if (m->control_pressed) { delete tmap; for (int i = 0; i < T.size(); i++) { delete T[i]; } outSum.close(); for (int i = 0; i < outputNames.size(); i++) { m->mothurRemove(outputNames[i]); } return 0; }
+
+ if (phylip) { createPhylipFile(); }
+
+ printWSummaryFile();
+
+ //clear out users groups
+ m->clearGroups();
+ delete tmap;
+ for (int i = 0; i < T.size(); i++) { delete T[i]; }
+
+ if (m->control_pressed) { for (int i = 0; i < outputNames.size(); i++) { m->mothurRemove(outputNames[i]); } return 0; }
+
+ m->mothurOut("It took " + toString(time(NULL) - start) + " secs to run unifrac.weighted."); m->mothurOutEndLine();
+
+ //set phylip file as new current phylipfile
+ string current = "";
+ itTypes = outputTypes.find("phylip");
+ if (itTypes != outputTypes.end()) {
+ if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setPhylipFile(current); }
+ }
+
+ //set column file as new current columnfile
+ itTypes = outputTypes.find("column");
+ if (itTypes != outputTypes.end()) {
+ if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setColumnFile(current); }
+ }
+
+ m->mothurOutEndLine();
+ m->mothurOut("Output File Names: "); m->mothurOutEndLine();
+ for (int i = 0; i < outputNames.size(); i++) { m->mothurOut(outputNames[i]); m->mothurOutEndLine(); }
+ m->mothurOutEndLine();
+
+ return 0;
+
+ }
+ catch(exception& e) {
+ m->errorOut(e, "UnifracWeightedCommand", "execute");
+ exit(1);
+ }
+}
+/**************************************************************************************************/
+int UnifracWeightedCommand::getAverageSTDMatrices(vector< vector<double> >& dists, int treeNum) {
+ try {
+ //we need to find the average distance and standard deviation for each groups distance
+
+ //finds sum
+ vector<double> averages; averages.resize(numComp, 0);
+ for (int thisIter = 0; thisIter < subsampleIters; thisIter++) {
+ for (int i = 0; i < dists[thisIter].size(); i++) {
+ averages[i] += dists[thisIter][i];
+ }
+ }
+
+ //finds average.
+ for (int i = 0; i < averages.size(); i++) { averages[i] /= (float) subsampleIters; }
+
+ //find standard deviation
+ vector<double> stdDev; stdDev.resize(numComp, 0);
+
+ for (int thisIter = 0; thisIter < iters; thisIter++) { //compute the difference of each dist from the mean, and square the result of each
+ for (int j = 0; j < dists[thisIter].size(); j++) {
+ stdDev[j] += ((dists[thisIter][j] - averages[j]) * (dists[thisIter][j] - averages[j]));
+ }
+ }
+ for (int i = 0; i < stdDev.size(); i++) {
+ stdDev[i] /= (float) subsampleIters;
+ stdDev[i] = sqrt(stdDev[i]);
+ }
+
+ //make matrix with scores in it
+ vector< vector<double> > avedists; avedists.resize(m->getNumGroups());
+ for (int i = 0; i < m->getNumGroups(); i++) {
+ avedists[i].resize(m->getNumGroups(), 0.0);
+ }
+
+ //make matrix with scores in it
+ vector< vector<double> > stddists; stddists.resize(m->getNumGroups());
+ for (int i = 0; i < m->getNumGroups(); i++) {
+ stddists[i].resize(m->getNumGroups(), 0.0);
+ }
+
+ //flip it so you can print it
+ int count = 0;
+ for (int r=0; r<m->getNumGroups(); r++) {
+ for (int l = 0; l < r; l++) {
+ avedists[r][l] = averages[count];
+ avedists[l][r] = averages[count];
+ stddists[r][l] = stdDev[count];
+ stddists[l][r] = stdDev[count];
+ count++;
+ }
+ }
+
+ string aveFileName = outputDir + m->getSimpleName(treefile) + toString(treeNum+1) + ".weighted.ave.dist";
+ outputNames.push_back(aveFileName); outputTypes["phylip"].push_back(aveFileName);
+
+ ofstream out;
+ m->openOutputFile(aveFileName, out);
+
+ string stdFileName = outputDir + m->getSimpleName(treefile) + toString(treeNum+1) + ".weighted.std.dist";
+ outputNames.push_back(stdFileName); outputTypes["phylip"].push_back(stdFileName);
+
+ ofstream outStd;
+ m->openOutputFile(stdFileName, outStd);
+
+ if ((outputForm == "lt") || (outputForm == "square")) {
+ //output numSeqs
+ out << m->getNumGroups() << endl;
+ outStd << m->getNumGroups() << endl;
+ }
+
+ //output to file
+ for (int r=0; r<m->getNumGroups(); r++) {
+ //output name
+ string name = (m->getGroups())[r];
+ if (name.length() < 10) { //pad with spaces to make compatible
+ while (name.length() < 10) { name += " "; }
+ }
+
+ if (outputForm == "lt") {
+ out << name << '\t';
+ outStd << name << '\t';
+
+ //output distances
+ for (int l = 0; l < r; l++) { out << avedists[r][l] << '\t'; outStd << stddists[r][l] << '\t';}
+ out << endl; outStd << endl;
+ }else if (outputForm == "square") {
+ out << name << '\t';
+ outStd << name << '\t';
+
+ //output distances
+ for (int l = 0; l < m->getNumGroups(); l++) { out << avedists[r][l] << '\t'; outStd << stddists[r][l] << '\t'; }
+ out << endl; outStd << endl;
+ }else{
+ //output distances
+ for (int l = 0; l < r; l++) {
+ string otherName = (m->getGroups())[l];
+ if (otherName.length() < 10) { //pad with spaces to make compatible
+ while (otherName.length() < 10) { otherName += " "; }
+ }
+
+ out << name << '\t' << otherName << avedists[r][l] << endl;
+ outStd << name << '\t' << otherName << stddists[r][l] << endl;
+ }
+ }
+ }
+ out.close();
+ outStd.close();
+
+ return 0;
+ }
+ catch(exception& e) {
+ m->errorOut(e, "UnifracWeightedCommand", "getAverageSTDMatrices");
+ exit(1);
+ }
+}
+
+/**************************************************************************************************/
+int UnifracWeightedCommand::getConsensusTrees(vector< vector<double> >& dists, int treeNum) {
+ try {
+
+ //used in tree constructor
+ m->runParse = false;
+
+ //create treemap class from groupmap for tree class to use
+ TreeMap* newTmap = new TreeMap();
+ newTmap->makeSim(m->getGroups());
+
+ //clear old tree names if any
+ m->Treenames.clear();
+
+ //fills globaldatas tree names
+ m->Treenames = m->getGroups();
+
+ vector<Tree*> newTrees = buildTrees(dists, treeNum, newTmap); //also creates .all.tre file containing the trees created
+
+ if (m->control_pressed) { delete newTmap; return 0; }
+
+ Consensus con;
+ Tree* conTree = con.getTree(newTrees, newTmap);
+
+ //create a new filename
+ string conFile = outputDir + m->getRootName(m->getSimpleName(treefile)) + toString(treeNum+1) + ".weighted.cons.tre";
+ outputNames.push_back(conFile); outputTypes["tree"].push_back(conFile);
+ ofstream outTree;
+ m->openOutputFile(conFile, outTree);
+
+ if (conTree != NULL) { conTree->print(outTree, "boot"); delete conTree; }
+ outTree.close();
+ delete newTmap;
+
+ return 0;
+
+ }
+ catch(exception& e) {
+ m->errorOut(e, "UnifracWeightedCommand", "getConsensusTrees");
+ exit(1);
+ }
+}
+/**************************************************************************************************/
+
+vector<Tree*> UnifracWeightedCommand::buildTrees(vector< vector<double> >& dists, int treeNum, TreeMap* mytmap) {
+ try {
+
+ vector<Tree*> trees;
+
+ //create a new filename
+ string outputFile = outputDir + m->getRootName(m->getSimpleName(treefile)) + toString(treeNum+1) + ".weighted.all.tre";
+ outputNames.push_back(outputFile); outputTypes["tree"].push_back(outputFile);
+
+ ofstream outAll;
+ m->openOutputFile(outputFile, outAll);
+
+
+ for (int i = 0; i < dists.size(); i++) { //dists[0] are the dists for the first subsampled tree.
+
+ if (m->control_pressed) { break; }
+
+ //make matrix with scores in it
+ vector< vector<double> > sims; sims.resize(m->getNumGroups());
+ for (int j = 0; j < m->getNumGroups(); j++) {
+ sims[j].resize(m->getNumGroups(), 0.0);
+ }
+
+ int count = 0;
+ for (int r=0; r<m->getNumGroups(); r++) {
+ for (int l = 0; l < r; l++) {
+ double sim = -(dists[i][count]-1.0);
+ sims[r][l] = sim;
+ sims[l][r] = sim;
+ count++;
+ }
+ }
+
+ //create tree
+ Tree* tempTree = new Tree(mytmap, sims);
+ tempTree->assembleTree();
+
+ trees.push_back(tempTree);
+
+ //print tree
+ tempTree->print(outAll);
+ }
+
+ outAll.close();
+
+ if (m->control_pressed) { for (int i = 0; i < trees.size(); i++) { delete trees[i]; trees[i] = NULL; } m->mothurRemove(outputFile); }
+
+ return trees;
+ }
+ catch(exception& e) {
+ m->errorOut(e, "UnifracWeightedCommand", "buildTrees");
+ exit(1);
+ }
+}
+/**************************************************************************************************/
+
+int UnifracWeightedCommand::readTrees() {
+ try {
+
+ if (groupfile != "") {
//read in group map info.
tmap = new TreeMap(groupfile);
tmap->readMap();
}
}
}
-
- sumFile = outputDir + m->getSimpleName(treefile) + ".wsummary";
- m->openOutputFile(sumFile, outSum);
- outputNames.push_back(sumFile); outputTypes["wsummary"].push_back(sumFile);
-
- util = new SharedUtil();
- string s; //to make work with setgroups
- Groups = m->getGroups();
- vector<string> nameGroups = tmap->getNamesOfGroups();
- util->setGroups(Groups, nameGroups, s, numGroups, "weighted"); //sets the groups the user wants to analyze
- util->getCombos(groupComb, Groups, numComp);
- m->setGroups(Groups);
- delete util;
-
- weighted = new Weighted(tmap, includeRoot);
-
- int start = time(NULL);
-
- //get weighted for users tree
- userData.resize(numComp,0); //data[0] = weightedscore AB, data[1] = weightedscore AC...
- randomData.resize(numComp,0); //data[0] = weightedscore AB, data[1] = weightedscore AC...
-
- if (numComp < processors) { processors = numComp; }
-
- //get weighted scores for users trees
- for (int i = 0; i < T.size(); i++) {
-
- if (m->control_pressed) { delete tmap; delete weighted;
- for (int i = 0; i < T.size(); i++) { delete T[i]; } outSum.close(); for (int i = 0; i < outputNames.size(); i++) { m->mothurRemove(outputNames[i]); } return 0; }
-
- counter = 0;
- rScores.resize(numComp); //data[0] = weightedscore AB, data[1] = weightedscore AC...
- uScores.resize(numComp); //data[0] = weightedscore AB, data[1] = weightedscore AC...
-
- if (random) {
- output = new ColumnFile(outputDir + m->getSimpleName(treefile) + toString(i+1) + ".weighted", itersString);
- outputNames.push_back(outputDir + m->getSimpleName(treefile) + toString(i+1) + ".weighted");
- outputTypes["weighted"].push_back(outputDir + m->getSimpleName(treefile) + toString(i+1) + ".weighted");
- }
-
- userData = weighted->getValues(T[i], processors, outputDir); //userData[0] = weightedscore
-
- if (m->control_pressed) { delete tmap; delete weighted;
- for (int i = 0; i < T.size(); i++) { delete T[i]; } if (random) { delete output; } outSum.close(); for (int i = 0; i < outputNames.size(); i++) { m->mothurRemove(outputNames[i]); } return 0; }
-
- //save users score
- for (int s=0; s<numComp; s++) {
- //add users score to vector of user scores
- uScores[s].push_back(userData[s]);
-
- //save users tree score for summary file
- utreeScores.push_back(userData[s]);
- }
-
- if (random) {
-
- //calculate number of comparisons i.e. with groups A,B,C = AB, AC, BC = 3;
- vector< vector<string> > namesOfGroupCombos;
- for (int a=0; a<numGroups; a++) {
- for (int l = 0; l < a; l++) {
- vector<string> groups; groups.push_back((m->getGroups())[a]); groups.push_back((m->getGroups())[l]);
- namesOfGroupCombos.push_back(groups);
- }
- }
-
- lines.clear();
-
- #if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)
- if(processors != 1){
- int numPairs = namesOfGroupCombos.size();
- int numPairsPerProcessor = numPairs / processors;
-
- for (int i = 0; i < processors; i++) {
- int startPos = i * numPairsPerProcessor;
- if(i == processors - 1){
- numPairsPerProcessor = numPairs - i * numPairsPerProcessor;
- }
- lines.push_back(linePair(startPos, numPairsPerProcessor));
- }
- }
- #endif
-
- //get scores for random trees
- for (int j = 0; j < iters; j++) {
-
- #if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)
- if(processors == 1){
- driver(T[i], namesOfGroupCombos, 0, namesOfGroupCombos.size(), rScores);
- }else{
- createProcesses(T[i], namesOfGroupCombos, rScores);
- }
- #else
- driver(T[i], namesOfGroupCombos, 0, namesOfGroupCombos.size(), rScores);
- #endif
-
- if (m->control_pressed) { delete tmap; delete weighted;
- for (int i = 0; i < T.size(); i++) { delete T[i]; } delete output; outSum.close(); for (int i = 0; i < outputNames.size(); i++) { m->mothurRemove(outputNames[i]); } return 0; }
-
- //report progress
-// m->mothurOut("Iter: " + toString(j+1)); m->mothurOutEndLine();
- }
- lines.clear();
-
- //find the signifigance of the score for summary file
- for (int f = 0; f < numComp; f++) {
- //sort random scores
- sort(rScores[f].begin(), rScores[f].end());
-
- //the index of the score higher than yours is returned
- //so if you have 1000 random trees the index returned is 100
- //then there are 900 trees with a score greater then you.
- //giving you a signifigance of 0.900
- int index = findIndex(userData[f], f); if (index == -1) { m->mothurOut("error in UnifracWeightedCommand"); m->mothurOutEndLine(); exit(1); } //error code
-
- //the signifigance is the number of trees with the users score or higher
- WScoreSig.push_back((iters-index)/(float)iters);
- }
-
- //out << "Tree# " << i << endl;
- calculateFreqsCumuls();
- printWeightedFile();
-
- delete output;
-
- }
-
- //clear data
- rScores.clear();
- uScores.clear();
- validScores.clear();
- }
-
-
- if (m->control_pressed) { delete tmap; delete weighted;
- for (int i = 0; i < T.size(); i++) { delete T[i]; } outSum.close(); for (int i = 0; i < outputNames.size(); i++) { m->mothurRemove(outputNames[i]); } return 0; }
-
- printWSummaryFile();
-
- if (phylip) { createPhylipFile(); }
-
- //clear out users groups
- m->clearGroups();
- delete tmap; delete weighted;
- for (int i = 0; i < T.size(); i++) { delete T[i]; }
-
-
- if (m->control_pressed) {
- for (int i = 0; i < outputNames.size(); i++) { m->mothurRemove(outputNames[i]); }
- return 0;
- }
-
- m->mothurOut("It took " + toString(time(NULL) - start) + " secs to run unifrac.weighted."); m->mothurOutEndLine();
-
- //set phylip file as new current phylipfile
- string current = "";
- itTypes = outputTypes.find("phylip");
- if (itTypes != outputTypes.end()) {
- if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setPhylipFile(current); }
- }
-
- //set column file as new current columnfile
- itTypes = outputTypes.find("column");
- if (itTypes != outputTypes.end()) {
- if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setColumnFile(current); }
- }
-
- m->mothurOutEndLine();
- m->mothurOut("Output File Names: "); m->mothurOutEndLine();
- for (int i = 0; i < outputNames.size(); i++) { m->mothurOut(outputNames[i]); m->mothurOutEndLine(); }
- m->mothurOutEndLine();
-
- return 0;
-
+ return 0;
+ }
+ catch(exception& e) {
+ m->errorOut(e, "UnifracWeightedCommand", "readTrees");
+ exit(1);
}
+}
+/**************************************************************************************************/
+
+int UnifracWeightedCommand::runRandomCalcs(Tree* thisTree, vector<double> usersScores) {
+ try {
+
+ //calculate number of comparisons i.e. with groups A,B,C = AB, AC, BC = 3;
+ vector< vector<string> > namesOfGroupCombos;
+ for (int a=0; a<numGroups; a++) {
+ for (int l = 0; l < a; l++) {
+ vector<string> groups; groups.push_back((m->getGroups())[a]); groups.push_back((m->getGroups())[l]);
+ namesOfGroupCombos.push_back(groups);
+ }
+ }
+
+ lines.clear();
+
+#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)
+ if(processors != 1){
+ int numPairs = namesOfGroupCombos.size();
+ int numPairsPerProcessor = numPairs / processors;
+
+ for (int i = 0; i < processors; i++) {
+ int startPos = i * numPairsPerProcessor;
+ if(i == processors - 1){
+ numPairsPerProcessor = numPairs - i * numPairsPerProcessor;
+ }
+ lines.push_back(linePair(startPos, numPairsPerProcessor));
+ }
+ }
+#endif
+
+
+ //get scores for random trees
+ for (int j = 0; j < iters; j++) {
+
+#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)
+ if(processors == 1){
+ driver(thisTree, namesOfGroupCombos, 0, namesOfGroupCombos.size(), rScores);
+ }else{
+ createProcesses(thisTree, namesOfGroupCombos, rScores);
+ }
+#else
+ driver(T[i], namesOfGroupCombos, 0, namesOfGroupCombos.size(), rScores);
+#endif
+
+ if (m->control_pressed) { delete tmap; for (int i = 0; i < T.size(); i++) { delete T[i]; } delete output; outSum.close(); for (int i = 0; i < outputNames.size(); i++) { m->mothurRemove(outputNames[i]); } return 0; }
+
+ //report progress
+ // m->mothurOut("Iter: " + toString(j+1)); m->mothurOutEndLine();
+ }
+ lines.clear();
+
+ //find the signifigance of the score for summary file
+ for (int f = 0; f < numComp; f++) {
+ //sort random scores
+ sort(rScores[f].begin(), rScores[f].end());
+
+ //the index of the score higher than yours is returned
+ //so if you have 1000 random trees the index returned is 100
+ //then there are 900 trees with a score greater then you.
+ //giving you a signifigance of 0.900
+ int index = findIndex(usersScores[f], f); if (index == -1) { m->mothurOut("error in UnifracWeightedCommand"); m->mothurOutEndLine(); exit(1); } //error code
+
+ //the signifigance is the number of trees with the users score or higher
+ WScoreSig.push_back((iters-index)/(float)iters);
+ }
+
+ //out << "Tree# " << i << endl;
+ calculateFreqsCumuls();
+ printWeightedFile();
+
+ delete output;
+
+ return 0;
+ }
catch(exception& e) {
- m->errorOut(e, "UnifracWeightedCommand", "execute");
+ m->errorOut(e, "UnifracWeightedCommand", "runRandomCalcs");
exit(1);
}
}
int UnifracWeightedCommand::driver(Tree* t, vector< vector<string> > namesOfGroupCombos, int start, int num, vector< vector<double> >& scores) {
try {
Tree* randT = new Tree(tmap);
-
+
+ Weighted weighted(tmap, includeRoot);
+
for (int h = start; h < (start+num); h++) {
if (m->control_pressed) { return 0; }
if (m->control_pressed) { delete randT; return 0; }
//get wscore of random tree
- EstOutput randomData = weighted->getValues(randT, groupA, groupB);
+ EstOutput randomData = weighted.getValues(randT, groupA, groupB);
if (m->control_pressed) { delete randT; return 0; }
m->splitAtComma(second, dupNames);
for (int i = 0; i < dupNames.size(); i++) {
- nameMap[dupNames[i]] = dupNames[i];
+ nameMap[dupNames[i]] = first;
if ((groupfile == "") && (i != 0)) { tmap->addSeq(dupNames[i], "Group1"); }
}
}else { m->mothurOut(first + " has already been seen in namefile, disregarding names file."); m->mothurOutEndLine(); in.close(); m->names.clear(); namefile = ""; return 1; }
projects / mothur.git / commitdiff