sharedordervector.cpp

   1 /*
   2  *  sharedSharedOrderVector.cpp
   3  *  Dotur
   4  *
   5  *  Created by Sarah Westcott on 12/9/08.
   6  *  Copyright 2008 Schloss Lab UMASS Amherst. All rights reserved.
   7  *
   8  */
   9
  10 #include "sharedordervector.h"
  11 #include "sharedutilities.h"
  12
  13 /***********************************************************************/
  14
  15 SharedOrderVector::SharedOrderVector() : DataVector(), maxRank(0), numBins(0), numSeqs(0)  {}
  16
  17 /***********************************************************************/
  18
  19 SharedOrderVector::SharedOrderVector(string id, vector<individual>  ov) :
  20                                                                                         DataVector(id), data(ov)
  21 {
  22                 updateStats();
  23 }
  24
  25 /***********************************************************************/
  26 //This function is used to read a .shared file for the collect.shared, rarefaction.shared and summary.shared commands
  27 //if you don't use a list and groupfile.
  28
  29 SharedOrderVector::SharedOrderVector(ifstream& f) : DataVector() {  //reads in a shared file
  30         try {
  31                 globaldata = GlobalData::getInstance();
  32                 maxRank = 0; numBins = 0; numSeqs = 0;
  33
  34                 if (globaldata->gGroupmap == NULL) {  groupmap = new GroupMap(); }
  35
  36                 int num, inputData, count;
  37                 count = 0;  numSeqs = 0;
  38                 string holdLabel, nextLabel, groupN;
  39                 individual newguy;
  40
  41                 //read in first row since you know there is at least 1 group.
  42                 f >> label >> groupN >> num;
  43                 holdLabel = label;
  44
  45                 if (globaldata->gGroupmap == NULL) {
  46                         //save group in groupmap
  47                         groupmap->namesOfGroups.push_back(groupN);
  48                         groupmap->groupIndex[groupN] = 0;
  49                 }
  50
  51                 for(int i=0;i<num;i++){
  52                         f >> inputData;
  53
  54                         for (int j = 0; j < inputData; j++) {
  55                                 push_back(i, i, groupN);
  56                                 numSeqs++;
  57                         }
  58                 }
  59
  60                 m->gobble(f);
  61
  62                 if (f.eof() != true) { f >> nextLabel; }
  63
  64                 //read the rest of the groups info in
  65                 while ((nextLabel == holdLabel) && (f.eof() != true)) {
  66                         f >> groupN >> num;
  67                         count++;
  68
  69                         if (globaldata->gGroupmap == NULL) {
  70                                 //save group in groupmap
  71                                 groupmap->namesOfGroups.push_back(groupN);
  72                                 groupmap->groupIndex[groupN] = count;
  73                         }
  74
  75                         for(int i=0;i<num;i++){
  76                                 f >> inputData;
  77
  78                                 for (int j = 0; j < inputData; j++) {
  79                                         push_back(i, i, groupN);
  80                                         numSeqs++;
  81                                 }
  82                         }
  83
  84                         m->gobble(f);
  85
  86                         if (f.eof() != true) { f >> nextLabel; }
  87
  88                 }
  89
  90                 //put file pointer back since you are now at a new distance label
  91                 for (int i = 0; i < nextLabel.length(); i++) { f.unget();  }
  92
  93                 if (globaldata->gGroupmap == NULL) { globaldata->gGroupmap = groupmap; }
  94
  95                 updateStats();
  96
  97         }
  98         catch(exception& e) {
  99                 m->errorOut(e, "SharedOrderVector", "SharedOrderVector");
 100                 exit(1);
 101         }
 102 }
 103 /***********************************************************************/
 104
 105 int SharedOrderVector::getNumBins(){
 106         return numBins;
 107 }
 108
 109 /***********************************************************************/
 110
 111 int SharedOrderVector::getNumSeqs(){
 112         return numSeqs;
 113 }
 114
 115 /***********************************************************************/
 116
 117 int SharedOrderVector::getMaxRank(){
 118         return maxRank;
 119 }
 120
 121
 122 /***********************************************************************/
 123
 124
 125
 126 void SharedOrderVector::set(int index, int binNumber, int abund, string groupName){
 127
 128         data[index].group = groupName;
 129         data[index].bin = binNumber;
 130         data[index].abundance = abund;
 131         //if (abund > maxRank) { maxRank = abund; }
 132         updateStats();
 133 }
 134
 135 /***********************************************************************/
 136
 137 individual SharedOrderVector::get(int index){
 138         return data[index];
 139 }
 140
 141
 142 /***********************************************************************/
 143 //commented updateStats out to improve speed, but whoever calls this must remember to update when they are done with all the pushbacks they are doing
 144 void SharedOrderVector::push_back(int binNumber, int abund, string groupName){
 145         individual newGuy;
 146         newGuy.group = groupName;
 147         newGuy.abundance = abund;
 148         newGuy.bin = binNumber;
 149         data.push_back(newGuy);
 150         //numSeqs++;
 151         //numBins++;
 152         //if (abund > maxRank) { maxRank = abund; }
 153
 154         //updateStats();
 155 }
 156
 157 /***********************************************************************/
 158
 159 void SharedOrderVector::print(ostream& output){
 160         try {
 161                 output << label << '\t' << numSeqs << '\t';
 162
 163                 for(int i=0;i<data.size();i++){
 164                         output << data[i].bin << '\t';
 165                 }
 166                 output << endl;
 167         }
 168         catch(exception& e) {
 169                 m->errorOut(e, "SharedOrderVector", "print");
 170                 exit(1);
 171         }
 172 }
 173
 174 /***********************************************************************/
 175
 176 void SharedOrderVector::clear(){
 177         numBins = 0;
 178         maxRank = 0;
 179         numSeqs = 0;
 180         data.clear();
 181 }
 182 /***********************************************************************/
 183
 184 void SharedOrderVector::resize(int){
 185         m->mothurOut("resize() did nothing in class SharedOrderVector");
 186 }
 187
 188 /***********************************************************************/
 189
 190
 191 vector<individual>::iterator SharedOrderVector::begin(){
 192         return data.begin();
 193 }
 194
 195 /***********************************************************************/
 196
 197 vector<individual>::iterator SharedOrderVector::end(){
 198         return data.end();
 199 }
 200
 201 /***********************************************************************/
 202
 203 int SharedOrderVector::size(){
 204         return data.size();
 205 }
 206
 207 /***********************************************************************/
 208
 209 RAbundVector SharedOrderVector::getRAbundVector(){
 210         try {
 211                 RAbundVector rav(data.size());
 212
 213                 for(int i=0;i<numSeqs;i++){
 214                         rav.set(data[i].bin, rav.get(data[i].bin) + 1);
 215                 }
 216                 sort(rav.rbegin(), rav.rend());
 217                 for(int i=numSeqs-1;i>=0;i--){
 218                         if(rav.get(i) == 0){    rav.pop_back(); }
 219                         else{
 220                                 break;
 221                         }
 222                 }
 223                 rav.setLabel(label);
 224
 225                 return rav;
 226         }
 227         catch(exception& e) {
 228                 m->errorOut(e, "SharedOrderVector", "getRAbundVector");
 229                 exit(1);
 230         }
 231 }
 232 /***********************************************************************/
 233
 234 OrderVector SharedOrderVector::getOrderVector(map<string,int>* nameMap = NULL) {
 235         try {
 236                 OrderVector ov;
 237
 238                 for (int i = 0; i < data.size(); i++) {
 239                         ov.push_back(data[i].bin);
 240                 }
 241
 242                 random_shuffle(ov.begin(), ov.end());
 243
 244                 ov.setLabel(label);
 245                 return ov;
 246         }
 247         catch(exception& e) {
 248                 m->errorOut(e, "SharedOrderVector", "getOrderVector");
 249                 exit(1);
 250         }
 251 }
 252
 253
 254 /***********************************************************************/
 255
 256 SAbundVector SharedOrderVector::getSAbundVector(){
 257
 258         RAbundVector rav(this->getRAbundVector());
 259         return rav.getSAbundVector();
 260
 261 }
 262 /***********************************************************************/
 263 SharedRAbundVector SharedOrderVector::getSharedRAbundVector(string group) {
 264         try {
 265                 SharedRAbundVector sharedRav(data.size());
 266
 267                 sharedRav.setLabel(label);
 268                 sharedRav.setGroup(group);
 269
 270                 for (int i = 0; i < data.size(); i++) {
 271                         if (data[i].group == group) {
 272                                 sharedRav.set(data[i].abundance, sharedRav.getAbundance(data[i].abundance) + 1, data[i].group);
 273                         }
 274                 }
 275                 return sharedRav;
 276         }
 277         catch(exception& e) {
 278                 m->errorOut(e, "SharedOrderVector", "getSharedRAbundVector");
 279                 exit(1);
 280         }
 281 }
 282 /***********************************************************************/
 283 vector<SharedRAbundVector*> SharedOrderVector::getSharedRAbundVector() {
 284         try {
 285                 SharedUtil* util;
 286                 util = new SharedUtil();
 287                 vector<SharedRAbundVector*> lookup;
 288
 289                 util->setGroups(globaldata->Groups, globaldata->gGroupmap->namesOfGroups);
 290                 util->getSharedVectors(globaldata->Groups, lookup, this);
 291
 292                 return lookup;
 293         }
 294         catch(exception& e) {
 295                 m->errorOut(e, "SharedOrderVector", "getSharedRAbundVector");
 296                 exit(1);
 297         }
 298 }
 299 /***********************************************************************/
 300 SharedSAbundVector SharedOrderVector::getSharedSAbundVector(string group) {
 301         try {
 302
 303                 SharedRAbundVector sharedRav(this->getSharedRAbundVector(group));
 304                 return sharedRav.getSharedSAbundVector();
 305
 306         }
 307         catch(exception& e) {
 308                 m->errorOut(e, "SharedOrderVector", "getSharedSAbundVector");
 309                 exit(1);
 310         }
 311 }
 312
 313 /***********************************************************************/
 314
 315 SharedOrderVector SharedOrderVector::getSharedOrderVector(){
 316         random_shuffle(data.begin(), data.end());
 317         return *this;
 318 }
 319
 320 /***********************************************************************/
 321
 322 void SharedOrderVector::updateStats(){
 323         try {
 324                 needToUpdate = 0;
 325                 numSeqs = 0;
 326                 numBins = 0;
 327                 maxRank = 0;
 328
 329                 numSeqs = data.size();
 330
 331                 vector<int> hold(numSeqs, 0);
 332                 for(int i=0;i<numSeqs;i++){
 333                         hold[data[i].bin] = hold[data[i].bin]+1;
 334                 }
 335
 336                 for(int i=0;i<numSeqs;i++){
 337                         if(hold[i] > 0)                         {       numBins++;                              }
 338                         if(hold[i] > maxRank)           {       maxRank = hold[i];              }
 339                 }
 340
 341         }
 342         catch(exception& e) {
 343                 m->errorOut(e, "SharedOrderVector", "updateStats");
 344                 exit(1);
 345         }
 346 }
 347
 348 /***********************************************************************/
 349
 350