TxCurrentAlgorithm.cpp

#include "TxCurrentAlgorithm.h"
#include "AnalysisAlgorithmMap.h"
#include "SctData/TxCurrentTestResult.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 TxCurrentAlgorithm::inMap = AnalysisAlgorithmMap::instance().setAlgorithm("TxCurrentTest", auto_ptr<AnalysisAlgorithm>(new TxCurrentAlgorithm()));
    
    shared_ptr<AnalysisAlgorithm> TxCurrentAlgorithm::clone(shared_ptr<const TestData> testData, const string& moduleName) const throw() {
    return shared_ptr<AnalysisAlgorithm>(new TxCurrentAlgorithm(testData, moduleName, *this));
    }

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

    
    bool TxCurrentAlgorithm::canAnalyze() const{
    return hasAllRaws();
    }
    
    shared_ptr<TestResult> TxCurrentAlgorithm::createTestResult() const {
    return shared_ptr<TxCurrentTestResult> (new TxCurrentTestResult());
    }
       
  struct Wadge {
    TxCurrentAlgorithm::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 TxCurrentAlgorithm::Category & cat, const unsigned int index) {
      category = cat;
      initialThreshIndex = index;
      width=1;
    };
    bool is(const TxCurrentAlgorithm::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);
    };
  };
    
    void TxCurrentAlgorithm::analyze() {
      TxCurrentTestResult & result =  *dynamic_pointer_cast<TxCurrentTestResult> ( 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;

        Wadges blackAndWhiteWadges;
        {
          Wadge currentWadge;
          
          for (unsigned int threshIndex = 0;
               threshIndex < ny;
               ++threshIndex) {
            const unsigned int nTriggers = points.getNEvents(threshIndex);
            const double txCurrent = points.getPoint(threshIndex);
            
            TxCurrentAlgorithm::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 && binContent != nTriggers) {
                category = coloured;
                break;
              };
              
              if (binContent == 0) {
                sawZero = true;
                continue;
              } else if (binContent == nTriggers) {
                sawSaturation = true;
                continue;
              };
            };
            
            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 ") + TxCurrentAlgorithm::categoryToString(category);
                
                std::ostringstream os;
                os << "Tx current " << txCurrent << " lineType " << lineType << " ntriggers " << nTriggers;
                std::string message = os.str();
                SctNames::Mrs()<< "TXCURRENTBASEDONCON" << 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 !

                // insert the wadge if it is blackAndWhite
                if (currentWadge.is(blackAndWhite)) {
                  blackAndWhiteWadges.insert(currentWadge);
                };

                // reset the current wadge to match the new category
                currentWadge.reset(category, threshIndex);
              };
            };
            
          };
          if (currentWadge.is(blackAndWhite)) {
            blackAndWhiteWadges.insert(currentWadge);
          };
        };
        // Now the blackAndWhiteWadges are fully set up!
        
        {
          const bool debug=true;
          if (debug) {
            for (Wadges::const_iterator it = blackAndWhiteWadges.begin();
                 it!=blackAndWhiteWadges.end();
                 ++it) {
              const Wadge & wadge = *it;              
              std::ostringstream os;
              os << TxCurrentAlgorithm::categoryToString(wadge.category) << " wadge of width " << wadge.width << " from " << wadge.from() << " to " << wadge.to();
              const std::string message = os.str();
              SctNames::Mrs()<< "TXCURRENTBASEDONCON" << MRS_INFORMATION<< MRS_TEXT(message.c_str())<< ENDM;
            };
          };
        };

        {          
          const bool debug=true;
          if (debug) {
            if (blackAndWhiteWadges.empty()) {
              SctNames::Mrs()<< "TXCURRENTBASEDONCON"<< 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 " << TxCurrentAlgorithm::categoryToString(largestWadge.category) << " and had width " << largestWadge.width << " from " << largestWadge.from() << " to " << largestWadge.to();
              const std::string message = os.str();
              SctNames::Mrs()<< "TXCURRENTBASEDONCON" << MRS_INFORMATION<< MRS_TEXT(message.c_str())<< ENDM;
            };
          };
        };

        {
          
          bool pass=false;
          bool problem=false;
          
          // time to record the result of the test!
          TxCurrentTestResult::StreamResult & sr = result.getStreamResult(ilink);
          if (blackAndWhiteWadges.empty()) {
            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 = *(blackAndWhiteWadges.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 bestThresh = (fromThresh+toThresh)/2;
            sr.setMinErrorFreeTxCurrent(fromThresh);
            sr.setMaxErrorFreeTxCurrent(  toThresh);
            sr.        setBestTxCurrent(bestThresh);
          };
          
          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 << "TxCurrentAlgorithm: unable to get scan at index " << index <<ends;
        throw IllegalStateError(os.str(), __FILE__, __LINE__);
        }
        
        if (debug) cout << "TxCurrentAlgorithm, scan #" << index << endl;

        for (unsigned ichip=0; ichip<nChipModule; ++ichip){
        TxCurrentTestResult::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){
        TxCurrentTestResult::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 << "TxCurrentAlgorithm done" << endl;
      */
    }
} // end of namespace SctAnalysis

---