PipelineAlgorithm.cpp

#include "PipelineAlgorithm.h"
#include "AnalysisAlgorithmMap.h"
#include "SctData/PipelineTestResult.h"
#include "SctData/StandardDefects.h"
#include "SctData/OccupancyProjector.h"
#include <TH1.h>
#include <TH2.h>

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

namespace SctAnalysis {
    
    bool PipelineAlgorithm::inMap = AnalysisAlgorithmMap::instance().setAlgorithm("PipelineTest", auto_ptr<AnalysisAlgorithm>(new PipelineAlgorithm()));
    
    shared_ptr<AnalysisAlgorithm> PipelineAlgorithm::clone(shared_ptr<const TestData> testData, const string& moduleName) const throw() {
    return shared_ptr<AnalysisAlgorithm>(new PipelineAlgorithm(testData, moduleName, *this));
    }

    shared_ptr<TestResult> PipelineAlgorithm::createTestResult() const {
    return shared_ptr<TestResult>(new PipelineTestResult());
    }
    
    void PipelineAlgorithm::loadData() {
    loadAllRaws();
    }
    
    bool PipelineAlgorithm::canAnalyze() const {
    return PipelineAlgorithm::hasAllRaws();
    }
    
    void PipelineAlgorithm::analyze() {
    shared_ptr<PipelineTestResult> result = dynamic_pointer_cast<PipelineTestResult>(getTestResult());
    result->setScanVariable(getRaw(0)->getHeader().getVariable());  
    shared_ptr<const RawScanResult> rawa=getRaw(0);
    shared_ptr<const RawScanResult> rawb=getRaw(1);
    
    bool pass = true;

    // quick check:
    if (rawa->getScanData(0).GetNbinsY() != rawb->getScanData(0).GetNbinsY() ||
        rawa->getScanData(1).GetNbinsY() != rawb->getScanData(1).GetNbinsY() ){
        ostringstream os;
        os << "PipelineAlgorithm different y-extent of scans " << rawa->getHeader().getScanNumber()
           << " and " << rawb->getHeader().getScanNumber() <<ends;
        throw IllegalStateError(os.str(), __FILE__, __LINE__);
    }

    DefectList& defects=result->getDefects();

    for (unsigned ichip=0; ichip<nChipModule; ++ichip){

        bool stuck[nChannelChip], dead[nChannelChip];

        // loop to find stuck and dead channels and report stuck and dead cells
        for (unsigned ichInChip=0; ichInChip<nChannelChip; ++ichInChip){
        // initialise
        stuck[ichInChip]=false;
        dead[ichInChip]=false;

        // find the real channel number
        unsigned ichannel=ichip*nChannelChip+ichInChip;

        TH2& hista = rawa->getScanData(ichip/nChipLink);
        TH2& histb = rawb->getScanData(ichip/nChipLink);
        unsigned stuckcells=0, deadcells=0, cellmask=0;

        unsigned nPipeline=hista.GetNbinsY();
        
        // find number of stuck and dead cells for this channel
        for ( unsigned delay=0; delay < nPipeline; ++delay){
            double vala = hista.GetBinContent(ichannel%nChannelLink+1, delay+1);
            double valb = histb.GetBinContent(ichannel%nChannelLink+1, delay+1);
            if(vala<0.95) deadcells += 1<<delay;   // cell is dead val=0
            if(valb>0.05) stuckcells += 1<<delay;  // cell is stuck val >0
            cellmask += 1<<delay;
        }

        if (stuckcells==cellmask){                 // channel stuck
          defects.addDefect(Defect(StandardDefects::STUCKON, 
                       ModuleElement::Channel(ichannel)));
          
        } else if (stuckcells!=0) {                // cell stuck
            defects.addDefect(Defect(StandardDefects::STUCK_CELL, 
                         ModuleElement::Channel(ichannel),
                         boost::optional<double>(stuckcells)));
            pass = false;
        }
        
        if (deadcells==cellmask){                 // channel dead
          defects.addDefect(Defect(StandardDefects::DEAD,
                       ModuleElement::Channel(ichannel)));

            dead[ichInChip]=true;
        } else  if (deadcells!=0) {               // cell dead
            defects.addDefect(Defect(StandardDefects::DEAD_CELL, 
                         ModuleElement::Channel(ichannel),
                         boost::optional<double>(deadcells)));
            pass = false;
        }
        } // end of first loop over channels in chip

    } // end of loop over chips
    
    // Fails if there are any defects...
    result->setPassed( defects.defectSeverityAffectingElement(ModuleElement::Module())==NONE );
    }
} // end of namespace SctAnalysis

---