2 * normalizesharedcommand.cpp
5 * Created by westcott on 9/15/10.
6 * Copyright 2010 Schloss Lab. All rights reserved.
10 #include "normalizesharedcommand.h"
12 //**********************************************************************************************************************
13 vector<string> NormalizeSharedCommand::setParameters(){
15 CommandParameter pshared("shared", "InputTypes", "", "", "LRSS", "LRSS", "none",false,false); parameters.push_back(pshared);
16 CommandParameter prelabund("relabund", "InputTypes", "", "", "LRSS", "LRSS", "none",false,false); parameters.push_back(prelabund);
17 CommandParameter pgroups("groups", "String", "", "", "", "", "",false,false); parameters.push_back(pgroups);
18 CommandParameter pmethod("method", "Multiple", "totalgroup-zscore", "totalgroup", "", "", "",false,false); parameters.push_back(pmethod);
19 CommandParameter pnorm("norm", "Number", "", "0", "", "", "",false,false); parameters.push_back(pnorm);
20 CommandParameter pmakerelabund("makerelabund", "Boolean", "", "F", "", "", "",false,false); parameters.push_back(pmakerelabund);
21 CommandParameter plabel("label", "String", "", "", "", "", "",false,false); parameters.push_back(plabel);
22 CommandParameter pinputdir("inputdir", "String", "", "", "", "", "",false,false); parameters.push_back(pinputdir);
23 CommandParameter poutputdir("outputdir", "String", "", "", "", "", "",false,false); parameters.push_back(poutputdir);
25 vector<string> myArray;
26 for (int i = 0; i < parameters.size(); i++) { myArray.push_back(parameters[i].name); }
30 m->errorOut(e, "NormalizeSharedCommand", "setParameters");
34 //**********************************************************************************************************************
35 string NormalizeSharedCommand::getHelpString(){
37 string helpString = "";
38 helpString += "The normalize.shared command parameters are shared, relabund, groups, method, norm, makerelabund and label. shared or relabund is required, unless you have a valid current file.\n";
39 helpString += "The groups parameter allows you to specify which of the groups in your groupfile you would like included. The group names are separated by dashes.\n";
40 helpString += "The label parameter allows you to select what distance levels you would like, and are also separated by dashes.\n";
41 helpString += "The method parameter allows you to select what method you would like to use to normalize. The options are totalgroup and zscore. We hope to add more ways to normalize in the future, suggestions are welcome!\n";
42 helpString += "The makerelabund parameter allows you to convert a shared file to a relabund file before you normalize. default=f.\n";
43 helpString += "The norm parameter allows you to number you would like to normalize to. By default this is set to the number of sequences in your smallest group.\n";
44 helpString += "The normalize.shared command should be in the following format: normalize.shared(groups=yourGroups, label=yourLabels).\n";
45 helpString += "Example normalize.shared(groups=A-B-C, scale=totalgroup).\n";
46 helpString += "The default value for groups is all the groups in your groupfile, and all labels in your inputfile will be used.\n";
47 helpString += "The normalize.shared command outputs a .norm.shared file.\n";
48 helpString += "Note: No spaces between parameter labels (i.e. groups), '=' and parameters (i.e.yourGroups).\n";
52 m->errorOut(e, "NormalizeSharedCommand", "getHelpString");
58 //**********************************************************************************************************************
59 NormalizeSharedCommand::NormalizeSharedCommand(){
61 abort = true; calledHelp = true;
63 vector<string> tempOutNames;
64 outputTypes["shared"] = tempOutNames;
67 m->errorOut(e, "NormalizeSharedCommand", "NormalizeSharedCommand");
71 //**********************************************************************************************************************
73 NormalizeSharedCommand::NormalizeSharedCommand(string option) {
75 abort = false; calledHelp = false;
78 //allow user to run help
79 if(option == "help") { help(); abort = true; calledHelp = true; }
80 else if(option == "citation") { citation(); abort = true; calledHelp = true;}
83 vector<string> myArray = setParameters();
85 OptionParser parser(option);
86 map<string,string> parameters = parser.getParameters();
87 map<string,string>::iterator it;
89 ValidParameters validParameter;
91 //check to make sure all parameters are valid for command
92 for (it = parameters.begin(); it != parameters.end(); it++) {
93 if (validParameter.isValidParameter(it->first, myArray, it->second) != true) { abort = true; }
96 //initialize outputTypes
97 vector<string> tempOutNames;
98 outputTypes["shared"] = tempOutNames;
100 //if the user changes the input directory command factory will send this info to us in the output parameter
101 string inputDir = validParameter.validFile(parameters, "inputdir", false);
102 if (inputDir == "not found"){ inputDir = ""; }
105 it = parameters.find("shared");
106 //user has given a template file
107 if(it != parameters.end()){
108 path = m->hasPath(it->second);
109 //if the user has not given a path then, add inputdir. else leave path alone.
110 if (path == "") { parameters["shared"] = inputDir + it->second; }
113 it = parameters.find("relabund");
114 //user has given a template file
115 if(it != parameters.end()){
116 path = m->hasPath(it->second);
117 //if the user has not given a path then, add inputdir. else leave path alone.
118 if (path == "") { parameters["relabund"] = inputDir + it->second; }
122 sharedfile = validParameter.validFile(parameters, "shared", true);
123 if (sharedfile == "not open") { sharedfile = ""; abort = true; }
124 else if (sharedfile == "not found") { sharedfile = ""; }
125 else { format = "sharedfile"; inputfile = sharedfile; m->setSharedFile(sharedfile); }
127 relabundfile = validParameter.validFile(parameters, "relabund", true);
128 if (relabundfile == "not open") { relabundfile = ""; abort = true; }
129 else if (relabundfile == "not found") { relabundfile = ""; }
130 else { format = "relabund"; inputfile = relabundfile; m->setRelAbundFile(relabundfile); }
133 if ((sharedfile == "") && (relabundfile == "")) {
134 //is there are current file available for any of these?
135 //give priority to shared, then list, then rabund, then sabund
136 //if there is a current shared file, use it
137 sharedfile = m->getSharedFile();
138 if (sharedfile != "") { inputfile = sharedfile; format = "sharedfile"; m->mothurOut("Using " + sharedfile + " as input file for the shared parameter."); m->mothurOutEndLine(); }
140 relabundfile = m->getRelAbundFile();
141 if (relabundfile != "") { inputfile = relabundfile; format = "relabund"; m->mothurOut("Using " + relabundfile + " as input file for the relabund parameter."); m->mothurOutEndLine(); }
143 m->mothurOut("No valid current files. You must provide a list, sabund, rabund, relabund or shared file."); m->mothurOutEndLine();
150 //if the user changes the output directory command factory will send this info to us in the output parameter
151 outputDir = validParameter.validFile(parameters, "outputdir", false); if (outputDir == "not found"){ outputDir = m->hasPath(inputfile); }
155 //check for optional parameter and set defaults
156 // ...at some point should added some additional type checking...
157 label = validParameter.validFile(parameters, "label", false);
158 if (label == "not found") { label = ""; }
160 if(label != "all") { m->splitAtDash(label, labels); allLines = 0; }
161 else { allLines = 1; }
164 groups = validParameter.validFile(parameters, "groups", false);
165 if (groups == "not found") { groups = ""; pickedGroups = false; }
168 m->splitAtDash(groups, Groups);
172 method = validParameter.validFile(parameters, "method", false); if (method == "not found") { method = "totalgroup"; }
173 if ((method != "totalgroup") && (method != "zscore")) { m->mothurOut(method + " is not a valid scaling option for the normalize.shared command. The options are totalgroup and zscore. We hope to add more ways to normalize in the future, suggestions are welcome!"); m->mothurOutEndLine(); abort = true; }
175 string temp = validParameter.validFile(parameters, "norm", false);
176 if (temp == "not found") {
177 norm = 0; //once you have read, set norm to smallest group number
180 if (norm < 0) { m->mothurOut("norm must be positive."); m->mothurOutEndLine(); abort=true; }
183 temp = validParameter.validFile(parameters, "makerelabund", false); if (temp == "") { temp = "f"; }
184 makeRelabund = m->isTrue(temp);
188 catch(exception& e) {
189 m->errorOut(e, "NormalizeSharedCommand", "NormalizeSharedCommand");
193 //**********************************************************************************************************************
195 int NormalizeSharedCommand::execute(){
198 if (abort == true) { if (calledHelp) { return 0; } return 2; }
200 input = new InputData(inputfile, format);
202 //you are reading a sharedfile and you do not want to make relabund
203 if ((format == "sharedfile") && (!makeRelabund)) {
204 lookup = input->getSharedRAbundVectors();
205 string lastLabel = lookup[0]->getLabel();
207 //look for groups whose numseqs is below norm and remove them, warning the user
210 vector<SharedRAbundVector*> temp;
211 for (int i = 0; i < lookup.size(); i++) {
212 if (lookup[i]->getNumSeqs() < norm) {
213 m->mothurOut(lookup[i]->getGroup() + " contains " + toString(lookup[i]->getNumSeqs()) + ". Eliminating."); m->mothurOutEndLine();
216 m->Groups.push_back(lookup[i]->getGroup());
217 temp.push_back(lookup[i]);
223 //if the users enters label "0.06" and there is no "0.06" in their file use the next lowest label.
224 set<string> processedLabels;
225 set<string> userLabels = labels;
227 if (method == "totalgroup") {
228 //set norm to smallest group number
230 norm = lookup[0]->getNumSeqs();
231 for (int i = 1; i < lookup.size(); i++) {
232 if (lookup[i]->getNumSeqs() < norm) { norm = lookup[i]->getNumSeqs(); }
236 m->mothurOut("Normalizing to " + toString(norm) + "."); m->mothurOutEndLine();
240 //as long as you are not at the end of the file or done wih the lines you want
241 while((lookup[0] != NULL) && ((allLines == 1) || (userLabels.size() != 0))) {
243 if (m->control_pressed) { for (int i = 0; i < outputNames.size(); i++) { m->mothurRemove(outputNames[i]); } outputTypes.clear(); for (int i = 0; i < lookup.size(); i++) { delete lookup[i]; } m->Groups.clear(); return 0; }
245 if(allLines == 1 || labels.count(lookup[0]->getLabel()) == 1){
247 m->mothurOut(lookup[0]->getLabel()); m->mothurOutEndLine();
250 processedLabels.insert(lookup[0]->getLabel());
251 userLabels.erase(lookup[0]->getLabel());
254 if ((m->anyLabelsToProcess(lookup[0]->getLabel(), userLabels, "") == true) && (processedLabels.count(lastLabel) != 1)) {
255 string saveLabel = lookup[0]->getLabel();
257 for (int i = 0; i < lookup.size(); i++) { delete lookup[i]; }
258 lookup = input->getSharedRAbundVectors(lastLabel);
259 m->mothurOut(lookup[0]->getLabel()); m->mothurOutEndLine();
263 processedLabels.insert(lookup[0]->getLabel());
264 userLabels.erase(lookup[0]->getLabel());
266 //restore real lastlabel to save below
267 lookup[0]->setLabel(saveLabel);
270 lastLabel = lookup[0]->getLabel();
271 //prevent memory leak
272 for (int i = 0; i < lookup.size(); i++) { delete lookup[i]; lookup[i] = NULL; }
274 if (m->control_pressed) { for (int i = 0; i < outputNames.size(); i++) { m->mothurRemove(outputNames[i]); } outputTypes.clear(); m->Groups.clear(); return 0; }
276 //get next line to process
277 lookup = input->getSharedRAbundVectors();
280 if (m->control_pressed) { for (int i = 0; i < outputNames.size(); i++) { m->mothurRemove(outputNames[i]); } outputTypes.clear(); m->Groups.clear(); return 0; }
282 //output error messages about any remaining user labels
283 set<string>::iterator it;
284 bool needToRun = false;
285 for (it = userLabels.begin(); it != userLabels.end(); it++) {
286 m->mothurOut("Your file does not include the label " + *it);
287 if (processedLabels.count(lastLabel) != 1) {
288 m->mothurOut(". I will use " + lastLabel + "."); m->mothurOutEndLine();
291 m->mothurOut(". Please refer to " + lastLabel + "."); m->mothurOutEndLine();
295 //run last label if you need to
296 if (needToRun == true) {
297 for (int i = 0; i < lookup.size(); i++) { if (lookup[i] != NULL) { delete lookup[i]; } }
298 lookup = input->getSharedRAbundVectors(lastLabel);
300 m->mothurOut(lookup[0]->getLabel()); m->mothurOutEndLine();
304 for (int i = 0; i < lookup.size(); i++) { delete lookup[i]; }
307 }else{ //relabund values
308 lookupFloat = input->getSharedRAbundFloatVectors();
309 string lastLabel = lookupFloat[0]->getLabel();
311 //if the users enters label "0.06" and there is no "0.06" in their file use the next lowest label.
312 set<string> processedLabels;
313 set<string> userLabels = labels;
315 //look for groups whose numseqs is below norm and remove them, warning the user
318 vector<SharedRAbundFloatVector*> temp;
319 for (int i = 0; i < lookupFloat.size(); i++) {
320 if (lookupFloat[i]->getNumSeqs() < norm) {
321 m->mothurOut(lookupFloat[i]->getGroup() + " contains " + toString(lookupFloat[i]->getNumSeqs()) + ". Eliminating."); m->mothurOutEndLine();
322 delete lookupFloat[i];
324 m->Groups.push_back(lookupFloat[i]->getGroup());
325 temp.push_back(lookupFloat[i]);
331 //set norm to smallest group number
332 if (method == "totalgroup") {
334 norm = lookupFloat[0]->getNumSeqs();
335 for (int i = 1; i < lookupFloat.size(); i++) {
336 if (lookupFloat[i]->getNumSeqs() < norm) { norm = lookupFloat[i]->getNumSeqs(); }
340 m->mothurOut("Normalizing to " + toString(norm) + "."); m->mothurOutEndLine();
343 //as long as you are not at the end of the file or done wih the lines you want
344 while((lookupFloat[0] != NULL) && ((allLines == 1) || (userLabels.size() != 0))) {
346 if (m->control_pressed) { for (int i = 0; i < outputNames.size(); i++) { m->mothurRemove(outputNames[i]); } outputTypes.clear(); for (int i = 0; i < lookupFloat.size(); i++) { delete lookupFloat[i]; } m->Groups.clear(); return 0; }
348 if(allLines == 1 || labels.count(lookupFloat[0]->getLabel()) == 1){
350 m->mothurOut(lookupFloat[0]->getLabel()); m->mothurOutEndLine();
352 normalize(lookupFloat);
354 processedLabels.insert(lookupFloat[0]->getLabel());
355 userLabels.erase(lookupFloat[0]->getLabel());
358 if ((m->anyLabelsToProcess(lookupFloat[0]->getLabel(), userLabels, "") == true) && (processedLabels.count(lastLabel) != 1)) {
359 string saveLabel = lookupFloat[0]->getLabel();
361 for (int i = 0; i < lookupFloat.size(); i++) { delete lookupFloat[i]; }
362 lookupFloat = input->getSharedRAbundFloatVectors(lastLabel);
364 m->mothurOut(lookupFloat[0]->getLabel()); m->mothurOutEndLine();
366 normalize(lookupFloat);
368 processedLabels.insert(lookupFloat[0]->getLabel());
369 userLabels.erase(lookupFloat[0]->getLabel());
371 //restore real lastlabel to save below
372 lookupFloat[0]->setLabel(saveLabel);
375 lastLabel = lookupFloat[0]->getLabel();
376 //prevent memory leak
377 for (int i = 0; i < lookupFloat.size(); i++) { delete lookupFloat[i]; lookupFloat[i] = NULL; }
379 if (m->control_pressed) { for (int i = 0; i < outputNames.size(); i++) { m->mothurRemove(outputNames[i]); } outputTypes.clear(); m->Groups.clear(); return 0; }
381 //get next line to process
382 lookupFloat = input->getSharedRAbundFloatVectors();
385 if (m->control_pressed) { for (int i = 0; i < outputNames.size(); i++) { m->mothurRemove(outputNames[i]); } outputTypes.clear(); m->Groups.clear(); return 0; }
387 //output error messages about any remaining user labels
388 set<string>::iterator it;
389 bool needToRun = false;
390 for (it = userLabels.begin(); it != userLabels.end(); it++) {
391 m->mothurOut("Your file does not include the label " + *it);
392 if (processedLabels.count(lastLabel) != 1) {
393 m->mothurOut(". I will use " + lastLabel + "."); m->mothurOutEndLine();
396 m->mothurOut(". Please refer to " + lastLabel + "."); m->mothurOutEndLine();
400 //run last label if you need to
401 if (needToRun == true) {
402 for (int i = 0; i < lookupFloat.size(); i++) { if (lookupFloat[i] != NULL) { delete lookupFloat[i]; } }
403 lookupFloat = input->getSharedRAbundFloatVectors(lastLabel);
405 m->mothurOut(lookupFloat[0]->getLabel()); m->mothurOutEndLine();
407 normalize(lookupFloat);
409 for (int i = 0; i < lookupFloat.size(); i++) { delete lookupFloat[i]; }
413 //reset groups parameter
417 if (m->control_pressed) { for (int i = 0; i < outputNames.size(); i++) { m->mothurRemove(outputNames[i]); } outputTypes.clear(); return 0;}
419 m->mothurOutEndLine();
420 m->mothurOut("Output File Names: "); m->mothurOutEndLine();
421 //m->mothurOut(outputFileName); m->mothurOutEndLine(); outputNames.push_back(outputFileName); outputTypes["shared"].push_back(outputFileName);
422 for (int i = 0; i < outputNames.size(); i++) { m->mothurOut(outputNames[i]); m->mothurOutEndLine(); }
423 m->mothurOutEndLine();
425 //set shared file as new current sharedfile
427 itTypes = outputTypes.find("shared");
428 if (itTypes != outputTypes.end()) {
429 if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setSharedFile(current); }
434 catch(exception& e) {
435 m->errorOut(e, "NormalizeSharedCommand", "execute");
439 //**********************************************************************************************************************
441 int NormalizeSharedCommand::normalize(vector<SharedRAbundVector*>& thisLookUp){
443 //save mothurOut's binLabels to restore for next label
444 vector<string> saveBinLabels = m->currentBinLabels;
446 if (pickedGroups) { eliminateZeroOTUS(thisLookUp); }
448 string outputFileName = outputDir + m->getRootName(m->getSimpleName(inputfile)) + thisLookUp[0]->getLabel() + ".norm.shared";
450 m->openOutputFile(outputFileName, out);
451 outputNames.push_back(outputFileName); outputTypes["shared"].push_back(outputFileName);
453 if (method == "totalgroup") {
455 //save numSeqs since they will change as the data is normalized
457 for (int i = 0; i < thisLookUp.size(); i++) { sizes.push_back(thisLookUp[i]->getNumSeqs()); }
459 for (int j = 0; j < thisLookUp[0]->getNumBins(); j++) {
461 for (int i = 0; i < thisLookUp.size(); i++) {
463 if (m->control_pressed) { out.close(); return 0; }
465 int abund = thisLookUp[i]->getAbundance(j);
467 float relabund = abund / (float) sizes[i];
468 float newNorm = relabund * norm;
470 //round to nearest int
471 int finalNorm = (int) floor((newNorm + 0.5));
473 thisLookUp[i]->set(j, finalNorm, thisLookUp[i]->getGroup());
477 }else if (method == "zscore") {
479 for (int j = 0; j < thisLookUp[0]->getNumBins(); j++) {
481 if (m->control_pressed) { out.close(); return 0; }
485 for (int i = 0; i < thisLookUp.size(); i++) { mean += thisLookUp[i]->getAbundance(j); }
486 mean /= (float) thisLookUp.size();
488 //calc standard deviation
489 float sumSquared = 0.0;
490 for (int i = 0; i < thisLookUp.size(); i++) { sumSquared += (((float)thisLookUp[i]->getAbundance(j) - mean) * ((float)thisLookUp[i]->getAbundance(j) - mean)); }
491 sumSquared /= (float) thisLookUp.size();
493 float standardDev = sqrt(sumSquared);
495 for (int i = 0; i < thisLookUp.size(); i++) {
497 if (standardDev != 0) { // stop divide by zero
498 float newNorm = ((float)thisLookUp[i]->getAbundance(j) - mean) / standardDev;
499 //round to nearest int
500 finalNorm = (int) floor((newNorm + 0.5));
503 thisLookUp[i]->set(j, finalNorm, thisLookUp[i]->getGroup());
507 }else{ m->mothurOut(method + " is not a valid scaling option."); m->mothurOutEndLine(); m->control_pressed = true; return 0; }
511 eliminateZeroOTUS(thisLookUp);
513 thisLookUp[0]->printHeaders(out);
515 for (int i = 0; i < thisLookUp.size(); i++) {
516 out << thisLookUp[i]->getLabel() << '\t' << thisLookUp[i]->getGroup() << '\t';
517 thisLookUp[i]->print(out);
522 m->currentBinLabels = saveBinLabels;
526 catch(exception& e) {
527 m->errorOut(e, "NormalizeSharedCommand", "normalize");
531 //**********************************************************************************************************************
533 int NormalizeSharedCommand::normalize(vector<SharedRAbundFloatVector*>& thisLookUp){
536 //save mothurOut's binLabels to restore for next label
537 vector<string> saveBinLabels = m->currentBinLabels;
539 string outputFileName = outputDir + m->getRootName(m->getSimpleName(inputfile)) + thisLookUp[0]->getLabel() + ".norm.shared";
541 m->openOutputFile(outputFileName, out);
542 outputNames.push_back(outputFileName); outputTypes["shared"].push_back(outputFileName);
545 if (pickedGroups) { eliminateZeroOTUS(thisLookUp); }
547 if (method == "totalgroup") {
549 //save numSeqs since they will change as the data is normalized
551 for (int i = 0; i < thisLookUp.size(); i++) { sizes.push_back(thisLookUp[i]->getNumSeqs()); }
553 for (int j = 0; j < thisLookUp[0]->getNumBins(); j++) {
555 for (int i = 0; i < thisLookUp.size(); i++) {
557 if (m->control_pressed) { out.close(); return 0; }
559 float abund = thisLookUp[i]->getAbundance(j);
561 float relabund = abund / (float) sizes[i];
562 float newNorm = relabund * norm;
564 thisLookUp[i]->set(j, newNorm, thisLookUp[i]->getGroup());
568 }else if (method == "zscore") {
569 for (int j = 0; j < thisLookUp[0]->getNumBins(); j++) {
571 if (m->control_pressed) { out.close(); return 0; }
575 for (int i = 0; i < thisLookUp.size(); i++) { mean += thisLookUp[i]->getAbundance(j); }
576 mean /= (float) thisLookUp.size();
578 //calc standard deviation
579 float sumSquared = 0.0;
580 for (int i = 0; i < thisLookUp.size(); i++) { sumSquared += ((thisLookUp[i]->getAbundance(j) - mean) * (thisLookUp[i]->getAbundance(j) - mean)); }
581 sumSquared /= (float) thisLookUp.size();
583 float standardDev = sqrt(sumSquared);
585 for (int i = 0; i < thisLookUp.size(); i++) {
587 if (standardDev != 0) { // stop divide by zero
588 newNorm = (thisLookUp[i]->getAbundance(j) - mean) / standardDev;
590 thisLookUp[i]->set(j, newNorm, thisLookUp[i]->getGroup());
594 }else{ m->mothurOut(method + " is not a valid scaling option."); m->mothurOutEndLine(); m->control_pressed = true; return 0; }
597 eliminateZeroOTUS(thisLookUp);
599 thisLookUp[0]->printHeaders(out);
601 for (int i = 0; i < thisLookUp.size(); i++) {
602 out << thisLookUp[i]->getLabel() << '\t' << thisLookUp[i]->getGroup() << '\t';
603 thisLookUp[i]->print(out);
608 m->currentBinLabels = saveBinLabels;
612 catch(exception& e) {
613 m->errorOut(e, "NormalizeSharedCommand", "normalize");
617 //**********************************************************************************************************************
618 int NormalizeSharedCommand::eliminateZeroOTUS(vector<SharedRAbundVector*>& thislookup) {
621 vector<SharedRAbundVector*> newLookup;
622 for (int i = 0; i < thislookup.size(); i++) {
623 SharedRAbundVector* temp = new SharedRAbundVector();
624 temp->setLabel(thislookup[i]->getLabel());
625 temp->setGroup(thislookup[i]->getGroup());
626 newLookup.push_back(temp);
630 vector<string> newBinLabels;
631 for (int i = 0; i < thislookup[0]->getNumBins(); i++) {
632 if (m->control_pressed) { for (int j = 0; j < newLookup.size(); j++) { delete newLookup[j]; } return 0; }
634 //look at each sharedRabund and make sure they are not all zero
636 for (int j = 0; j < thislookup.size(); j++) {
637 if (thislookup[j]->getAbundance(i) != 0) { allZero = false; break; }
640 //if they are not all zero add this bin
642 for (int j = 0; j < thislookup.size(); j++) {
643 newLookup[j]->push_back(thislookup[j]->getAbundance(i), thislookup[j]->getGroup());
645 //if there is a bin label use it otherwise make one
646 string binLabel = "Otu" + (i+1);
647 if (i < m->currentBinLabels.size()) { binLabel = m->currentBinLabels[i]; }
649 newBinLabels.push_back(binLabel);
653 for (int j = 0; j < thislookup.size(); j++) { delete thislookup[j]; }
655 thislookup = newLookup;
656 m->currentBinLabels = newBinLabels;
661 catch(exception& e) {
662 m->errorOut(e, "NormalizeSharedCommand", "eliminateZeroOTUS");
666 //**********************************************************************************************************************
667 int NormalizeSharedCommand::eliminateZeroOTUS(vector<SharedRAbundFloatVector*>& thislookup) {
670 vector<SharedRAbundFloatVector*> newLookup;
671 for (int i = 0; i < thislookup.size(); i++) {
672 SharedRAbundFloatVector* temp = new SharedRAbundFloatVector();
673 temp->setLabel(thislookup[i]->getLabel());
674 temp->setGroup(thislookup[i]->getGroup());
675 newLookup.push_back(temp);
679 vector<string> newBinLabels;
680 for (int i = 0; i < thislookup[0]->getNumBins(); i++) {
681 if (m->control_pressed) { for (int j = 0; j < newLookup.size(); j++) { delete newLookup[j]; } return 0; }
683 //look at each sharedRabund and make sure they are not all zero
685 for (int j = 0; j < thislookup.size(); j++) {
686 if (thislookup[j]->getAbundance(i) != 0) { allZero = false; break; }
689 //if they are not all zero add this bin
691 for (int j = 0; j < thislookup.size(); j++) {
692 newLookup[j]->push_back(thislookup[j]->getAbundance(i), thislookup[j]->getGroup());
694 //if there is a bin label use it otherwise make one
695 string binLabel = "Otu" + (i+1);
696 if (i < m->currentBinLabels.size()) { binLabel = m->currentBinLabels[i]; }
698 newBinLabels.push_back(binLabel);
702 for (int j = 0; j < thislookup.size(); j++) { delete thislookup[j]; }
704 thislookup = newLookup;
705 m->currentBinLabels = newBinLabels;
710 catch(exception& e) {
711 m->errorOut(e, "NormalizeSharedCommand", "eliminateZeroOTUS");
716 //**********************************************************************************************************************