matrixoutputcommand.h

   1 #ifndef MATRIXOUTPUTCOMMAND_H
   2 #define MATRIXOUTPUTCOMMAND_H
   3
   4 /*
   5  *  matrixoutputcommand.h
   6  *  Mothur
   7  *
   8  *  Created by Sarah Westcott on 5/20/09.
   9  *  Copyright 2009 Schloss Lab UMASS Amherst. All rights reserved.
  10  *
  11  */
  12 #include "command.hpp"
  13 #include "inputdata.h"
  14 #include "groupmap.h"
  15 #include "validcalculator.h"
  16 #include "sharedsobscollectsummary.h"
  17 #include "sharedchao1.h"
  18 #include "sharedace.h"
  19 #include "sharednseqs.h"
  20 #include "sharedjabund.h"
  21 #include "sharedsorabund.h"
  22 #include "sharedjclass.h"
  23 #include "sharedsorclass.h"
  24 #include "sharedjest.h"
  25 #include "sharedsorest.h"
  26 #include "sharedthetayc.h"
  27 #include "sharedthetan.h"
  28 #include "sharedkstest.h"
  29 #include "whittaker.h"
  30 #include "sharedochiai.h"
  31 #include "sharedanderbergs.h"
  32 #include "sharedkulczynski.h"
  33 #include "sharedkulczynskicody.h"
  34 #include "sharedlennon.h"
  35 #include "sharedmorisitahorn.h"
  36 #include "sharedbraycurtis.h"
  37 #include "sharedjackknife.h"
  38 #include "whittaker.h"
  39 #include "odum.h"
  40 #include "canberra.h"
  41 #include "structeuclidean.h"
  42 #include "structchord.h"
  43 #include "hellinger.h"
  44 #include "manhattan.h"
  45 #include "structpearson.h"
  46 #include "soergel.h"
  47 #include "spearman.h"
  48 #include "structkulczynski.h"
  49 #include "structchi2.h"
  50 #include "speciesprofile.h"
  51 #include "hamming.h"
  52 #include "gower.h"
  53 #include "memchi2.h"
  54 #include "memchord.h"
  55 #include "memeuclidean.h"
  56 #include "mempearson.h"
  57
  58
  59 // aka. dist.shared()
  60
  61 /* This command create a tree file for each similarity calculator at distance level, using various calculators to find the similiarity between groups.
  62         The user can select the labels they wish to use as well as the groups they would like included.
  63         They can also use as many or as few calculators as they wish. */
  64
  65
  66 class MatrixOutputCommand : public Command {
  67
  68 public:
  69         MatrixOutputCommand(string);
  70         MatrixOutputCommand();
  71         ~MatrixOutputCommand();
  72
  73         vector<string> setParameters();
  74         string getCommandName()                 { return "dist.shared";                         }
  75         string getCommandCategory()             { return "OTU-Based Approaches";        }
  76
  77         string getHelpString();
  78     string getOutputPattern(string);
  79         string getCitation() { return "http://www.mothur.org/wiki/Dist.shared"; }
  80         string getDescription()         { return "generate a distance matrix that describes the dissimilarity among multiple groups"; }
  81
  82
  83         int execute();
  84         void help() { m->mothurOut(getHelpString()); }
  85
  86 private:
  87         struct linePair {
  88                 int start;
  89                 int end;
  90         };
  91         vector<linePair> lines;
  92
  93         void printSims(ostream&, vector< vector<double> >&);
  94         int process(vector<SharedRAbundVector*>);
  95
  96         vector<Calculator*> matrixCalculators;
  97         //vector< vector<float> > simMatrix;
  98         InputData* input;
  99         vector<SharedRAbundVector*> lookup;
 100         string exportFileName, output, sharedfile;
 101         int numGroups, processors, iters, subsampleSize;
 102         ofstream out;
 103
 104         bool abort, allLines, subsample;
 105         set<string> labels; //holds labels to be used
 106         string outputFile, calc, groups, label, outputDir, mode;
 107         vector<string>  Estimators, Groups, outputNames; //holds estimators to be used
 108         int process(vector<SharedRAbundVector*>, string, string);
 109         int driver(vector<SharedRAbundVector*>, int, int, vector< vector<seqDist> >&);
 110
 111 };
 112
 113 /**************************************************************************************************/
 114 //custom data structure for threads to use.
 115 // This is passed by void pointer so it can be any data type
 116 // that can be passed using a single void pointer (LPVOID).
 117 struct distSharedData {
 118     vector<SharedRAbundVector*> thisLookup;
 119     vector< vector<seqDist> > calcDists;
 120     vector<string>  Estimators;
 121         unsigned long long start;
 122         unsigned long long end;
 123         MothurOut* m;
 124     int count;
 125
 126         distSharedData(){}
 127         distSharedData(MothurOut* mout, unsigned long long st, unsigned long long en, vector<string> est, vector<SharedRAbundVector*> lu) {
 128                 m = mout;
 129                 start = st;
 130                 end = en;
 131         Estimators = est;
 132         thisLookup = lu;
 133         count = 0;
 134         }
 135 };
 136 /**************************************************************************************************/
 137 #if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)
 138 #else
 139 static DWORD WINAPI MyDistSharedThreadFunction(LPVOID lpParam){
 140         distSharedData* pDataArray;
 141         pDataArray = (distSharedData*)lpParam;
 142
 143         try {
 144
 145         vector<Calculator*> matrixCalculators;
 146         ValidCalculators validCalculator;
 147         for (int i=0; i<pDataArray->Estimators.size(); i++) {
 148             if (validCalculator.isValidCalculator("matrix", pDataArray->Estimators[i]) == true) {
 149                 if (pDataArray->Estimators[i] == "sharedsobs") {
 150                     matrixCalculators.push_back(new SharedSobsCS());
 151                 }else if (pDataArray->Estimators[i] == "sharedchao") {
 152                     matrixCalculators.push_back(new SharedChao1());
 153                 }else if (pDataArray->Estimators[i] == "sharedace") {
 154                     matrixCalculators.push_back(new SharedAce());
 155                 }else if (pDataArray->Estimators[i] == "jabund") {
 156                     matrixCalculators.push_back(new JAbund());
 157                 }else if (pDataArray->Estimators[i] == "sorabund") {
 158                     matrixCalculators.push_back(new SorAbund());
 159                 }else if (pDataArray->Estimators[i] == "jclass") {
 160                     matrixCalculators.push_back(new Jclass());
 161                 }else if (pDataArray->Estimators[i] == "sorclass") {
 162                     matrixCalculators.push_back(new SorClass());
 163                 }else if (pDataArray->Estimators[i] == "jest") {
 164                     matrixCalculators.push_back(new Jest());
 165                 }else if (pDataArray->Estimators[i] == "sorest") {
 166                     matrixCalculators.push_back(new SorEst());
 167                 }else if (pDataArray->Estimators[i] == "thetayc") {
 168                     matrixCalculators.push_back(new ThetaYC());
 169                 }else if (pDataArray->Estimators[i] == "thetan") {
 170                     matrixCalculators.push_back(new ThetaN());
 171                 }else if (pDataArray->Estimators[i] == "kstest") {
 172                     matrixCalculators.push_back(new KSTest());
 173                 }else if (pDataArray->Estimators[i] == "sharednseqs") {
 174                     matrixCalculators.push_back(new SharedNSeqs());
 175                 }else if (pDataArray->Estimators[i] == "ochiai") {
 176                     matrixCalculators.push_back(new Ochiai());
 177                 }else if (pDataArray->Estimators[i] == "anderberg") {
 178                     matrixCalculators.push_back(new Anderberg());
 179                 }else if (pDataArray->Estimators[i] == "kulczynski") {
 180                     matrixCalculators.push_back(new Kulczynski());
 181                 }else if (pDataArray->Estimators[i] == "kulczynskicody") {
 182                     matrixCalculators.push_back(new KulczynskiCody());
 183                 }else if (pDataArray->Estimators[i] == "lennon") {
 184                     matrixCalculators.push_back(new Lennon());
 185                 }else if (pDataArray->Estimators[i] == "morisitahorn") {
 186                     matrixCalculators.push_back(new MorHorn());
 187                 }else if (pDataArray->Estimators[i] == "braycurtis") {
 188                     matrixCalculators.push_back(new BrayCurtis());
 189                 }else if (pDataArray->Estimators[i] == "whittaker") {
 190                     matrixCalculators.push_back(new Whittaker());
 191                 }else if (pDataArray->Estimators[i] == "odum") {
 192                     matrixCalculators.push_back(new Odum());
 193                 }else if (pDataArray->Estimators[i] == "canberra") {
 194                     matrixCalculators.push_back(new Canberra());
 195                 }else if (pDataArray->Estimators[i] == "structeuclidean") {
 196                     matrixCalculators.push_back(new StructEuclidean());
 197                 }else if (pDataArray->Estimators[i] == "structchord") {
 198                     matrixCalculators.push_back(new StructChord());
 199                 }else if (pDataArray->Estimators[i] == "hellinger") {
 200                     matrixCalculators.push_back(new Hellinger());
 201                 }else if (pDataArray->Estimators[i] == "manhattan") {
 202                     matrixCalculators.push_back(new Manhattan());
 203                 }else if (pDataArray->Estimators[i] == "structpearson") {
 204                     matrixCalculators.push_back(new StructPearson());
 205                 }else if (pDataArray->Estimators[i] == "soergel") {
 206                     matrixCalculators.push_back(new Soergel());
 207                 }else if (pDataArray->Estimators[i] == "spearman") {
 208                     matrixCalculators.push_back(new Spearman());
 209                 }else if (pDataArray->Estimators[i] == "structkulczynski") {
 210                     matrixCalculators.push_back(new StructKulczynski());
 211                 }else if (pDataArray->Estimators[i] == "speciesprofile") {
 212                     matrixCalculators.push_back(new SpeciesProfile());
 213                 }else if (pDataArray->Estimators[i] == "hamming") {
 214                     matrixCalculators.push_back(new Hamming());
 215                 }else if (pDataArray->Estimators[i] == "structchi2") {
 216                     matrixCalculators.push_back(new StructChi2());
 217                 }else if (pDataArray->Estimators[i] == "gower") {
 218                     matrixCalculators.push_back(new Gower());
 219                 }else if (pDataArray->Estimators[i] == "memchi2") {
 220                     matrixCalculators.push_back(new MemChi2());
 221                 }else if (pDataArray->Estimators[i] == "memchord") {
 222                     matrixCalculators.push_back(new MemChord());
 223                 }else if (pDataArray->Estimators[i] == "memeuclidean") {
 224                     matrixCalculators.push_back(new MemEuclidean());
 225                 }else if (pDataArray->Estimators[i] == "mempearson") {
 226                     matrixCalculators.push_back(new MemPearson());
 227                 }
 228             }
 229         }
 230
 231         pDataArray->calcDists.resize(matrixCalculators.size());
 232
 233                 vector<SharedRAbundVector*> subset;
 234                 for (int k = pDataArray->start; k < pDataArray->end; k++) { // pass cdd each set of groups to compare
 235                         pDataArray->count++;
 236                         for (int l = 0; l < k; l++) {
 237
 238                                 if (k != l) { //we dont need to similiarity of a groups to itself
 239                                         subset.clear(); //clear out old pair of sharedrabunds
 240                                         //add new pair of sharedrabunds
 241                                         subset.push_back(pDataArray->thisLookup[k]); subset.push_back(pDataArray->thisLookup[l]);
 242
 243                                         for(int i=0;i<matrixCalculators.size();i++) {
 244
 245                                                 //if this calc needs all groups to calculate the pair load all groups
 246                                                 if (matrixCalculators[i]->getNeedsAll()) {
 247                                                         //load subset with rest of lookup for those calcs that need everyone to calc for a pair
 248                                                         for (int w = 0; w < pDataArray->thisLookup.size(); w++) {
 249                                                                 if ((w != k) && (w != l)) { subset.push_back(pDataArray->thisLookup[w]); }
 250                                                         }
 251                                                 }
 252
 253                                                 vector<double> tempdata = matrixCalculators[i]->getValues(subset); //saves the calculator outputs
 254
 255                                                 if (pDataArray->m->control_pressed) { return 1; }
 256
 257                                                 seqDist temp(l, k, tempdata[0]);
 258                                                 pDataArray->calcDists[i].push_back(temp);
 259                                         }
 260                                 }
 261                         }
 262                 }
 263
 264         for(int i=0;i<matrixCalculators.size();i++){  delete matrixCalculators[i]; }
 265
 266                 return 0;
 267
 268         }
 269         catch(exception& e) {
 270                 pDataArray->m->errorOut(e, "MatrixOutputCommand", "MyDistSharedThreadFunction");
 271                 exit(1);
 272         }
 273 }
 274 #endif
 275
 276 #endif
 277