flowdata.cpp

   1 /*
   2  *  flowdata.cpp
   3  *  Mothur
   4  *
   5  *  Created by Pat Schloss on 12/22/10.
   6  *  Copyright 2010 Schloss Lab. All rights reserved.
   7  *
   8  */
   9
  10 #include "flowdata.h"
  11
  12 //**********************************************************************************************************************
  13
  14 FlowData::FlowData(){}
  15
  16 //**********************************************************************************************************************
  17
  18 FlowData::~FlowData(){  /*      do nothing      */      }
  19
  20 //**********************************************************************************************************************
  21
  22 FlowData::FlowData(int numFlows, float signal, float noise, int maxHomoP, string baseFlow) :
  23                         numFlows(numFlows), signalIntensity(signal), noiseIntensity(noise), maxHomoP(maxHomoP), baseFlow(baseFlow){
  24
  25         try {
  26                 m = MothurOut::getInstance();
  27
  28                 flowData.assign(numFlows, 0);
  29 //              baseFlow = "TACG";
  30                 seqName = "";
  31                 locationString = "";
  32         }
  33         catch(exception& e) {
  34                 m->errorOut(e, "FlowData", "FlowData");
  35                 exit(1);
  36         }
  37
  38 }
  39
  40 //**********************************************************************************************************************
  41
  42 bool FlowData::getNext(ifstream& flowFile){
  43
  44         try {
  45                 flowFile >> seqName >> endFlow;
  46                 //cout << "in Flowdata " + seqName << endl;
  47                 for(int i=0;i<numFlows;i++)     {       flowFile >> flowData[i];        }
  48                 //cout << "in Flowdata read " << seqName + " done" << endl;
  49                 updateEndFlow();
  50                 translateFlow();
  51
  52                 m->gobble(flowFile);
  53                 if(flowFile){   return 1;       }
  54                 else            {       return 0;       }
  55         }
  56         catch(exception& e) {
  57                 m->errorOut(e, "FlowData", "getNext");
  58                 exit(1);
  59         }
  60
  61 }
  62
  63 //**********************************************************************************************************************
  64
  65 void FlowData::updateEndFlow(){
  66         try{
  67
  68                 //int currLength = 0;
  69                 float maxIntensity = (float) maxHomoP + 0.49;
  70
  71                 int deadSpot = 0;
  72
  73                 while(deadSpot < endFlow){
  74                         int signal = 0;
  75                         int noise = 0;
  76
  77                         for(int i=0;i<4;i++){
  78                                 float intensity = flowData[i + deadSpot];
  79                                 if(intensity > signalIntensity){
  80                                         signal++;
  81
  82                                         if(intensity  < noiseIntensity || intensity > maxIntensity){
  83                                                 noise++;
  84                                         }
  85                                 }
  86                         }
  87
  88                         if(noise > 0 || signal == 0){
  89                                 break;
  90                         }
  91
  92                         deadSpot += 4;
  93                 }
  94                 endFlow = deadSpot;
  95
  96         }
  97         catch(exception& e) {
  98                 m->errorOut(e, "FlowData", "findDeadSpot");
  99                 exit(1);
 100         }
 101 }
 102
 103 //**********************************************************************************************************************
 104
 105 void FlowData::translateFlow(){
 106
 107         try{
 108                 sequence = "";
 109                 for(int i=0;i<endFlow;i++){
 110                         int intensity = (int)(flowData[i] + 0.5);
 111                         char base = baseFlow[i % 4];
 112
 113                         for(int j=0;j<intensity;j++){
 114                                 sequence += base;
 115                         }
 116                 }
 117
 118                 if(sequence.size() > 4){
 119                         sequence = sequence.substr(4);
 120                 }
 121                 else{
 122                         sequence = "NNNN";
 123                 }
 124         }
 125         catch(exception& e) {
 126                 m->errorOut(e, "FlowData", "translateFlow");
 127                 exit(1);
 128         }
 129 }
 130
 131 //**********************************************************************************************************************
 132
 133 void FlowData::capFlows(int mF){
 134
 135         try{
 136
 137                 maxFlows = mF;
 138                 if(endFlow > maxFlows){ endFlow = maxFlows;     }
 139
 140         }
 141         catch(exception& e) {
 142                 m->errorOut(e, "FlowData", "capFlows");
 143                 exit(1);
 144         }
 145 }
 146
 147 //**********************************************************************************************************************
 148
 149 bool FlowData::hasMinFlows(int minFlows){
 150
 151         try{
 152                 bool pastMin = 0;
 153                 if(endFlow >= minFlows){        pastMin = 1;    }
 154
 155                 return pastMin;
 156         }
 157         catch(exception& e) {
 158                 m->errorOut(e, "FlowData", "hasMinFlows");
 159                 exit(1);
 160         }
 161 }
 162
 163 //**********************************************************************************************************************
 164
 165 Sequence FlowData::getSequence(){
 166
 167         try{
 168                 return Sequence(seqName, sequence);
 169         }
 170         catch(exception& e) {
 171                 m->errorOut(e, "FlowData", "getSequence");
 172                 exit(1);
 173         }
 174 }
 175
 176 //**********************************************************************************************************************
 177
 178 void FlowData::printFlows(ofstream& outFlowFile){
 179         try{
 180 //      outFlowFile << '>' << seqName << locationString << " length=" << seqLength << " numflows=" << maxFlows << endl;
 181                 outFlowFile << seqName << ' ' << endFlow << ' ' << setprecision(2);
 182
 183                 for(int i=0;i<maxFlows;i++){
 184                         outFlowFile << flowData[i] << ' ';
 185                 }
 186                 outFlowFile << endl;
 187         }
 188         catch(exception& e) {
 189                 m->errorOut(e, "FlowData", "printFlows");
 190                 exit(1);
 191         }
 192 }
 193
 194 //**********************************************************************************************************************
 195
 196 void FlowData::printFlows(ofstream& outFlowFile, string scrapCode){
 197         try{
 198                 outFlowFile << seqName << '|' << scrapCode << ' ' << endFlow << ' ' << setprecision(2);
 199
 200                 for(int i=0;i<numFlows;i++){
 201                         outFlowFile << flowData[i] << ' ';
 202                 }
 203                 outFlowFile << endl;
 204         }
 205         catch(exception& e) {
 206                 m->errorOut(e, "FlowData", "printFlows");
 207                 exit(1);
 208         }
 209 }
 210
 211 //**********************************************************************************************************************
 212
 213 string FlowData::getName(){
 214
 215         try{
 216                 return seqName;
 217         }
 218         catch(exception& e) {
 219                 m->errorOut(e, "FlowData", "getName");
 220                 exit(1);
 221         }
 222 }
 223
 224 //**********************************************************************************************************************