RxThresholdBasedOnConfigRegisterAlgorithm.cpp

#include "RxThresholdBasedOnConfigRegisterAlgorithm.h"
#include "AnalysisAlgorithmMap.h"
#include "SctData/RxThresholdBasedOnConfigRegisterTestResult.h"
//#include "SctData/StandardDefects.h"
//#include "SctData/FitObject.h"
#include "SctData/RawScanResult.h"
#include <cfloat>
#include "TH2.h"
#include "Sct/SctNames.h"

// gcc296 needs a declaration of fabs
#include <cmath>
#include <set>

using namespace std;
using namespace boost;
using namespace SctData;
using namespace Sct;

namespace SctAnalysis {
    
    bool RxThresholdBasedOnConfigRegisterAlgorithm::inMap = AnalysisAlgorithmMap::instance().setAlgorithm("RxThresholdBasedOnConfigRegisterTest", auto_ptr<AnalysisAlgorithm>(new RxThresholdBasedOnConfigRegisterAlgorithm()));

    

 RxThresholdBasedOnConfigRegisterAlgorithm::RxThresholdBasedOnConfigRegisterAlgorithm(shared_ptr<const TestData> testData, const string& moduleName, const AnalysisAlgorithm& alg) throw() : AnalysisAlgorithm(testData, moduleName, alg), m_fraction(0.7) {}

    shared_ptr<AnalysisAlgorithm> RxThresholdBasedOnConfigRegisterAlgorithm::clone(shared_ptr<const TestData> testData, const string& moduleName) const throw() {
    return shared_ptr<AnalysisAlgorithm>(new RxThresholdBasedOnConfigRegisterAlgorithm(testData, moduleName, *this));
    }

    void RxThresholdBasedOnConfigRegisterAlgorithm::loadData() {
    loadAllRaws();
    }

    
    bool RxThresholdBasedOnConfigRegisterAlgorithm::canAnalyze() const{
    return hasAllRaws();
    }
    
    shared_ptr<TestResult> RxThresholdBasedOnConfigRegisterAlgorithm::createTestResult() const {
    return shared_ptr<RxThresholdBasedOnConfigRegisterTestResult> (new RxThresholdBasedOnConfigRegisterTestResult());
    }
       
  struct Wadge {
    RxThresholdBasedOnConfigRegisterAlgorithm::Category category;
    unsigned int initialThreshIndex;
    unsigned int width;
    unsigned int from() const { return initialThreshIndex; };
    unsigned int to() const { return initialThreshIndex+width-1; };
    void reset(const RxThresholdBasedOnConfigRegisterAlgorithm::Category & cat, const unsigned int index) {
      category = cat;
      initialThreshIndex = index;
      width=1;
    };
    bool is(const RxThresholdBasedOnConfigRegisterAlgorithm::Category & cat) const { return cat == category; }; 
    void increment() {
      ++width;
    };
    void makeEmpty() {
      width=0;
    };
    bool isEmpty() const {
      return width==0;
    };
    Wadge() {
      makeEmpty();
    };
    bool operator<(const Wadge & other) const {
      return (this->width)<(other.width);
    };
  };
    
    bool RxThresholdBasedOnConfigRegisterAlgorithm::
    canRead(const std::vector<char> & wanted, // what to look for
        const std::vector<bool> & have, // what to look in
        std::vector<bool>::const_iterator & externalPos, // where to start looking -- will be advanced on a successful read (i.e. when true is returned) otherwise left unchanged.
        const bool showDebug) {
      if (wanted.empty()) {
    if (showDebug) {
      std::cout << " MATCH\n";
    };
    return true;
      };
      // if we get here, "wanted" contains some stuff.

      std::vector<bool>::const_iterator localPos = externalPos;

      for(std::vector<char>::const_iterator wantedPos = wanted.begin();
      wantedPos != wanted.end();
      (++wantedPos, ++localPos)) {
    
    if (localPos == have.end()) {
      if (showDebug) {
        std::cout << "[EOD]\n";
      };
      return false;
    };
    
    const char wantedChar = *wantedPos;

    if (wantedChar == 2) {
      // wildcard!  ok, keep looking
      if (showDebug) {
        std::cout << ( (*localPos) /*bit*/ ? "D" : "d" ); 
      };
      continue;
    };

    const bool bit = *localPos;

    if (wantedChar == 0 && !bit ||
        wantedChar == 1 &&  bit) {
      // desired bits match, ok, keep looking
      if (showDebug) {
        std::cout << bit;
      };
      continue;
    } else {
      // bits fail to match
      if (showDebug) {
        std::cout << "[W:" << (wantedChar ? "1" : "0") << ",G:" << bit << "]\n";
      };
      return false;
    };
      };
      // If we got this far, we actually found a match!
      // Update external pos
      externalPos = localPos;
      if (showDebug) {
    std::cout << " MATCH\n";
      };
      return true;
    };
      

    void RxThresholdBasedOnConfigRegisterAlgorithm::analyze() {
      RxThresholdBasedOnConfigRegisterTestResult & result =  *dynamic_pointer_cast<RxThresholdBasedOnConfigRegisterTestResult> ( getTestResult() );
      
      const RawScanResult& raw = *getRaw(0);
      result.setScanVariable(raw.getHeader().getVariable());    

      const SctData::ScanPoints& points=raw.getPoints();
      const unsigned int numberOfScanPoints = points.getNPoints();
 

      for (short unsigned int ilink=0; ilink<nLinkModule; ++ilink ) {
    const TH2& data = raw.getScanData(ilink);
        const unsigned nx = data.GetNbinsX();
        const unsigned ny = data.GetNbinsY();
        if(!(ny==numberOfScanPoints)) {
          throw IllegalStateError("This should not be!",__FILE__,__LINE__);
        };
        if(ny<=0) {
          throw IllegalStateError("This should not be!",__FILE__,__LINE__);
        };
        
        
       
        typedef unsigned int Width;
        typedef std::multiset<Wadge> Wadges;

    // A long rise time of the RxThreshold seems to be a good indicator of VCSELS that might die, according to TW. 
    // So lets try to find them.  BD
    int riseTime = 0;
    
        Wadges blackAndWhiteWadges;
        Wadges meaningfulDataWadges;
        {
          Wadge currentWadge;

      // Start by finding where the first bin which is non-zero for each threshold.  BD
      int unsigned beginNonZero[ny];
      int unsigned maxNonZeroThreshIndex = 0;
      
          for (unsigned int threshIndex = 0; threshIndex < ny; ++threshIndex) {
        std::vector<bool> bwCopy(nx);

            const unsigned int nTriggers = points.getNEvents(threshIndex);
            const double rxThresh = points.getPoint(threshIndex);
            
        beginNonZero[threshIndex] = 0;

            RxThresholdBasedOnConfigRegisterAlgorithm::Category category = undecided;
            bool sawZero = false;
            bool sawSaturation = false;
            for (unsigned int x=0; x<nx && category==undecided; ++x) {
              const Stat_t binContent_t = data.GetBinContent(x+1, threshIndex+1);
              const unsigned int binContent = static_cast<unsigned int>(binContent_t);
              if (static_cast<Stat_t>(binContent) != binContent_t) {
                throw IllegalStateError("This cannot be!",__FILE__,__LINE__);            
              }; 
              
              if (binContent != 0 ) {
        if (beginNonZero[threshIndex] == 0) {
          beginNonZero[threshIndex] = x;
          
        }
          }

              if (binContent != 0 && binContent != nTriggers) {
                category = coloured;
                break;
              };
              
              if (binContent == 0) {
                sawZero = true;
        bwCopy[x] = false;
                continue;
              } else if (binContent == nTriggers) {
                sawSaturation = true;
        bwCopy[x] = true;
                continue;
              };
            }; // end of loop over x values

        if (beginNonZero[threshIndex] != 0) {
          maxNonZeroThreshIndex = threshIndex;
        }

            if (category==undecided) {
              if (sawZero && !sawSaturation) {
                category = white;
              } else if (sawSaturation && !sawZero) {
                category = black;
              } else if (sawSaturation &&  sawZero) {
                category = blackAndWhite;
              } else {
                throw IllegalStateError("This cannot be!",__FILE__,__LINE__);
              };
            };
            
            if (category==undecided) {
              throw IllegalStateError("This cannot be!",__FILE__,__LINE__);
            };
      
            // so now we know what this line was like!
            {
              const bool debug=false;
              if (debug) {
                const std::string lineType = 
                  std::string("lineType was ") + RxThresholdBasedOnConfigRegisterAlgorithm::categoryToString(category);
                
                std::ostringstream os;
                os << "Rx thresh " << rxThresh << " lineType " << lineType << " ntriggers " << nTriggers;
                std::string message = os.str();
                SctNames::Mrs()<< "RXTHRESHBASEDONCON" << MRS_INFORMATION<< MRS_TEXT(message.c_str())<< ENDM;
              };
            };

        // If black and white, check to see the output looks like data from Send_ID mode.
        // If the data DOES look like Send_ID data, we can upgrade the
        // category to "meaningfulDataPresent"
        if (category==blackAndWhite) {
          
          static const char startPacketArr[] = {
        1,1,1,0,1,       // preamble
        0,               // spacer
        2,2,2,2,         // L1ID
        2,2,2,2,2,2,2,2, // BCID
        1                // spacer
          };
          static const char confDataPacketArr[] = {
        0,0,0,           // preamble
        2,2,2,2,         // chip id
        1,1,1,           // nonsense
        2,2,2,2,2,2,2,2, // config reg bits
            1,               // spacer
        2,2,2,2,2,2,2,2, // config reg bits
        1                // spacer
          };
          static const char trailerPacketArr[] = {
        1,0,0,0,
        0,0,0,0,
        0,0,0,0,
        0,0,0,0
          };

          static const std::vector<char> startPacket(startPacketArr, startPacketArr+sizeof(startPacketArr)); 
          static const std::vector<char> confDataPacket(confDataPacketArr, confDataPacketArr+sizeof(confDataPacketArr)); 
          static const std::vector<char> trailerPacket(trailerPacketArr, trailerPacketArr+sizeof(trailerPacketArr)); 
          
          const bool showDebug = false;

          // now try to identify valid start range ...
          std::vector<bool>::const_iterator startPosIt = bwCopy.begin();
          bool foundValidData=false;
          unsigned int validStartPosWas=0; // does not need to be initialised, but we give it a value of 0 to keep the compiler warnings at bay
          for (unsigned int startPos=0;
           startPos<50 && startPosIt != bwCopy.end() && !foundValidData; 
           (++startPos, ++startPosIt) ) {
        
        std::vector<bool>::const_iterator currentPos = startPosIt; 

        // look for start packet
        if (showDebug) {
          std::cout << "Looking for start packet at " << startPos << " on thr " << rxThresh << " ...\n";
        } 
        if (!(this->canRead(startPacket,
                    bwCopy,
                    currentPos,
                    showDebug))) {
          // it wasn't there
          continue;
        };
        // we found the start packet!

        // count payload units
        if (showDebug) {
          std::cout << "Looking for payload ...\n";
        } 
        unsigned int payload=0;
        while (this->canRead(confDataPacket,
                     bwCopy,
                     currentPos,
                     showDebug)) {
          ++payload;
        };
          
        if (payload==0) {
          // there was no payload!
          continue;
        };

        // look for trailer
        if (showDebug) {
          std::cout << "Looking for trailer ...\n";
        } 
        if (!(this->canRead(trailerPacket,
                    bwCopy,
                    currentPos,
                    showDebug))) {
          // there was no trailer
          continue;
        };
        // we found the trailer!
        
        foundValidData=true;
        validStartPosWas=startPos;
        
          }; // end of loop over startPos positions

          //std::cout << "LESTER DEBUG ThreshIndex " << threshIndex 
          //    << " Found valid data was " << foundValidData 
          //    << " at " << validStartPosWas << std::endl;

          if (foundValidData) {
        // upgrade the category!
        category = meaningfulData;
          };

        }; // end of detailed conf-reg-specific analysis.


        // BD -- check the first NonZero points
            {
              const bool debug=false;
              if (debug) {
                const std::string lineType = 
                  std::string("lineType was ") + RxThresholdBasedOnConfigRegisterAlgorithm::categoryToString(category);
                
                std::ostringstream os;
                os << "Rx thresh " << rxThresh << " beginNonZero " << beginNonZero[threshIndex] ;
                std::string message = os.str();
                SctNames::Mrs()<< "RXTHRESHBASEDONCON" << MRS_INFORMATION<< MRS_TEXT(message.c_str())<< ENDM;
              };
            };

            
            if (currentWadge.isEmpty()) {
              currentWadge.reset(category, threshIndex);
            } else {
              // currentWadge is NOT empty !
              if (currentWadge.is(category)) {
                currentWadge.increment();
              } else {
                // the category just CHANGED !

                // Remember blackAndWhite wadges (meaningfulData is also black and white) 
                if (currentWadge.is(blackAndWhite) || currentWadge.is(meaningfulData)) {
                  blackAndWhiteWadges.insert(currentWadge); // CGL TODO: remove all references to the object "blackAndWhiteWadges".  Obsoleted by meaningfulDataWadges.  Unless still used by BD.  
                };

        // Remember the wadge if it is meaningfulData 
        if (currentWadge.is(meaningfulData)) {
                  meaningfulDataWadges.insert(currentWadge);
                };

                // reset the current wadge to match the new category
                currentWadge.reset(category, threshIndex);
              };
            };
      
        // here end of for-loop over thresholds 
          };

      // Find if the RxThreshold has a slope feature.  BD
      int unsigned beginSlope = ((int)(maxNonZeroThreshIndex*0.25/5))*5;
      int unsigned endSlope = ((int)(maxNonZeroThreshIndex*0.75/5))*5;
      riseTime = beginNonZero[endSlope] - beginNonZero[beginSlope];

      {
        const bool debug=false;
        if (debug) {
          std::ostringstream os;
          os << "beginSlope: " << beginSlope << " endSlope: " << endSlope << " riseTime: " << riseTime;
          std::string message = os.str();
          SctNames::Mrs()<< "RXTHRESHBASEDONCON" << MRS_INFORMATION<< MRS_TEXT(message.c_str())<< ENDM;
        }
      }

      
      // Remember blackAndWhite wadges (meaningfulData is also black and white)
          if (currentWadge.is(blackAndWhite) || currentWadge.is(meaningfulData)) {
            blackAndWhiteWadges.insert(currentWadge); // CGL TODO: remove all references to the object "blackAndWhiteWadges".  Obsoleted by meaningfulDataWadges.  Unless still used by BD.  
          };

      // Remember the wadge if it is meaningfulData 
      if (currentWadge.is(meaningfulData)) {
        meaningfulDataWadges.insert(currentWadge);
      };

        };
        // Now the collections of Wadges are fully set up!
        
        {
          const bool debug=false;
          if (debug) {
            for (Wadges::const_iterator it = blackAndWhiteWadges.begin();
                 it!=blackAndWhiteWadges.end();
                 ++it) {
              const Wadge & wadge = *it;              
              std::ostringstream os;
              os << RxThresholdBasedOnConfigRegisterAlgorithm::categoryToString(wadge.category) << " wadge of width " << wadge.width << " from " << wadge.from() << " to " << wadge.to();
              const std::string message = os.str();
          SctNames::Mrs()<< "RXTHRESHBASEDONCON" << MRS_INFORMATION<< MRS_TEXT(message.c_str())<< ENDM;
            };
          };
        };

        {          
          const bool debug=false;
          if (debug) {
            if (blackAndWhiteWadges.empty()) {
              SctNames::Mrs()<< "RXTHRESHBASEDONCON"<< MRS_INFORMATION<< MRS_TEXT("There were no blackAndWhite wadges for this stream!") << ENDM;
            } else {
              const Wadge & largestWadge = *(blackAndWhiteWadges.rbegin());              
              std::ostringstream os;
              os << "The largest wadge was " << RxThresholdBasedOnConfigRegisterAlgorithm::categoryToString(largestWadge.category) << " and had width " << largestWadge.width << " from " << largestWadge.from() << " to " << largestWadge.to();
              const std::string message = os.str();
              SctNames::Mrs()<< "RXTHRESHBASEDONCON" << MRS_INFORMATION<< MRS_TEXT(message.c_str())<< ENDM;
            };
          };
        };

        {
          const bool debug=false;
          if (debug) {
            for (Wadges::const_iterator it = meaningfulDataWadges.begin();
                 it!=meaningfulDataWadges.end();
                 ++it) {
              const Wadge & wadge = *it;              
              std::ostringstream os;
              os << RxThresholdBasedOnConfigRegisterAlgorithm::categoryToString(wadge.category) << " wadge of width " << wadge.width << " from " << wadge.from() << " to " << wadge.to();
              const std::string message = os.str();
          SctNames::Mrs()<< "RXTHRESHBASEDONCON" << MRS_INFORMATION<< MRS_TEXT(message.c_str())<< ENDM;
            };
          };
        };

        {          
          const bool debug=false;
          if (debug) {
            if (meaningfulDataWadges.empty()) {
              SctNames::Mrs()<< "RXTHRESHBASEDONCON"<< MRS_INFORMATION<< MRS_TEXT("There were no meaningfulData wadges for this stream!") << ENDM;
            } else {
              const Wadge & largestWadge = *(meaningfulDataWadges.rbegin());              
              std::ostringstream os;
              os << "The largest wadge was " << RxThresholdBasedOnConfigRegisterAlgorithm::categoryToString(largestWadge.category) << " and had width " << largestWadge.width << " from " << largestWadge.from() << " to " << largestWadge.to();
              const std::string message = os.str();
              SctNames::Mrs()<< "RXTHRESHBASEDONCON" << MRS_INFORMATION<< MRS_TEXT(message.c_str())<< ENDM;
            };
          };
        };

        {
          
          bool pass=false;
          bool problem=false;
          
          // time to record the result of the test!
          RxThresholdBasedOnConfigRegisterTestResult::StreamResult & sr = result.getStreamResult(ilink);
          if (meaningfulDataWadges.empty() /*used to be blackAndWhiteWadges*/ ) {
            problem=true;
            sr.setInvalid(); // this should be unnecessary as it already should be constructed as invalid until set otherwise ...
          } else {
            pass=true;
            const Wadge & largestWadge = *(meaningfulDataWadges.rbegin());
            const unsigned int fromIndex = largestWadge.from();
            const unsigned int toIndex   = largestWadge.  to();
            const int fromThresh = static_cast<int>(points.getPoint( fromIndex ));
            const int   toThresh = static_cast<int>(points.getPoint(   toIndex ));
            const int low = min(fromThresh, toThresh);
            const int high = max(fromThresh, toThresh);
            float fraction = getFraction();
        const int bestThresh = (int) ( ((1.-fraction)*(float)low)
                                   +((fraction)*(float)high) );

            sr.setMinErrorFreeRxThresh(low);
            sr.setMaxErrorFreeRxThresh(high);
            sr.setBestRxThresh(bestThresh);

        sr.setRiseTime(riseTime);

        // BD
        // std::ostringstream os;
        // os << "ilink: " <<  ilink <<" Low: " << low << " High: " << high << " Best: " << bestThresh;
        // const std::string message = os.str();
        // SctNames::Mrs()<< "RXTHRESHBASEDONCON" << MRS_INFORMATION<< MRS_TEXT(message.c_str())<< ENDM;

          };
          
          result.setPassed(pass);
          result.setProblem(problem);

        };
        //HERE LESTER
       
      };
      
     /* 

    float min_time[nChipModule];
    float max_time[nChipModule];
    for (unsigned ichip=0; ichip<nChipModule; ++ichip){
        min_time[ichip]=FLT_MAX;  // large positive number
        max_time[ichip]=-FLT_MAX; // large negative number
    }

    for (unsigned index=0; index<result->getNScans() ; ++index){
        shared_ptr<const FitScanResult> fit=getFit(index);

        if (!fit.get()) {
        ostringstream os;
        os << "RxThresholdBasedOnConfigRegisterAlgorithm: unable to get scan at index " << index <<ends;
        throw IllegalStateError(os.str(), __FILE__, __LINE__);
        }
        
        if (debug) cout << "RxThresholdBasedOnConfigRegisterAlgorithm, scan #" << index << endl;

        for (unsigned ichip=0; ichip<nChipModule; ++ichip){
        RxThresholdBasedOnConfigRegisterTestResult::ChipTWResult& cr = result->getChipResult(ichip);
        FitObject& fobj =fit->getChipFit(ichip);
        
        // on last point calculate calibration factor.
        if (debug) cout << index << "," 
                << result->getNScans()-1 << endl;
        if (index==result->getNScans()-1){
            cr.calibration = // mid-rise - mid-fall
            fabs(fobj.getParameter(1) - fobj.getParameter(3));
            if (debug) {
            cout << "Calibration for chip "
                 << ichip << " = " << cr.calibration<< endl;
            }
            
        }
        if (fobj.getParameter(3) < min_time[ichip]){
            min_time[ichip]=fobj.getParameter(3);
        }
        if (fobj.getParameter(3) > max_time[ichip]){
            max_time[ichip]=fobj.getParameter(3);
        }
        }
    }
    
    bool pass = true;

    for (unsigned ichip=0; ichip<nChipModule; ++ichip){
        RxThresholdBasedOnConfigRegisterTestResult::ChipTWResult& cr = result->getChipResult(ichip);
        cr.timewalk=max_time[ichip]-min_time[ichip];
        if (debug) {
        cout << "Time-walk for chip " << ichip
             << " = " <<  cr.timewalk << endl;
        }
        if (cr.timewalk<StandardDefects::TW_LO.getParameter()){
        result->getDefects().addDefect(Defect(StandardDefects::TW_LO, ModuleElement::Chip(ichip)));
        pass = false;
        }
        if (cr.timewalk>StandardDefects::TW_HI.getParameter()){
        result->getDefects().addDefect(Defect(StandardDefects::TW_HI, ModuleElement::Chip(ichip)));
        pass = false;
        }
    }

    result->setPassed(pass);
    if (debug) cout << "RxThresholdBasedOnConfigRegisterAlgorithm done" << endl;
      */
    }
} // end of namespace SctAnalysis

---