DoubleTriggerNoiseAlgorithm.cpp

#include "DoubleTriggerNoiseAlgorithm.h"
#include "AnalysisAlgorithmMap.h"
#include "AnalysisService.h"
#include "SctData/DoubleTriggerNoiseTestResult.h"
#include "SctData/StandardDefects.h"
#include "SctData/RawScanResult.h"
#include "SctData/ConfigurationVariable.h"
#include "Sct/UnsupportedOperationError.h"
#include "SctData/OccupancyProjector.h"
#include <Sct/AbcdScans.h>
#include <TH1.h>
#include <TH2.h>

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

namespace SctAnalysis {
    
    DoubleTriggerNoiseAlgorithm::~DoubleTriggerNoiseAlgorithm() throw() {}

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

    bool DoubleTriggerNoiseAlgorithm::inMap = AnalysisAlgorithmMap::instance().setAlgorithm("DoubleTriggerNoiseTest", auto_ptr<AnalysisAlgorithm>(new DoubleTriggerNoiseAlgorithm()));

    //----------------------------------------------------------------------
    
    void DoubleTriggerNoiseAlgorithm::loadData() {
    loadAllRaws();
    }
    
    bool DoubleTriggerNoiseAlgorithm::canAnalyze() const {
    return hasAllRaws();
    }
    
    shared_ptr<SctData::TestResult> DoubleTriggerNoiseAlgorithm::createTestResult() const {
    return shared_ptr<TestResult>(new DoubleTriggerNoiseTestResult());
    }

    void DoubleTriggerNoiseAlgorithm::analyze() {
    shared_ptr<DoubleTriggerNoiseTestResult> result = dynamic_pointer_cast<DoubleTriggerNoiseTestResult>(getTestResult());
    const SctData::ConfigurationVariable& scanVariable = getRaw(0)->getHeader().getVariable();
    result->setScanVariable(scanVariable);
    const ModuleConfiguration config=getRaw(0)->getConfiguration();
    
    m_scanVariable = SctData::ConfigurationVariableIOHelper::getTypeRep(scanVariable);
    
    result->setPassed(true);

    for (unsigned ilink=0; ilink<nLinkModule; ++ilink){
      if (getRaw(0)->getScanData(ilink).GetMaximum()<1.) result->setProblem(true);
      std::ostringstream comment;
      comment << "Problem: no data in link " << ilink << std::endl;
      result->addComment(comment.str());
    }


    OccupancyProjector opr(*getRaw(0) );
    for (unsigned int ichip=0; ichip<nChipModule; ++ichip) {
      //const ChipConfiguration& chipconfig=config.getChipConfiguration(ichip);
      //DefectList& defects = result->getDefects();
      auto_ptr<TH1> occ = opr.getOccupancy("temp", ModuleElement::Chip(ichip)) ;
      float peak=0; // maximum occupancy over time bins
      float peakbin=0; // bin where the maximum occupancy occurs
      float peakerr=0; // the errorbar on the peak. 
      float av=0;   // average occupancy over time bins
      float peakratio=0; // ratio of peak to pedestal
      for (unsigned ibin=1; ibin<=occ->GetNbinsX(); ++ibin){
        const float value = occ->GetBinContent(ibin);
        if (value>peak) {
          peak = value;
          peakerr = occ->GetBinError(ibin);
          peakbin = occ->GetBinCenter(ibin);
        }
        av+=value;
      }
      av -= peak; //subtract the peak out of the sum of all
      // Find the average: using N-1, since one bin, namely the peak isn't part of the sum
      if (occ->GetNbinsX()>0) av/=((static_cast<float>(occ->GetNbinsX()))-1); 
      result->setPeakOccupancy(ichip, peak);
      result->setPeakOccupancyBin(ichip, peakbin);
      result->setPedestalOccupancy(ichip, av);
      if (av>0) {
        peakratio = peak/av;
      } else {
        peakratio = 0;
      }
      result->setPeakRatio(ichip, peakratio);
      // Set passed false if the peak is 5 sigma away from the average
      if (peak > 5E-4 || peak > (av+peakerr*5.)){
        result->setPassed(false);
        result->getDefects().addDefect(Defect(StandardDefects::DOUBTR_HI, ModuleElement::Chip(ichip)));
      }
    }
    }
} // end of namespace SctAnalysis

---