1 #ifndef MATRIXOUTPUTCOMMAND_H
2 #define MATRIXOUTPUTCOMMAND_H
5 * matrixoutputcommand.h
8 * Created by Sarah Westcott on 5/20/09.
9 * Copyright 2009 Schloss Lab UMASS Amherst. All rights reserved.
12 #include "command.hpp"
13 #include "inputdata.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"
41 #include "structeuclidean.h"
42 #include "structchord.h"
43 #include "hellinger.h"
44 #include "manhattan.h"
45 #include "structpearson.h"
48 #include "structkulczynski.h"
49 #include "structchi2.h"
50 #include "speciesprofile.h"
55 #include "memeuclidean.h"
56 #include "mempearson.h"
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. */
66 class MatrixOutputCommand : public Command {
69 MatrixOutputCommand(string);
70 MatrixOutputCommand();
71 ~MatrixOutputCommand();
73 vector<string> setParameters();
74 string getCommandName() { return "dist.shared"; }
75 string getCommandCategory() { return "OTU-Based Approaches"; }
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"; }
84 void help() { m->mothurOut(getHelpString()); }
91 vector<linePair> lines;
93 void printSims(ostream&, vector< vector<double> >&);
94 int process(vector<SharedRAbundVector*>);
96 vector<Calculator*> matrixCalculators;
97 //vector< vector<float> > simMatrix;
99 vector<SharedRAbundVector*> lookup;
100 string exportFileName, output, sharedfile;
101 int numGroups, processors, iters, subsampleSize;
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> >&);
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;
127 distSharedData(MothurOut* mout, unsigned long long st, unsigned long long en, vector<string> est, vector<SharedRAbundVector*> lu) {
136 /**************************************************************************************************/
137 #if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)
139 static DWORD WINAPI MyDistSharedThreadFunction(LPVOID lpParam){
140 distSharedData* pDataArray;
141 pDataArray = (distSharedData*)lpParam;
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());
231 pDataArray->calcDists.resize(matrixCalculators.size());
233 vector<SharedRAbundVector*> subset;
234 for (int k = pDataArray->start; k < pDataArray->end; k++) { // pass cdd each set of groups to compare
236 for (int l = 0; l < k; l++) {
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]);
243 for(int i=0;i<matrixCalculators.size();i++) {
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]); }
253 vector<double> tempdata = matrixCalculators[i]->getValues(subset); //saves the calculator outputs
255 if (pDataArray->m->control_pressed) { return 1; }
257 seqDist temp(l, k, tempdata[0]);
258 pDataArray->calcDists[i].push_back(temp);
264 for(int i=0;i<matrixCalculators.size();i++){ delete matrixCalculators[i]; }
269 catch(exception& e) {
270 pDataArray->m->errorOut(e, "MatrixOutputCommand", "MyDistSharedThreadFunction");