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
 125         distSharedData(){}
 126         distSharedData(MothurOut* mout, unsigned long long st, unsigned long long en, vector<string> est, vector<SharedRAbundVector*> lu) {
 127                 m = mout;
 128                 start = st;
 129                 end = en;
 130         Estimators = est;
 131         thisLookup = lu;
 132         }
 133 };
 134 /**************************************************************************************************/
 135 #if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)
 136 #else
 137 static DWORD WINAPI MyDistSharedThreadFunction(LPVOID lpParam){
 138         distSharedData* pDataArray;
 139         pDataArray = (distSharedData*)lpParam;
 140
 141         try {
 142
 143         vector<Calculator*> matrixCalculators;
 144         ValidCalculators validCalculator;
 145         for (int i=0; i<pDataArray->Estimators.size(); i++) {
 146             if (validCalculator.isValidCalculator("matrix", pDataArray->Estimators[i]) == true) {
 147                 if (pDataArray->Estimators[i] == "sharedsobs") {
 148                     matrixCalculators.push_back(new SharedSobsCS());
 149                 }else if (pDataArray->Estimators[i] == "sharedchao") {
 150                     matrixCalculators.push_back(new SharedChao1());
 151                 }else if (pDataArray->Estimators[i] == "sharedace") {
 152                     matrixCalculators.push_back(new SharedAce());
 153                 }else if (pDataArray->Estimators[i] == "jabund") {
 154                     matrixCalculators.push_back(new JAbund());
 155                 }else if (pDataArray->Estimators[i] == "sorabund") {
 156                     matrixCalculators.push_back(new SorAbund());
 157                 }else if (pDataArray->Estimators[i] == "jclass") {
 158                     matrixCalculators.push_back(new Jclass());
 159                 }else if (pDataArray->Estimators[i] == "sorclass") {
 160                     matrixCalculators.push_back(new SorClass());
 161                 }else if (pDataArray->Estimators[i] == "jest") {
 162                     matrixCalculators.push_back(new Jest());
 163                 }else if (pDataArray->Estimators[i] == "sorest") {
 164                     matrixCalculators.push_back(new SorEst());
 165                 }else if (pDataArray->Estimators[i] == "thetayc") {
 166                     matrixCalculators.push_back(new ThetaYC());
 167                 }else if (pDataArray->Estimators[i] == "thetan") {
 168                     matrixCalculators.push_back(new ThetaN());
 169                 }else if (pDataArray->Estimators[i] == "kstest") {
 170                     matrixCalculators.push_back(new KSTest());
 171                 }else if (pDataArray->Estimators[i] == "sharednseqs") {
 172                     matrixCalculators.push_back(new SharedNSeqs());
 173                 }else if (pDataArray->Estimators[i] == "ochiai") {
 174                     matrixCalculators.push_back(new Ochiai());
 175                 }else if (pDataArray->Estimators[i] == "anderberg") {
 176                     matrixCalculators.push_back(new Anderberg());
 177                 }else if (pDataArray->Estimators[i] == "kulczynski") {
 178                     matrixCalculators.push_back(new Kulczynski());
 179                 }else if (pDataArray->Estimators[i] == "kulczynskicody") {
 180                     matrixCalculators.push_back(new KulczynskiCody());
 181                 }else if (pDataArray->Estimators[i] == "lennon") {
 182                     matrixCalculators.push_back(new Lennon());
 183                 }else if (pDataArray->Estimators[i] == "morisitahorn") {
 184                     matrixCalculators.push_back(new MorHorn());
 185                 }else if (pDataArray->Estimators[i] == "braycurtis") {
 186                     matrixCalculators.push_back(new BrayCurtis());
 187                 }else if (pDataArray->Estimators[i] == "whittaker") {
 188                     matrixCalculators.push_back(new Whittaker());
 189                 }else if (pDataArray->Estimators[i] == "odum") {
 190                     matrixCalculators.push_back(new Odum());
 191                 }else if (pDataArray->Estimators[i] == "canberra") {
 192                     matrixCalculators.push_back(new Canberra());
 193                 }else if (pDataArray->Estimators[i] == "structeuclidean") {
 194                     matrixCalculators.push_back(new StructEuclidean());
 195                 }else if (pDataArray->Estimators[i] == "structchord") {
 196                     matrixCalculators.push_back(new StructChord());
 197                 }else if (pDataArray->Estimators[i] == "hellinger") {
 198                     matrixCalculators.push_back(new Hellinger());
 199                 }else if (pDataArray->Estimators[i] == "manhattan") {
 200                     matrixCalculators.push_back(new Manhattan());
 201                 }else if (pDataArray->Estimators[i] == "structpearson") {
 202                     matrixCalculators.push_back(new StructPearson());
 203                 }else if (pDataArray->Estimators[i] == "soergel") {
 204                     matrixCalculators.push_back(new Soergel());
 205                 }else if (pDataArray->Estimators[i] == "spearman") {
 206                     matrixCalculators.push_back(new Spearman());
 207                 }else if (pDataArray->Estimators[i] == "structkulczynski") {
 208                     matrixCalculators.push_back(new StructKulczynski());
 209                 }else if (pDataArray->Estimators[i] == "speciesprofile") {
 210                     matrixCalculators.push_back(new SpeciesProfile());
 211                 }else if (pDataArray->Estimators[i] == "hamming") {
 212                     matrixCalculators.push_back(new Hamming());
 213                 }else if (pDataArray->Estimators[i] == "structchi2") {
 214                     matrixCalculators.push_back(new StructChi2());
 215                 }else if (pDataArray->Estimators[i] == "gower") {
 216                     matrixCalculators.push_back(new Gower());
 217                 }else if (pDataArray->Estimators[i] == "memchi2") {
 218                     matrixCalculators.push_back(new MemChi2());
 219                 }else if (pDataArray->Estimators[i] == "memchord") {
 220                     matrixCalculators.push_back(new MemChord());
 221                 }else if (pDataArray->Estimators[i] == "memeuclidean") {
 222                     matrixCalculators.push_back(new MemEuclidean());
 223                 }else if (pDataArray->Estimators[i] == "mempearson") {
 224                     matrixCalculators.push_back(new MemPearson());
 225                 }
 226             }
 227         }
 228
 229         pDataArray->calcDists.resize(matrixCalculators.size());
 230
 231                 vector<SharedRAbundVector*> subset;
 232                 for (int k = pDataArray->start; k < pDataArray->end; k++) { // pass cdd each set of groups to compare
 233
 234                         for (int l = 0; l < k; l++) {
 235
 236                                 if (k != l) { //we dont need to similiarity of a groups to itself
 237                                         subset.clear(); //clear out old pair of sharedrabunds
 238                                         //add new pair of sharedrabunds
 239                                         subset.push_back(pDataArray->thisLookup[k]); subset.push_back(pDataArray->thisLookup[l]);
 240
 241                                         for(int i=0;i<matrixCalculators.size();i++) {
 242
 243                                                 //if this calc needs all groups to calculate the pair load all groups
 244                                                 if (matrixCalculators[i]->getNeedsAll()) {
 245                                                         //load subset with rest of lookup for those calcs that need everyone to calc for a pair
 246                                                         for (int w = 0; w < pDataArray->thisLookup.size(); w++) {
 247                                                                 if ((w != k) && (w != l)) { subset.push_back(pDataArray->thisLookup[w]); }
 248                                                         }
 249                                                 }
 250
 251                                                 vector<double> tempdata = matrixCalculators[i]->getValues(subset); //saves the calculator outputs
 252
 253                                                 if (pDataArray->m->control_pressed) { return 1; }
 254
 255                                                 seqDist temp(l, k, tempdata[0]);
 256                                                 pDataArray->calcDists[i].push_back(temp);
 257                                         }
 258                                 }
 259                         }
 260                 }
 261
 262         for(int i=0;i<matrixCalculators.size();i++){  delete matrixCalculators[i]; }
 263
 264                 return 0;
 265
 266         }
 267         catch(exception& e) {
 268                 pDataArray->m->errorOut(e, "MatrixOutputCommand", "MyDistSharedThreadFunction");
 269                 exit(1);
 270         }
 271 }
 272 #endif
 273
 274 #endif
 275