CastorChannelQualityMonitor.cc

Go to the documentation of this file.

#include "DQM/CastorMonitor/interface/CastorChannelQualityMonitor.h"
#include "DQMServices/Core/interface/DQMStore.h"
#include "DQMServices/Core/interface/MonitorElement.h"

//***************************************************//
//********** CastorChannelQualityMonitor *******************//
//********** Author: Dmytro Volyanskyy   ************//
//********** Date  : 04.03.2010 (first version) ******// 
//***************************************************//

//==================================================================//
//======================= Constructor ==============================//
//==================================================================//
CastorChannelQualityMonitor::CastorChannelQualityMonitor(){
 ievt_=0;
 counter1=0;
 counter2=0;
}

//==================================================================//
//======================= Destructor ==============================//
//==================================================================//

CastorChannelQualityMonitor::~CastorChannelQualityMonitor(){
}


void CastorChannelQualityMonitor::reset(){
}


//==========================================================//
//========================= setup ==========================//
//==========================================================//

void CastorChannelQualityMonitor::setup(const edm::ParameterSet& ps, DQMStore* dbe){

  CastorBaseMonitor::setup(ps,dbe);
   averageEnergyMethod_ = ps.getUntrackedParameter<bool>("averageEnergyMethod", true); 
   offline_             = ps.getUntrackedParameter<bool>("OfflineMode", false); 
   nThreshold_          = ps.getUntrackedParameter<double>("nThreshold", 0);
   dThreshold_          = ps.getUntrackedParameter<double>("dThreshold", 0);

  // baseFolder_ = rootFolder_+"CastorChannelQualityMonitor";

  if(fVerbosity>0) std::cout << "CastorChannelQualityMonitor::setup (start)" << std::endl;

  for (int row=0; row<14; row++) {
    for (int col=0; col<16; col++){
        aboveNoisyThreshold[row][col] = 0;
        belowDThreshold[row][col]     = 0;
        energyArray[row][col]         = 0;
        aboveThr[row][col]         = 0;
    }
  }

  ievt_=0; counter1=0; counter2=0;  wcounter1=0.; wcounter2=0.; 
  fraction=0.; 
  status = -99; numOK = 0; 
  iRecHit=false;
  averageEnergy=0.;

  if(fVerbosity>0) std::cout << "CastorChannelQualityMonitor::setup (end)" << std::endl;

  return;
}


//=================================================================//
//========================== beginRun =============================//
//================================================================//
void CastorChannelQualityMonitor::beginRun(const edm::Run& iRun, const edm::EventSetup& iSetup)
  {
  if(fVerbosity>0) std::cout << "CastorChannelQualityMonitor::beginRun (start)" << std::endl;
 
   if ( m_dbe !=NULL )
    {    
        m_dbe->setCurrentFolder(rootFolder_+"CastorChannelQuality");
        reportSummary    = m_dbe->bookFloat("RecHit Energy based reportSummary");
        reportSummaryMap = m_dbe->book2D("RecHitEnergyBasedSummaryMap","RecHitEnergyBasedSummaryMap",14,0.0,14.0,16,0.0,16.0);
        if(offline_)
        {
            h_reportSummaryMap =reportSummaryMap->getTH2F();
            h_reportSummaryMap->SetOption("textcolz");
            h_reportSummaryMap->GetXaxis()->SetTitle("module");
            h_reportSummaryMap->GetYaxis()->SetTitle("sector");
            }
    
        overallStatus = m_dbe->bookFloat("RecHit Energy based fraction of good channels");

    fraction=0.; 
    overallStatus->Fill(fraction); reportSummary->Fill(fraction); 

    }
  else
    {
    if(fVerbosity>0) std::cout << "CastorChannelQualityMonitor::beginRun - NO DQMStore service" << std::endl; 
    }
 
 
 if(fVerbosity>0) std::cout << "CastorChannelQualityMonitor::beginRun (end)" << std::endl;


 return;
}



//==========================================================//
//================== processEvent ==========================//
//==========================================================//
void CastorChannelQualityMonitor::processEvent(const CastorRecHitCollection& castorHits)
  {
  if(fVerbosity>0) std::cout << "CastorChannelQualityMonitor::processEvent (begin)" << std::endl;

  if(!m_dbe) { 
    if(fVerbosity>0) std::cout <<"CastorChannelQualityMonitor::processEvent => DQMStore is not instantiated !!!"<<std::endl;  
    return; 
  }

  if(fVerbosity>1){
     std::cout << "CastorChannelQualityMonitor: Noisy Threshold is set to: "<< nThreshold_ << std::endl;
     std::cout << "CastorChannelQualityMonitor: Dead Threshold is set to: " << dThreshold_ << std::endl;
    }

  castorModule = -1;  castorSector = -1; castorEnergy = -1.; 
  
  if (castorHits.size()>0) iRecHit=true;
  else iRecHit=false;
 
 
 for(CastorRecHitCollection::const_iterator recHit = castorHits.begin(); recHit != castorHits.end(); ++recHit){

    HcalCastorDetId CastorID = HcalCastorDetId(recHit->id());
    if(fVerbosity>1) std::cout << "Castor ID = " << CastorID << std::endl;
    CastorRecHitCollection::const_iterator rh = castorHits.find(CastorID);
    castorModule = CastorID.module();
    castorSector = CastorID.sector();
    castorEnergy = rh->energy();
    //if(ievt_ % 1000 == 0) std::cout << "==> module=" << module << " sector=" << sector << " energy= "<< energy << std::endl;
    iRecHit=true; 
   
    if(castorEnergy > nThreshold_) ++aboveNoisyThreshold[castorModule-1][castorSector-1];
    if(castorEnergy < dThreshold_) ++belowDThreshold[castorModule-1][castorSector-1];
    if(castorEnergy>1) { //if(castorEnergy>0) {
      ++aboveThr[castorModule-1][castorSector-1]; 
      energyArray[castorModule-1][castorSector-1]=energyArray[castorModule-1][castorSector-1]+castorEnergy;
    }

   }




  ievt_++;



  // if( (ievt_ == 25 || ievt_ % 500 == 0) && iRecHit ) {
  // no particular event selection done 
   if( iRecHit ) {
   
   status = -99;  numOK = 0; 

    // if(offline_) reportSummaryMap->Reset();


 for (int sector=0; sector<16; sector++){
  for (int module=0; module<14; module++){
  

   if(averageEnergyMethod_){

     if(aboveThr[module][sector] >0)
     averageEnergy= energyArray[module][sector]/double(aboveThr[module][sector]); // calculate the average energy in each channel
     else averageEnergy=0;
 
     if( averageEnergy >  nThreshold_ )  status= 0;   
     if( averageEnergy < dThreshold_  ) { status= -1;  
          if(fVerbosity>1) std::cout << "!!! dChannels ===> module="<< module+1 << " sector="<< sector+1 << std::endl;
      }
     if( averageEnergy <  nThreshold_ && averageEnergy > dThreshold_ )  status= 1; 

     if(fVerbosity>1)
      std::cout << "===> module="<< module+1 << " sector="<< sector+1 <<" *** average Energy=" 
       << averageEnergy << " => energy=" << energyArray[module][sector] << " events="
           << ievt_ << " aboveThr="<< double(aboveThr[module][sector]) <<std::endl;
    }


   else{
      //-- look at the arrays
      counter1= aboveNoisyThreshold[module][sector]; //counter1 defines how many times the energy was above a noisythreshold
      counter2= belowDThreshold[module][sector];  //counter2 defines how many times the energy was below a dthreshold
      wcounter1= double(counter1)/double(ievt_);
      wcounter2= double(counter2)/double(ievt_);
      if( wcounter1 > 0.85 )  status= 0; 
      if( wcounter2 > 0.85 ) {status= -1;  
         if(fVerbosity>1) std::cout << "!!! dChannels ===> module="<< module+1 << " sector="<< sector+1 << std::endl; 
    }
      if( wcounter1 < 0.85 && wcounter2 <  0.85 ) status= 1; 

      if(fVerbosity>1)
        std::cout << "===> module="<< module+1 << " sector="<< sector+1 <<" *** counter1=" 
        << counter1 << " => counter2=" << counter2 << " events="<< ievt_ 
        << " wcounter1=" << wcounter1  << " wcounter2=" <<  wcounter2
        << " *** ==> STATUS=" << status <<std::endl;      
    }

   // reportSummaryMap->Fill(module,sector,status);
   reportSummaryMap->getTH2F()->SetBinContent(module+1,sector+1,double(status));
   if (status == 1) numOK++;

      }
    }
  fraction=double(numOK)/224;
  overallStatus->Fill(fraction); reportSummary->Fill(fraction); 
  }
  
  if(fVerbosity>0) std::cout << "CastorChannelQualityMonitor::processEvent (end)" << std::endl;

  return;
}