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"
57 #include "sharedjsd.h"
62 /* This command create a tree file for each similarity calculator at distance level, using various calculators to find the similiarity between groups.
63 The user can select the labels they wish to use as well as the groups they would like included.
64 They can also use as many or as few calculators as they wish. */
67 class MatrixOutputCommand : public Command {
70 MatrixOutputCommand(string);
71 MatrixOutputCommand();
72 ~MatrixOutputCommand();
74 vector<string> setParameters();
75 string getCommandName() { return "dist.shared"; }
76 string getCommandCategory() { return "OTU-Based Approaches"; }
78 string getHelpString();
79 string getOutputPattern(string);
80 string getCitation() { return "http://www.mothur.org/wiki/Dist.shared"; }
81 string getDescription() { return "generate a distance matrix that describes the dissimilarity among multiple groups"; }
85 void help() { m->mothurOut(getHelpString()); }
92 vector<linePair> lines;
94 void printSims(ostream&, vector< vector<double> >&);
95 int process(vector<SharedRAbundVector*>);
97 vector<Calculator*> matrixCalculators;
98 //vector< vector<float> > simMatrix;
100 vector<SharedRAbundVector*> lookup;
101 string exportFileName, output, sharedfile;
102 int numGroups, processors, iters, subsampleSize;
105 bool abort, allLines, subsample;
106 set<string> labels; //holds labels to be used
107 string outputFile, calc, groups, label, outputDir, mode;
108 vector<string> Estimators, Groups, outputNames; //holds estimators to be used
109 int process(vector<SharedRAbundVector*>, string, string);
110 int driver(vector<SharedRAbundVector*>, int, int, vector< vector<seqDist> >&);
114 /**************************************************************************************************/
115 //custom data structure for threads to use.
116 // This is passed by void pointer so it can be any data type
117 // that can be passed using a single void pointer (LPVOID).
118 struct distSharedData {
119 vector<SharedRAbundVector*> thisLookup;
120 vector< vector<seqDist> > calcDists;
121 vector<string> Estimators;
122 unsigned long long start;
123 unsigned long long end;
128 distSharedData(MothurOut* mout, unsigned long long st, unsigned long long en, vector<string> est, vector<SharedRAbundVector*> lu) {
137 /**************************************************************************************************/
138 #if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)
140 static DWORD WINAPI MyDistSharedThreadFunction(LPVOID lpParam){
141 distSharedData* pDataArray;
142 pDataArray = (distSharedData*)lpParam;
146 vector<Calculator*> matrixCalculators;
147 ValidCalculators validCalculator;
148 for (int i=0; i<pDataArray->Estimators.size(); i++) {
149 if (validCalculator.isValidCalculator("matrix", pDataArray->Estimators[i]) == true) {
150 if (pDataArray->Estimators[i] == "sharedsobs") {
151 matrixCalculators.push_back(new SharedSobsCS());
152 }else if (pDataArray->Estimators[i] == "sharedchao") {
153 matrixCalculators.push_back(new SharedChao1());
154 }else if (pDataArray->Estimators[i] == "sharedace") {
155 matrixCalculators.push_back(new SharedAce());
156 }else if (pDataArray->Estimators[i] == "jabund") {
157 matrixCalculators.push_back(new JAbund());
158 }else if (pDataArray->Estimators[i] == "sorabund") {
159 matrixCalculators.push_back(new SorAbund());
160 }else if (pDataArray->Estimators[i] == "jclass") {
161 matrixCalculators.push_back(new Jclass());
162 }else if (pDataArray->Estimators[i] == "sorclass") {
163 matrixCalculators.push_back(new SorClass());
164 }else if (pDataArray->Estimators[i] == "jest") {
165 matrixCalculators.push_back(new Jest());
166 }else if (pDataArray->Estimators[i] == "sorest") {
167 matrixCalculators.push_back(new SorEst());
168 }else if (pDataArray->Estimators[i] == "thetayc") {
169 matrixCalculators.push_back(new ThetaYC());
170 }else if (pDataArray->Estimators[i] == "thetan") {
171 matrixCalculators.push_back(new ThetaN());
172 }else if (pDataArray->Estimators[i] == "kstest") {
173 matrixCalculators.push_back(new KSTest());
174 }else if (pDataArray->Estimators[i] == "sharednseqs") {
175 matrixCalculators.push_back(new SharedNSeqs());
176 }else if (pDataArray->Estimators[i] == "ochiai") {
177 matrixCalculators.push_back(new Ochiai());
178 }else if (pDataArray->Estimators[i] == "anderberg") {
179 matrixCalculators.push_back(new Anderberg());
180 }else if (pDataArray->Estimators[i] == "kulczynski") {
181 matrixCalculators.push_back(new Kulczynski());
182 }else if (pDataArray->Estimators[i] == "kulczynskicody") {
183 matrixCalculators.push_back(new KulczynskiCody());
184 }else if (pDataArray->Estimators[i] == "lennon") {
185 matrixCalculators.push_back(new Lennon());
186 }else if (pDataArray->Estimators[i] == "morisitahorn") {
187 matrixCalculators.push_back(new MorHorn());
188 }else if (pDataArray->Estimators[i] == "braycurtis") {
189 matrixCalculators.push_back(new BrayCurtis());
190 }else if (pDataArray->Estimators[i] == "whittaker") {
191 matrixCalculators.push_back(new Whittaker());
192 }else if (pDataArray->Estimators[i] == "odum") {
193 matrixCalculators.push_back(new Odum());
194 }else if (pDataArray->Estimators[i] == "canberra") {
195 matrixCalculators.push_back(new Canberra());
196 }else if (pDataArray->Estimators[i] == "structeuclidean") {
197 matrixCalculators.push_back(new StructEuclidean());
198 }else if (pDataArray->Estimators[i] == "structchord") {
199 matrixCalculators.push_back(new StructChord());
200 }else if (pDataArray->Estimators[i] == "hellinger") {
201 matrixCalculators.push_back(new Hellinger());
202 }else if (pDataArray->Estimators[i] == "manhattan") {
203 matrixCalculators.push_back(new Manhattan());
204 }else if (pDataArray->Estimators[i] == "structpearson") {
205 matrixCalculators.push_back(new StructPearson());
206 }else if (pDataArray->Estimators[i] == "soergel") {
207 matrixCalculators.push_back(new Soergel());
208 }else if (pDataArray->Estimators[i] == "spearman") {
209 matrixCalculators.push_back(new Spearman());
210 }else if (pDataArray->Estimators[i] == "structkulczynski") {
211 matrixCalculators.push_back(new StructKulczynski());
212 }else if (pDataArray->Estimators[i] == "speciesprofile") {
213 matrixCalculators.push_back(new SpeciesProfile());
214 }else if (pDataArray->Estimators[i] == "hamming") {
215 matrixCalculators.push_back(new Hamming());
216 }else if (pDataArray->Estimators[i] == "structchi2") {
217 matrixCalculators.push_back(new StructChi2());
218 }else if (pDataArray->Estimators[i] == "gower") {
219 matrixCalculators.push_back(new Gower());
220 }else if (pDataArray->Estimators[i] == "memchi2") {
221 matrixCalculators.push_back(new MemChi2());
222 }else if (pDataArray->Estimators[i] == "memchord") {
223 matrixCalculators.push_back(new MemChord());
224 }else if (pDataArray->Estimators[i] == "memeuclidean") {
225 matrixCalculators.push_back(new MemEuclidean());
226 }else if (pDataArray->Estimators[i] == "mempearson") {
227 matrixCalculators.push_back(new MemPearson());
228 }else if (pDataArray->Estimators[i] == "jsd") {
229 matrixCalculators.push_back(new JSD());
235 pDataArray->calcDists.resize(matrixCalculators.size());
237 vector<SharedRAbundVector*> subset;
238 for (int k = pDataArray->start; k < pDataArray->end; k++) { // pass cdd each set of groups to compare
240 for (int l = 0; l < k; l++) {
242 if (k != l) { //we dont need to similiarity of a groups to itself
243 subset.clear(); //clear out old pair of sharedrabunds
244 //add new pair of sharedrabunds
245 subset.push_back(pDataArray->thisLookup[k]); subset.push_back(pDataArray->thisLookup[l]);
247 for(int i=0;i<matrixCalculators.size();i++) {
249 //if this calc needs all groups to calculate the pair load all groups
250 if (matrixCalculators[i]->getNeedsAll()) {
251 //load subset with rest of lookup for those calcs that need everyone to calc for a pair
252 for (int w = 0; w < pDataArray->thisLookup.size(); w++) {
253 if ((w != k) && (w != l)) { subset.push_back(pDataArray->thisLookup[w]); }
257 vector<double> tempdata = matrixCalculators[i]->getValues(subset); //saves the calculator outputs
259 if (pDataArray->m->control_pressed) { return 1; }
261 seqDist temp(l, k, tempdata[0]);
262 pDataArray->calcDists[i].push_back(temp);
268 for(int i=0;i<matrixCalculators.size();i++){ delete matrixCalculators[i]; }
273 catch(exception& e) {
274 pDataArray->m->errorOut(e, "MatrixOutputCommand", "MyDistSharedThreadFunction");