filterseqscommand.h

   1 #ifndef FILTERSEQSCOMMAND_H\r
   2 #define FILTERSEQSCOMMAND_H\r
   3 \r
   4 /*\r
   5  *  filterseqscommand.h\r
   6  *  Mothur\r
   7  *\r
   8  *  Created by Thomas Ryabin on 5/4/09.\r
   9  *  Copyright 2009 Schloss Lab UMASS Amherst. All rights reserved.\r
  10  *\r
  11  */\r
  12 \r
  13 #include "command.hpp"\r
  14 #include "filters.h"\r
  15 \r
  16 class Sequence;\r
  17 class FilterSeqsCommand : public Command {\r
  18 \r
  19 public:\r
  20         FilterSeqsCommand(string);\r
  21         FilterSeqsCommand();\r
  22         ~FilterSeqsCommand() {};\r
  23         \r
  24         vector<string> setParameters();\r
  25         string getCommandName()                 { return "filter.seqs";                 }\r
  26         string getCommandCategory()             { return "Sequence Processing"; }\r
  27         string getOutputFileNameTag(string, string);\r
  28         string getHelpString(); \r
  29         string getCitation() { return "http://www.mothur.org/wiki/Filter.seqs"; }\r
  30         string getDescription()         { return "removes columns from alignments based on a criteria defined by the user"; }\r
  31         \r
  32         int execute(); \r
  33         void help() { m->mothurOut(getHelpString()); }  \r
  34         \r
  35 private:\r
  36         struct linePair {\r
  37                 unsigned long long start;\r
  38                 unsigned long long end;\r
  39                 linePair(unsigned long long i, unsigned long long j) : start(i), end(j) {}\r
  40         };\r
  41 \r
  42         vector<linePair*> lines;\r
  43         vector<int> processIDS;\r
  44     map<int, vector<unsigned long long> > savedPositions;\r
  45 \r
  46         string vertical, filter, fasta, hard, outputDir, filterFileName;\r
  47         vector<string> fastafileNames;  \r
  48         int alignmentLength, processors;\r
  49         vector<int> bufferSizes;\r
  50         vector<string> outputNames;\r
  51 \r
  52         char trump;\r
  53         bool abort;\r
  54         float soft;\r
  55         int numSeqs;\r
  56         \r
  57         string createFilter();\r
  58         int filterSequences();\r
  59         int createProcessesCreateFilter(Filters&, string);\r
  60         int createProcessesRunFilter(string, string, string);\r
  61         int driverRunFilter(string, string, string, linePair*);\r
  62         int driverCreateFilter(Filters& F, string filename, linePair* line);\r
  63         #ifdef USE_MPI\r
  64         int driverMPIRun(int, int, MPI_File&, MPI_File&, vector<unsigned long long>&);\r
  65         int MPICreateFilter(int, int, Filters&, MPI_File&, vector<unsigned long long>&);        \r
  66         #endif\r
  67         \r
  68 };\r
  69 \r
  70 \r
  71 /**************************************************************************************************/\r
  72 //custom data structure for threads to use.\r
  73 // This is passed by void pointer so it can be any data type\r
  74 // that can be passed using a single void pointer (LPVOID).\r
  75 struct filterData {\r
  76         Filters F;\r
  77     int count, tid, alignmentLength;\r
  78     unsigned long long start, end;\r
  79     MothurOut* m;\r
  80     string filename, vertical, hard;\r
  81     char trump;\r
  82     float soft;\r
  83         \r
  84         filterData(){}\r
  85         filterData(string fn, MothurOut* mout, unsigned long long st, unsigned long long en, int aLength, char tr, string vert, float so, string ha, int t) {\r
  86         filename = fn;\r
  87                 m = mout;\r
  88                 start = st;\r
  89                 end = en;\r
  90         tid = t;\r
  91         trump = tr;\r
  92         alignmentLength = aLength;\r
  93         vertical = vert;\r
  94         soft = so;\r
  95         hard = ha;\r
  96                 count = 0;\r
  97         }\r
  98 };\r
  99 /**************************************************************************************************/\r
 100 //custom data structure for threads to use.\r
 101 // This is passed by void pointer so it can be any data type\r
 102 // that can be passed using a single void pointer (LPVOID).\r
 103 struct filterRunData {\r
 104     int count, tid, alignmentLength;\r
 105     unsigned long long start, end;\r
 106     MothurOut* m;\r
 107     string filename;\r
 108     string filter, outputFilename;\r
 109         \r
 110         filterRunData(){}\r
 111         filterRunData(string f, string fn, string ofn, MothurOut* mout, unsigned long long st, unsigned long long en, int aLength, int t) {\r
 112         filter = f;\r
 113         outputFilename = ofn;\r
 114         filename = fn;\r
 115                 m = mout;\r
 116                 start = st;\r
 117                 end = en;\r
 118         tid = t;\r
 119         alignmentLength = aLength;\r
 120                 count = 0;\r
 121         }\r
 122 };\r
 123 \r
 124 /**************************************************************************************************/\r
 125 #if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)\r
 126 #else\r
 127 static DWORD WINAPI MyCreateFilterThreadFunction(LPVOID lpParam){ \r
 128         filterData* pDataArray;\r
 129         pDataArray = (filterData*)lpParam;\r
 130         \r
 131         try {\r
 132 \r
 133                 if (pDataArray->soft != 0)                      {  pDataArray->F.setSoft(pDataArray->soft);             }\r
 134                 if (pDataArray->trump != '*')           {  pDataArray->F.setTrump(pDataArray->trump);   }\r
 135                 \r
 136                 pDataArray->F.setLength(pDataArray->alignmentLength);\r
 137                 \r
 138                 if(pDataArray->trump != '*' || pDataArray->m->isTrue(pDataArray->vertical) || pDataArray->soft != 0){\r
 139                         pDataArray->F.initialize();\r
 140                 }\r
 141                 \r
 142                 if(pDataArray->hard.compare("") != 0)   {       pDataArray->F.doHard(pDataArray->hard);         }\r
 143                 else                                            {       pDataArray->F.setFilter(string(pDataArray->alignmentLength, '1'));      }\r
 144         \r
 145                 ifstream in;\r
 146                 pDataArray->m->openInputFile(pDataArray->filename, in);\r
 147         \r
 148                 //print header if you are process 0\r
 149                 if ((pDataArray->start == 0) || (pDataArray->start == 1)) {\r
 150                         in.seekg(0);\r
 151                 }else { //this accounts for the difference in line endings. \r
 152                         in.seekg(pDataArray->start-1); pDataArray->m->gobble(in); \r
 153                 }\r
 154                 \r
 155                 pDataArray->count = pDataArray->end;\r
 156                 for(int i = 0; i < pDataArray->end; i++){ //end is the number of sequences to process\r
 157                         \r
 158                         if (pDataArray->m->control_pressed) { in.close(); pDataArray->count = 1; return 1; }\r
 159                         \r
 160                         Sequence current(in); pDataArray->m->gobble(in); \r
 161                         \r
 162                         if (current.getName() != "") {\r
 163                                 if (current.getAligned().length() != pDataArray->alignmentLength) { pDataArray->m->mothurOut("Sequences are not all the same length, please correct."); pDataArray->m->mothurOutEndLine(); pDataArray->m->control_pressed = true;  }\r
 164                 \r
 165                 if(pDataArray->trump != '*')                    {       pDataArray->F.doTrump(current);         }\r
 166                 if(pDataArray->m->isTrue(pDataArray->vertical) || pDataArray->soft != 0)        {       pDataArray->F.getFreqs(current);        }\r
 167                         }\r
 168             \r
 169             //report progress\r
 170                         if((i) % 100 == 0){     pDataArray->m->mothurOut(toString(i)); pDataArray->m->mothurOutEndLine();               }\r
 171                 }\r
 172                 \r
 173         if((pDataArray->count) % 100 != 0){     pDataArray->m->mothurOut(toString(pDataArray->count)); pDataArray->m->mothurOutEndLine();               }\r
 174         \r
 175                 in.close();\r
 176                 \r
 177                 return 0;\r
 178                 \r
 179         }\r
 180         catch(exception& e) {\r
 181                 pDataArray->m->errorOut(e, "FilterSeqsCommand", "MyCreateFilterThreadFunction");\r
 182                 exit(1);\r
 183         }\r
 184 } \r
 185 /**************************************************************************************************/\r
 186 static DWORD WINAPI MyRunFilterThreadFunction(LPVOID lpParam){ \r
 187         filterRunData* pDataArray;\r
 188         pDataArray = (filterRunData*)lpParam;\r
 189         \r
 190         try {\r
 191         \r
 192         ofstream out;\r
 193                 pDataArray->m->openOutputFile(pDataArray->outputFilename, out);\r
 194 \r
 195                 ifstream in;\r
 196                 pDataArray->m->openInputFile(pDataArray->filename, in);\r
 197         \r
 198                 //print header if you are process 0\r
 199                 if ((pDataArray->start == 0) || (pDataArray->start == 1)) {\r
 200                         in.seekg(0);\r
 201                 }else { //this accounts for the difference in line endings. \r
 202                         in.seekg(pDataArray->start-1); pDataArray->m->gobble(in); \r
 203                 }\r
 204                 \r
 205                 pDataArray->count = pDataArray->end;\r
 206                 for(int i = 0; i < pDataArray->end; i++){ //end is the number of sequences to process\r
 207                         \r
 208                         if (pDataArray->m->control_pressed) { in.close(); out.close(); pDataArray->count = 1; return 1; }\r
 209                         \r
 210                         Sequence seq(in); pDataArray->m->gobble(in);\r
 211             if (seq.getName() != "") {\r
 212                 string align = seq.getAligned();\r
 213                 string filterSeq = "";\r
 214                 \r
 215                 for(int j=0;j<pDataArray->alignmentLength;j++){\r
 216                     if(pDataArray->filter[j] == '1'){\r
 217                         filterSeq += align[j];\r
 218                     }\r
 219                 }\r
 220                 \r
 221                 out << '>' << seq.getName() << endl << filterSeq << endl;\r
 222             }\r
 223             \r
 224             //report progress\r
 225                         if((i) % 100 == 0){     pDataArray->m->mothurOut(toString(i)); pDataArray->m->mothurOutEndLine();               }\r
 226                 }\r
 227                 \r
 228         if((pDataArray->count) % 100 != 0){     pDataArray->m->mothurOut(toString(pDataArray->count)); pDataArray->m->mothurOutEndLine();               }\r
 229         \r
 230                 in.close();\r
 231         out.close();\r
 232                 \r
 233                 return 0;\r
 234                 \r
 235         }\r
 236         catch(exception& e) {\r
 237                 pDataArray->m->errorOut(e, "FilterSeqsCommand", "MyRunFilterThreadFunction");\r
 238                 exit(1);\r
 239         }\r
 240 } \r
 241 /**************************************************************************************************/\r
 242 #endif\r
 243 \r
 244 \r
 245 #endif\r