DQMSourceEleCalib.cc

Go to the documentation of this file.

/*
 * \file DQMSourceEleCalib.cc
 *
 * \author Andrea Gozzelino - Universita  e INFN Torino
 * \author Stefano Argiro
 *        
 *
 *
 * Description: Monitoring of Phi Symmetry Calibration Stream  
*/


#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/ServiceRegistry/interface/Service.h"

// DQM include files

#include "DQMServices/Core/interface/MonitorElement.h"

// work on collections
#include "DataFormats/EcalDetId/interface/EBDetId.h"
#include "DataFormats/EcalDetId/interface/EEDetId.h"

#include "DataFormats/EcalRecHit/interface/EcalRecHit.h"

#include "DQMServices/Core/interface/DQMStore.h"
#include "DQMOffline/CalibCalo/interface/DQMSourceEleCalib.h"


using namespace std;
using namespace edm;


// ******************************************
// constructors
// *****************************************

DQMSourceEleCalib::DQMSourceEleCalib( const edm::ParameterSet& ps ) :
eventCounter_(0)
{
  folderName_ = ps.getUntrackedParameter<string>("FolderName","ALCAStreamEcalSingleEle");
  productMonitoredEB_= consumes<EcalRecHitCollection>(ps.getParameter<edm::InputTag>("AlCaStreamEBTag"));
  productMonitoredEE_= consumes<EcalRecHitCollection>(ps.getParameter<edm::InputTag>("AlCaStreamEETag"));

  saveToFile_=ps.getUntrackedParameter<bool>("SaveToFile",false);
  fileName_=  ps.getUntrackedParameter<string>("FileName","MonitorAlCaEcalSingleEle.root");
  productMonitoredElectrons_ = consumes<reco::GsfElectronCollection>(ps.getParameter<InputTag>("electronCollection"));
  prescaleFactor_ = ps.getUntrackedParameter<unsigned int>("prescaleFactor",1);

}


DQMSourceEleCalib::~DQMSourceEleCalib()
{}


//--------------------------------------------------------
void DQMSourceEleCalib::bookHistograms(DQMStore::IBooker & ibooker, edm::Run const & irun, edm::EventSetup const & isetup) {

  // create and cd into new folder
  ibooker.setCurrentFolder(folderName_);

  recHitsPerElectron_ = ibooker.book1D("recHitsPerElectron_","recHitPerElectron",
                    200,0,200);
  ElectronsNumber_ = ibooker.book1D("ElectronsNumber_","electrons in the event",
                   40,0,40);
  ESCoP_ = ibooker.book1D ("ESCoP","ESCoP",50,0,5);

  OccupancyEB_= ibooker.book2D("OccupancyEB_","OccupancyEB",360,1,361,171,-85,86);
  OccupancyEEP_= ibooker.book2D("OccupancyEEP_","Occupancy EE Plus",100,1,101,100,1,101);
  OccupancyEEM_= ibooker.book2D("OccupancyEEM_","Occupancy EE Minus",100,1,101,100,1,101);
  HitsVsAssociatedHits_ = ibooker.book1D ("HitsVsAssociatedHits_","HitsVsAssociatedHits",100,0,5);
  LocalOccupancyEB_ = ibooker.book2D ("LocalOccupancyEB_","Local occupancy Barrel",9,-4,5,9,-4,5); 
  LocalOccupancyEE_ = ibooker.book2D ("LocalOccupancyEE_","Local occupancy Endcap",9,-4,5,9,-4,5); 

}

//--------------------------------------------------------
void DQMSourceEleCalib::beginLuminosityBlock(const LuminosityBlock& lumiSeg, 
     const EventSetup& context) {
  
}

//-------------------------------------------------------------

void DQMSourceEleCalib::analyze(const Event& iEvent, 
                   const EventSetup& iSetup ){
 
//  if (eventCounter_% prescaleFactor_ ) return; //FIXME
  eventCounter_++;
  int numberOfHits=0;
  int numberOfElectrons=0;
  int numberOfAssociatedHits = 0;
  //reads the recHits
  edm::Handle<EcalRecHitCollection> rhEB;
  edm::Handle<EcalRecHitCollection> rhEE;
 
  iEvent.getByToken(productMonitoredEB_, rhEB);
  iEvent.getByToken(productMonitoredEE_, rhEE);

  EcalRecHitCollection::const_iterator itb;

  //reads the electrons
  edm::Handle<reco::GsfElectronCollection> pElectrons ;
  iEvent.getByToken (productMonitoredElectrons_, pElectrons) ;
  
  if (pElectrons.isValid()){
    ElectronsNumber_->Fill(pElectrons->size()+0.1);
    numberOfElectrons = pElectrons->size();
    for (reco::GsfElectronCollection::const_iterator eleIt = pElectrons->begin();
        eleIt!= pElectrons->end(); ++eleIt){
    ESCoP_->Fill(eleIt->eSuperClusterOverP());
    numberOfAssociatedHits+= eleIt->superCluster()->size();
    DetId Max = findMaxHit (eleIt->superCluster ()->hitsAndFractions (), 
                             rhEB.product(),  rhEE.product()) ;
    if (!Max.det()) continue;
    if (Max.subdetId()==EcalBarrel) {
        EBDetId EBMax (Max);
        fillAroundBarrel (rhEB.product(),EBMax.ieta(),EBMax.iphi());
    }
    if (Max.subdetId()==EcalEndcap) {
        EEDetId EEMax (Max);
        fillAroundEndcap (rhEE.product(),EEMax.ix(),EEMax.iy());
    }
   }
  }//is valid electron

  // fill EB histos
  if (rhEB.isValid())
  {
    numberOfHits+= rhEB->size();
    for(itb=rhEB->begin(); itb!=rhEB->end(); ++itb){
      EBDetId id(itb->id());
      OccupancyEB_->Fill(id.iphi(),id.ieta());
    } // Eb rechits
   } //is Valid
   if (rhEE.isValid())
   {
     numberOfHits+= rhEE->size();
     for (itb = rhEE->begin(); itb!=rhEE->end(); ++itb){
       EEDetId id (itb->id());
       if (id.zside()>0){
           OccupancyEEP_->Fill(id.ix(),id.iy());
       } //zside>0
       else if (id.zside()<0){
           OccupancyEEM_->Fill(id.ix(),id.iy());
       } //zside<0
      
    }//EE reChit
   }//is Valid
   if (numberOfElectrons) recHitsPerElectron_->Fill((double)numberOfHits/((double)numberOfElectrons));
   if (numberOfHits) HitsVsAssociatedHits_->Fill((double)numberOfAssociatedHits/((double)numberOfHits));
} //end of the analyzer




//--------------------------------------------------------
void DQMSourceEleCalib::endLuminosityBlock(const LuminosityBlock& lumiSeg, 
                                          const EventSetup& context) {
}

//------------------------------------------------


DetId
DQMSourceEleCalib::findMaxHit (const std::vector<std::pair<DetId,float> > & v1,
                               const EcalRecHitCollection* EBhits,
                               const EcalRecHitCollection* EEhits) 
{

  double currEnergy = 0. ;
  DetId maxHit ;
  for (std::vector<std::pair<DetId,float> >::const_iterator idsIt = v1.begin () ; 
       idsIt != v1.end () ; ++idsIt)
    {
            
     if (idsIt->first.subdetId () == EcalBarrel) 
       {              
         EcalRecHitCollection::const_iterator itrechit ;
         itrechit = EBhits->find ((*idsIt).first) ;
         if (itrechit == EBhits->end () )
           {
             edm::LogInfo ("reading")
             << "[findMaxHit] rechit not found! " ;
             continue ;
           }
//FIXME: wnat to use the fraction i.e. .second??
         if (itrechit->energy () > currEnergy)
           {
             currEnergy = itrechit->energy () ;
             maxHit= (*idsIt).first ;
           }
       }
     else 
       {     
         EcalRecHitCollection::const_iterator itrechit ;
         itrechit = EEhits->find ((*idsIt).first) ;
         if (itrechit == EEhits->end () )
           {
             edm::LogInfo ("reading")
             << "[findMaxHit] rechit not found! " ;
             continue ;
           }
              
//FIXME: wnat to use the fraction i.e. .second??
         if (itrechit->energy () > currEnergy)
           {
            currEnergy=itrechit->energy () ;
            maxHit= (*idsIt).first ;
           }
       }
    }
  return maxHit ;
}


void
DQMSourceEleCalib::fillAroundBarrel (const EcalRecHitCollection * recHits, int eta, int phi)
{

  for (EcalRecHitCollection::const_iterator elem = recHits->begin () ;
       elem != recHits->end () ;
       ++elem)
    {
      EBDetId elementId = elem->id () ; 
      LocalOccupancyEB_->Fill (
        elementId.ieta () - eta ,
        elementId.iphi () - phi ,
        elem->energy ()
      ) ;
    }   
  return ;
}


// ----------------------------------------------------------------


void
DQMSourceEleCalib::fillAroundEndcap (const EcalRecHitCollection * recHits, int ics, int ips)
{
  for (EcalRecHitCollection::const_iterator elem = recHits->begin () ;
       elem != recHits->end () ;
       ++elem)
    {
      EEDetId elementId = elem->id () ; 
      LocalOccupancyEE_->Fill (
        elementId.ix () - ics ,
        elementId.iy () - ips ,
        elem->energy ()
      ) ;
    }   
  return ;
}