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; }
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; }
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 string outputFileName = outputDir + m->getRootName(m->getSimpleName(inputfile)) + "norm.shared";
202 m->openOutputFile(outputFileName, out);
204 input = new InputData(inputfile, format);
206 //you are reading a sharedfile and you do not want to make relabund
207 if ((format == "sharedfile") && (!makeRelabund)) {
208 lookup = input->getSharedRAbundVectors();
209 string lastLabel = lookup[0]->getLabel();
211 //look for groups whose numseqs is below norm and remove them, warning the user
214 vector<SharedRAbundVector*> temp;
215 for (int i = 0; i < lookup.size(); i++) {
216 if (lookup[i]->getNumSeqs() < norm) {
217 m->mothurOut(lookup[i]->getGroup() + " contains " + toString(lookup[i]->getNumSeqs()) + ". Eliminating."); m->mothurOutEndLine();
220 m->Groups.push_back(lookup[i]->getGroup());
221 temp.push_back(lookup[i]);
227 //if the users enters label "0.06" and there is no "0.06" in their file use the next lowest label.
228 set<string> processedLabels;
229 set<string> userLabels = labels;
231 if (method == "totalgroup") {
232 //set norm to smallest group number
234 norm = lookup[0]->getNumSeqs();
235 for (int i = 1; i < lookup.size(); i++) {
236 if (lookup[i]->getNumSeqs() < norm) { norm = lookup[i]->getNumSeqs(); }
240 m->mothurOut("Normalizing to " + toString(norm) + "."); m->mothurOutEndLine();
244 //as long as you are not at the end of the file or done wih the lines you want
245 while((lookup[0] != NULL) && ((allLines == 1) || (userLabels.size() != 0))) {
247 if (m->control_pressed) { outputTypes.clear(); for (int i = 0; i < lookup.size(); i++) { delete lookup[i]; } m->Groups.clear(); out.close(); remove(outputFileName.c_str()); return 0; }
249 if(allLines == 1 || labels.count(lookup[0]->getLabel()) == 1){
251 m->mothurOut(lookup[0]->getLabel()); m->mothurOutEndLine();
252 if (!m->printedHeaders) { lookup[0]->printHeaders(out); }
253 normalize(lookup, out);
255 processedLabels.insert(lookup[0]->getLabel());
256 userLabels.erase(lookup[0]->getLabel());
259 if ((m->anyLabelsToProcess(lookup[0]->getLabel(), userLabels, "") == true) && (processedLabels.count(lastLabel) != 1)) {
260 string saveLabel = lookup[0]->getLabel();
262 for (int i = 0; i < lookup.size(); i++) { delete lookup[i]; }
263 lookup = input->getSharedRAbundVectors(lastLabel);
264 m->mothurOut(lookup[0]->getLabel()); m->mothurOutEndLine();
265 if (!m->printedHeaders) { lookup[0]->printHeaders(out); }
266 normalize(lookup, out);
268 processedLabels.insert(lookup[0]->getLabel());
269 userLabels.erase(lookup[0]->getLabel());
271 //restore real lastlabel to save below
272 lookup[0]->setLabel(saveLabel);
275 lastLabel = lookup[0]->getLabel();
276 //prevent memory leak
277 for (int i = 0; i < lookup.size(); i++) { delete lookup[i]; lookup[i] = NULL; }
279 if (m->control_pressed) { outputTypes.clear(); m->Groups.clear(); out.close(); remove(outputFileName.c_str()); return 0; }
281 //get next line to process
282 lookup = input->getSharedRAbundVectors();
285 if (m->control_pressed) { outputTypes.clear(); m->Groups.clear(); out.close(); remove(outputFileName.c_str()); return 0; }
287 //output error messages about any remaining user labels
288 set<string>::iterator it;
289 bool needToRun = false;
290 for (it = userLabels.begin(); it != userLabels.end(); it++) {
291 m->mothurOut("Your file does not include the label " + *it);
292 if (processedLabels.count(lastLabel) != 1) {
293 m->mothurOut(". I will use " + lastLabel + "."); m->mothurOutEndLine();
296 m->mothurOut(". Please refer to " + lastLabel + "."); m->mothurOutEndLine();
300 //run last label if you need to
301 if (needToRun == true) {
302 for (int i = 0; i < lookup.size(); i++) { if (lookup[i] != NULL) { delete lookup[i]; } }
303 lookup = input->getSharedRAbundVectors(lastLabel);
305 m->mothurOut(lookup[0]->getLabel()); m->mothurOutEndLine();
306 if (!m->printedHeaders) { lookup[0]->printHeaders(out); }
307 normalize(lookup, out);
309 for (int i = 0; i < lookup.size(); i++) { delete lookup[i]; }
312 }else{ //relabund values
313 lookupFloat = input->getSharedRAbundFloatVectors();
314 string lastLabel = lookupFloat[0]->getLabel();
316 //if the users enters label "0.06" and there is no "0.06" in their file use the next lowest label.
317 set<string> processedLabels;
318 set<string> userLabels = labels;
320 //look for groups whose numseqs is below norm and remove them, warning the user
323 vector<SharedRAbundFloatVector*> temp;
324 for (int i = 0; i < lookupFloat.size(); i++) {
325 if (lookupFloat[i]->getNumSeqs() < norm) {
326 m->mothurOut(lookupFloat[i]->getGroup() + " contains " + toString(lookupFloat[i]->getNumSeqs()) + ". Eliminating."); m->mothurOutEndLine();
327 delete lookupFloat[i];
329 m->Groups.push_back(lookupFloat[i]->getGroup());
330 temp.push_back(lookupFloat[i]);
336 //set norm to smallest group number
337 if (method == "totalgroup") {
339 norm = lookupFloat[0]->getNumSeqs();
340 for (int i = 1; i < lookupFloat.size(); i++) {
341 if (lookupFloat[i]->getNumSeqs() < norm) { norm = lookupFloat[i]->getNumSeqs(); }
345 m->mothurOut("Normalizing to " + toString(norm) + "."); m->mothurOutEndLine();
348 //as long as you are not at the end of the file or done wih the lines you want
349 while((lookupFloat[0] != NULL) && ((allLines == 1) || (userLabels.size() != 0))) {
351 if (m->control_pressed) { outputTypes.clear(); for (int i = 0; i < lookupFloat.size(); i++) { delete lookupFloat[i]; } m->Groups.clear(); out.close(); remove(outputFileName.c_str()); return 0; }
353 if(allLines == 1 || labels.count(lookupFloat[0]->getLabel()) == 1){
355 m->mothurOut(lookupFloat[0]->getLabel()); m->mothurOutEndLine();
357 if (!m->printedHeaders) { lookupFloat[0]->printHeaders(out); }
358 normalize(lookupFloat, out);
360 processedLabels.insert(lookupFloat[0]->getLabel());
361 userLabels.erase(lookupFloat[0]->getLabel());
364 if ((m->anyLabelsToProcess(lookupFloat[0]->getLabel(), userLabels, "") == true) && (processedLabels.count(lastLabel) != 1)) {
365 string saveLabel = lookupFloat[0]->getLabel();
367 for (int i = 0; i < lookupFloat.size(); i++) { delete lookupFloat[i]; }
368 lookupFloat = input->getSharedRAbundFloatVectors(lastLabel);
370 m->mothurOut(lookupFloat[0]->getLabel()); m->mothurOutEndLine();
371 if (!m->printedHeaders) { lookupFloat[0]->printHeaders(out); }
372 normalize(lookupFloat, out);
374 processedLabels.insert(lookupFloat[0]->getLabel());
375 userLabels.erase(lookupFloat[0]->getLabel());
377 //restore real lastlabel to save below
378 lookupFloat[0]->setLabel(saveLabel);
381 lastLabel = lookupFloat[0]->getLabel();
382 //prevent memory leak
383 for (int i = 0; i < lookupFloat.size(); i++) { delete lookupFloat[i]; lookupFloat[i] = NULL; }
385 if (m->control_pressed) { outputTypes.clear(); m->Groups.clear(); out.close(); remove(outputFileName.c_str()); return 0; }
387 //get next line to process
388 lookupFloat = input->getSharedRAbundFloatVectors();
391 if (m->control_pressed) { outputTypes.clear(); m->Groups.clear(); out.close(); remove(outputFileName.c_str()); return 0; }
393 //output error messages about any remaining user labels
394 set<string>::iterator it;
395 bool needToRun = false;
396 for (it = userLabels.begin(); it != userLabels.end(); it++) {
397 m->mothurOut("Your file does not include the label " + *it);
398 if (processedLabels.count(lastLabel) != 1) {
399 m->mothurOut(". I will use " + lastLabel + "."); m->mothurOutEndLine();
402 m->mothurOut(". Please refer to " + lastLabel + "."); m->mothurOutEndLine();
406 //run last label if you need to
407 if (needToRun == true) {
408 for (int i = 0; i < lookupFloat.size(); i++) { if (lookupFloat[i] != NULL) { delete lookupFloat[i]; } }
409 lookupFloat = input->getSharedRAbundFloatVectors(lastLabel);
411 m->mothurOut(lookupFloat[0]->getLabel()); m->mothurOutEndLine();
413 if (!m->printedHeaders) { lookupFloat[0]->printHeaders(out); }
414 normalize(lookupFloat, out);
416 for (int i = 0; i < lookupFloat.size(); i++) { delete lookupFloat[i]; }
420 //reset groups parameter
425 if (m->control_pressed) { outputTypes.clear(); remove(outputFileName.c_str()); return 0;}
427 m->mothurOutEndLine();
428 m->mothurOut("Output File Names: "); m->mothurOutEndLine();
429 m->mothurOut(outputFileName); m->mothurOutEndLine(); outputNames.push_back(outputFileName); outputTypes["shared"].push_back(outputFileName);
430 m->mothurOutEndLine();
432 //set shared file as new current sharedfile
434 itTypes = outputTypes.find("shared");
435 if (itTypes != outputTypes.end()) {
436 if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setSharedFile(current); }
441 catch(exception& e) {
442 m->errorOut(e, "NormalizeSharedCommand", "execute");
446 //**********************************************************************************************************************
448 int NormalizeSharedCommand::normalize(vector<SharedRAbundVector*>& thisLookUp, ofstream& out){
450 if (pickedGroups) { eliminateZeroOTUS(thisLookUp); }
452 if (method == "totalgroup") {
454 for (int j = 0; j < thisLookUp[0]->getNumBins(); j++) {
456 for (int i = 0; i < thisLookUp.size(); i++) {
458 if (m->control_pressed) { return 0; }
460 int abund = thisLookUp[i]->getAbundance(j);
462 float relabund = abund / (float) thisLookUp[i]->getNumSeqs();
463 float newNorm = relabund * norm;
465 //round to nearest int
466 int finalNorm = (int) floor((newNorm + 0.5));
468 thisLookUp[i]->set(j, finalNorm, thisLookUp[i]->getGroup());
472 }else if (method == "zscore") {
474 for (int j = 0; j < thisLookUp[0]->getNumBins(); j++) {
476 if (m->control_pressed) { return 0; }
480 for (int i = 0; i < thisLookUp.size(); i++) { mean += thisLookUp[i]->getAbundance(j); }
481 mean /= (float) thisLookUp.size();
483 //calc standard deviation
484 float sumSquared = 0.0;
485 for (int i = 0; i < thisLookUp.size(); i++) { sumSquared += (((float)thisLookUp[i]->getAbundance(j) - mean) * ((float)thisLookUp[i]->getAbundance(j) - mean)); }
486 sumSquared /= (float) thisLookUp.size();
488 float standardDev = sqrt(sumSquared);
490 for (int i = 0; i < thisLookUp.size(); i++) {
492 if (standardDev != 0) { // stop divide by zero
493 float newNorm = ((float)thisLookUp[i]->getAbundance(j) - mean) / standardDev;
494 //round to nearest int
495 finalNorm = (int) floor((newNorm + 0.5));
498 thisLookUp[i]->set(j, finalNorm, thisLookUp[i]->getGroup());
502 }else{ m->mothurOut(method + " is not a valid scaling option."); m->mothurOutEndLine(); m->control_pressed = true; return 0; }
506 eliminateZeroOTUS(thisLookUp);
508 for (int i = 0; i < thisLookUp.size(); i++) {
509 out << thisLookUp[i]->getLabel() << '\t' << thisLookUp[i]->getGroup() << '\t';
510 thisLookUp[i]->print(out);
515 catch(exception& e) {
516 m->errorOut(e, "NormalizeSharedCommand", "normalize");
520 //**********************************************************************************************************************
522 int NormalizeSharedCommand::normalize(vector<SharedRAbundFloatVector*>& thisLookUp, ofstream& out){
524 if (pickedGroups) { eliminateZeroOTUS(thisLookUp); }
526 if (method == "totalgroup") {
528 for (int j = 0; j < thisLookUp[0]->getNumBins(); j++) {
530 for (int i = 0; i < thisLookUp.size(); i++) {
532 if (m->control_pressed) { return 0; }
534 float abund = thisLookUp[i]->getAbundance(j);
536 float relabund = abund / (float) thisLookUp[i]->getNumSeqs();
537 float newNorm = relabund * norm;
539 thisLookUp[i]->set(j, newNorm, thisLookUp[i]->getGroup());
543 }else if (method == "zscore") {
544 for (int j = 0; j < thisLookUp[0]->getNumBins(); j++) {
546 if (m->control_pressed) { return 0; }
550 for (int i = 0; i < thisLookUp.size(); i++) { mean += thisLookUp[i]->getAbundance(j); }
551 mean /= (float) thisLookUp.size();
553 //calc standard deviation
554 float sumSquared = 0.0;
555 for (int i = 0; i < thisLookUp.size(); i++) { sumSquared += ((thisLookUp[i]->getAbundance(j) - mean) * (thisLookUp[i]->getAbundance(j) - mean)); }
556 sumSquared /= (float) thisLookUp.size();
558 float standardDev = sqrt(sumSquared);
560 for (int i = 0; i < thisLookUp.size(); i++) {
562 if (standardDev != 0) { // stop divide by zero
563 newNorm = (thisLookUp[i]->getAbundance(j) - mean) / standardDev;
565 thisLookUp[i]->set(j, newNorm, thisLookUp[i]->getGroup());
569 }else{ m->mothurOut(method + " is not a valid scaling option."); m->mothurOutEndLine(); m->control_pressed = true; return 0; }
572 eliminateZeroOTUS(thisLookUp);
574 for (int i = 0; i < thisLookUp.size(); i++) {
575 out << thisLookUp[i]->getLabel() << '\t' << thisLookUp[i]->getGroup() << '\t';
576 thisLookUp[i]->print(out);
581 catch(exception& e) {
582 m->errorOut(e, "NormalizeSharedCommand", "normalize");
586 //**********************************************************************************************************************
587 int NormalizeSharedCommand::eliminateZeroOTUS(vector<SharedRAbundVector*>& thislookup) {
590 vector<SharedRAbundVector*> newLookup;
591 for (int i = 0; i < thislookup.size(); i++) {
592 SharedRAbundVector* temp = new SharedRAbundVector();
593 temp->setLabel(thislookup[i]->getLabel());
594 temp->setGroup(thislookup[i]->getGroup());
595 newLookup.push_back(temp);
599 for (int i = 0; i < thislookup[0]->getNumBins(); i++) {
600 if (m->control_pressed) { for (int j = 0; j < newLookup.size(); j++) { delete newLookup[j]; } return 0; }
602 //look at each sharedRabund and make sure they are not all zero
604 for (int j = 0; j < thislookup.size(); j++) {
605 if (thislookup[j]->getAbundance(i) != 0) { allZero = false; break; }
608 //if they are not all zero add this bin
610 for (int j = 0; j < thislookup.size(); j++) {
611 newLookup[j]->push_back(thislookup[j]->getAbundance(i), thislookup[j]->getGroup());
616 for (int j = 0; j < thislookup.size(); j++) { delete thislookup[j]; }
618 thislookup = newLookup;
623 catch(exception& e) {
624 m->errorOut(e, "NormalizeSharedCommand", "eliminateZeroOTUS");
628 //**********************************************************************************************************************
629 int NormalizeSharedCommand::eliminateZeroOTUS(vector<SharedRAbundFloatVector*>& thislookup) {
632 vector<SharedRAbundFloatVector*> newLookup;
633 for (int i = 0; i < thislookup.size(); i++) {
634 SharedRAbundFloatVector* temp = new SharedRAbundFloatVector();
635 temp->setLabel(thislookup[i]->getLabel());
636 temp->setGroup(thislookup[i]->getGroup());
637 newLookup.push_back(temp);
641 for (int i = 0; i < thislookup[0]->getNumBins(); i++) {
642 if (m->control_pressed) { for (int j = 0; j < newLookup.size(); j++) { delete newLookup[j]; } return 0; }
644 //look at each sharedRabund and make sure they are not all zero
646 for (int j = 0; j < thislookup.size(); j++) {
647 if (thislookup[j]->getAbundance(i) != 0) { allZero = false; break; }
650 //if they are not all zero add this bin
652 for (int j = 0; j < thislookup.size(); j++) {
653 newLookup[j]->push_back(thislookup[j]->getAbundance(i), thislookup[j]->getGroup());
658 for (int j = 0; j < thislookup.size(); j++) { delete thislookup[j]; }
660 thislookup = newLookup;
665 catch(exception& e) {
666 m->errorOut(e, "NormalizeSharedCommand", "eliminateZeroOTUS");
671 //**********************************************************************************************************************